@zealakit/css-doctor-cli 1.0.0 → 1.1.0

package/dist/index.js

@@ -3052,80 +3052,6 @@ var require_commander = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS({
-  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var p = process || {};
-    var argv = p.argv || [];
-    var env = p.env || {};
-    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-    var formatter = (open, close, replace = open) => (input) => {
-      let string = "" + input, index = string.indexOf(close, open.length);
-      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-    };
-    var replaceClose = (string, close, replace, index) => {
-      let result = "", cursor = 0;
-      do {
-        result += string.substring(cursor, index) + replace;
-        cursor = index + close.length;
-        index = string.indexOf(close, cursor);
-      } while (~index);
-      return result + string.substring(cursor);
-    };
-    var createColors = (enabled = isColorSupported) => {
-      let f = enabled ? formatter : () => String;
-      return {
-        isColorSupported: enabled,
-        reset: f("\x1B[0m", "\x1B[0m"),
-        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-        italic: f("\x1B[3m", "\x1B[23m"),
-        underline: f("\x1B[4m", "\x1B[24m"),
-        inverse: f("\x1B[7m", "\x1B[27m"),
-        hidden: f("\x1B[8m", "\x1B[28m"),
-        strikethrough: f("\x1B[9m", "\x1B[29m"),
-        black: f("\x1B[30m", "\x1B[39m"),
-        red: f("\x1B[31m", "\x1B[39m"),
-        green: f("\x1B[32m", "\x1B[39m"),
-        yellow: f("\x1B[33m", "\x1B[39m"),
-        blue: f("\x1B[34m", "\x1B[39m"),
-        magenta: f("\x1B[35m", "\x1B[39m"),
-        cyan: f("\x1B[36m", "\x1B[39m"),
-        white: f("\x1B[37m", "\x1B[39m"),
-        gray: f("\x1B[90m", "\x1B[39m"),
-        bgBlack: f("\x1B[40m", "\x1B[49m"),
-        bgRed: f("\x1B[41m", "\x1B[49m"),
-        bgGreen: f("\x1B[42m", "\x1B[49m"),
-        bgYellow: f("\x1B[43m", "\x1B[49m"),
-        bgBlue: f("\x1B[44m", "\x1B[49m"),
-        bgMagenta: f("\x1B[45m", "\x1B[49m"),
-        bgCyan: f("\x1B[46m", "\x1B[49m"),
-        bgWhite: f("\x1B[47m", "\x1B[49m"),
-        blackBright: f("\x1B[90m", "\x1B[39m"),
-        redBright: f("\x1B[91m", "\x1B[39m"),
-        greenBright: f("\x1B[92m", "\x1B[39m"),
-        yellowBright: f("\x1B[93m", "\x1B[39m"),
-        blueBright: f("\x1B[94m", "\x1B[39m"),
-        magentaBright: f("\x1B[95m", "\x1B[39m"),
-        cyanBright: f("\x1B[96m", "\x1B[39m"),
-        whiteBright: f("\x1B[97m", "\x1B[39m"),
-        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-        bgRedBright: f("\x1B[101m", "\x1B[49m"),
-        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-      };
-    };
-    module.exports = createColors();
-    module.exports.createColors = createColors;
-  }
-});
-
 // ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js
 var require_array = __commonJS({
   "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js"(exports) {
@@ -3803,7 +3729,7 @@ var require_fill_range = __commonJS({
       }
       return options.stringify === true;
     };
-    var pad = (input, maxLength, toNumber) => {
+    var pad4 = (input, maxLength, toNumber) => {
       if (maxLength > 0) {
         let dash = input[0] === "-" ? "-" : "";
         if (dash) input = input.slice(1);
@@ -3905,7 +3831,7 @@ var require_fill_range = __commonJS({
         if (options.toRegex === true && step > 1) {
           push(a);
         } else {
-          range.push(pad(format(a, index), maxLen, toNumber));
+          range.push(pad4(format(a, index), maxLen, toNumber));
         }
         a = descending ? a - step : a + step;
         index++;
@@ -6583,7 +6509,7 @@ var require_pattern = __commonJS({
       const absolute = [];
       const relative2 = [];
       for (const pattern of patterns) {
-        if (isAbsolute2(pattern)) {
+        if (isAbsolute3(pattern)) {
           absolute.push(pattern);
         } else {
           relative2.push(pattern);
@@ -6592,10 +6518,10 @@ var require_pattern = __commonJS({
       return [absolute, relative2];
     }
     exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
-    function isAbsolute2(pattern) {
+    function isAbsolute3(pattern) {
       return path2.isAbsolute(pattern);
     }
-    exports.isAbsolute = isAbsolute2;
+    exports.isAbsolute = isAbsolute3;
   }
 });
 
@@ -6899,7 +6825,7 @@ var require_async = __commonJS({
           callSuccessCallback(callback, lstat);
           return;
         }
-        settings.fs.stat(path2, (statError, stat2) => {
+        settings.fs.stat(path2, (statError, stat3) => {
           if (statError !== null) {
             if (settings.throwErrorOnBrokenSymbolicLink) {
               callFailureCallback(callback, statError);
@@ -6909,9 +6835,9 @@ var require_async = __commonJS({
             return;
           }
           if (settings.markSymbolicLink) {
-            stat2.isSymbolicLink = () => true;
+            stat3.isSymbolicLink = () => true;
           }
-          callSuccessCallback(callback, stat2);
+          callSuccessCallback(callback, stat3);
         });
       });
     }
@@ -6938,11 +6864,11 @@ var require_sync = __commonJS({
         return lstat;
       }
       try {
-        const stat2 = settings.fs.statSync(path2);
+        const stat3 = settings.fs.statSync(path2);
         if (settings.markSymbolicLink) {
-          stat2.isSymbolicLink = () => true;
+          stat3.isSymbolicLink = () => true;
         }
-        return stat2;
+        return stat3;
       } catch (error) {
         if (!settings.throwErrorOnBrokenSymbolicLink) {
           return lstat;
@@ -7012,14 +6938,14 @@ var require_out = __commonJS({
     var sync = require_sync();
     var settings_1 = require_settings();
     exports.Settings = settings_1.default;
-    function stat2(path2, optionsOrSettingsOrCallback, callback) {
+    function stat3(path2, optionsOrSettingsOrCallback, callback) {
       if (typeof optionsOrSettingsOrCallback === "function") {
         async.read(path2, getSettings(), optionsOrSettingsOrCallback);
         return;
       }
       async.read(path2, getSettings(optionsOrSettingsOrCallback), callback);
     }
-    exports.stat = stat2;
+    exports.stat = stat3;
     function statSync(path2, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path2, settings);
@@ -7705,41 +7631,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve3, reject) {
+        var p = new Promise(function(resolve9, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve3(result);
+            resolve9(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function unshift(value) {
-        var p = new Promise(function(resolve3, reject) {
+        var p = new Promise(function(resolve9, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve3(result);
+            resolve9(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function drained() {
-        var p = new Promise(function(resolve3) {
+        var p = new Promise(function(resolve9) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve3();
+              resolve9();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve3();
+                resolve9();
                 queue.drain = previousDrain;
               };
             }
@@ -8236,9 +8162,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve9, reject) => {
           this._stat(filepath, this._fsStatSettings, (error, stats) => {
-            return error === null ? resolve3(stats) : reject(error);
+            return error === null ? resolve9(stats) : reject(error);
           });
         });
       }
@@ -8263,10 +8189,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve9, reject) => {
           this._walkAsync(root, options, (error, entries) => {
             if (error === null) {
-              resolve3(entries);
+              resolve9(entries);
             } else {
               reject(error);
             }
@@ -8276,10 +8202,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve9, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve3(entries));
+          stream.once("end", () => resolve9(entries));
         });
       }
     };
@@ -8949,6 +8875,80 @@ var require_out4 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
 // src/index.ts
 init_esm_shims();
 
@@ -8973,8 +8973,30 @@ var {
 // package.json
 var package_default = {
   name: "@zealakit/css-doctor-cli",
-  version: "1.0.0",
+  version: "1.1.0",
   description: "Command line interface for css-doctor: CSS diagnostics from the terminal",
+  keywords: [
+    "css",
+    "css-doctor",
+    "cli",
+    "command-line",
+    "css-analysis",
+    "css-optimizer",
+    "dead-code-elimination",
+    "unused-css",
+    "purgecss",
+    "css-health",
+    "css-baseline",
+    "css-regression",
+    "css-splitting",
+    "page-coverage",
+    "devtools",
+    "ci",
+    "performance",
+    "web-performance",
+    "stylesheet",
+    "frontend"
+  ],
   author: "nqhed - Huy Edward Nguyen",
   type: "module",
   license: "MIT",
@@ -9027,11 +9049,9 @@ var package_default = {
   homepage: "https://github.com/zealakit/css-doctor#readme"
 };
 
-// src/commands/check.ts
+// src/commands/baseline.ts
 init_esm_shims();
-import { createRequire } from "module";
-import { performance } from "perf_hooks";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 
 // src/formatters/json.ts
 init_esm_shims();
@@ -9039,309 +9059,2734 @@ function formatJsonReport(report) {
   return JSON.stringify(report, null, 2);
 }
 
-// src/formatters/terminal.ts
+// src/utils/baseline-io.ts
 init_esm_shims();
-var import_picocolors = __toESM(require_picocolors(), 1);
-var TOP_SELECTOR_LIMIT = 5;
-function terminalExitCode(report) {
-  return report.success ? 0 : 1;
+import { mkdir, readFile as readFile2, unlink, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/utils/binding.ts
+init_esm_shims();
+import { createRequire } from "module";
+
+// src/utils/file.ts
+init_esm_shims();
+var import_fast_glob = __toESM(require_out4(), 1);
+import { readFile, stat } from "fs/promises";
+import { isAbsolute, relative, resolve, sep } from "path";
+var DEFAULT_IGNORES = ["**/node_modules/**", "**/.git/**"];
+async function isFile(filePath) {
+  try {
+    return (await stat(filePath)).isFile();
+  } catch {
+    return false;
+  }
 }
-function formatTerminalReport(report, options = {}) {
-  const colors = import_picocolors.default.createColors(
-    options.color ?? import_picocolors.default.isColorSupported
-  );
-  const lines = [];
-  const separator = colors.dim("\u2500".repeat(64));
-  lines.push(
-    `${colors.bold(colors.cyan("css-doctor"))} ${colors.dim(`v${report.version}`)} ${colors.dim("\xB7")} ${colors.dim("check")}`
-  );
-  lines.push(
-    `${colors.dim("patterns")} ${report.patterns.length > 0 ? report.patterns.join(", ") : "(none)"}`
-  );
-  lines.push(separator);
-  if (report.errors.length > 0) {
-    lines.push(colors.red(colors.bold("ERRORS")));
-    for (const error of report.errors) {
-      lines.push(`  ${colors.red("\u2716")} ${error}`);
-    }
-    lines.push("");
+async function isDirectory(directoryPath) {
+  try {
+    return (await stat(directoryPath)).isDirectory();
+  } catch {
+    return false;
   }
-  for (const file of report.files) {
-    lines.push(...formatFile(file, colors));
+}
+async function resolveCssFiles(patterns, cwd) {
+  const files = /* @__PURE__ */ new Set();
+  const globPatterns = [];
+  for (const pattern of patterns) {
+    const absolutePath = isAbsolute(pattern) ? pattern : resolve(cwd, pattern);
+    if (await isFile(absolutePath)) {
+      files.add(absolutePath);
+    } else {
+      globPatterns.push(pattern);
+    }
   }
-  if (report.files.length === 0 && report.errors.length === 0) {
-    lines.push(colors.yellow("No files were analyzed."));
-    lines.push("");
+  if (globPatterns.length > 0) {
+    const matches = await (0, import_fast_glob.default)(globPatterns, {
+      cwd,
+      absolute: true,
+      onlyFiles: true,
+      unique: true,
+      dot: false,
+      followSymbolicLinks: true,
+      ignore: DEFAULT_IGNORES
+    });
+    for (const match of matches) {
+      files.add(resolve(match));
+    }
   }
-  lines.push(separator);
-  lines.push(...formatSummary(report, colors));
-  return lines.join("\n");
+  return [...files].sort((left, right) => left.localeCompare(right));
 }
-function formatFile(file, colors) {
-  const status = fileStatus(file);
-  const lines = [];
-  lines.push(
-    `${statusBadge(status, colors)} ${colors.bold(file.path)} ${colors.dim(`\xB7 ${formatBytes(file.sizeBytes)}`)}`
-  );
-  if (!file.ok) {
-    lines.push(`  ${colors.red(file.error ?? "Unknown error")}`);
-    lines.push("");
-    return lines;
+async function readCssFile(filePath) {
+  try {
+    const buffer = await readFile(filePath);
+    return {
+      ok: true,
+      content: buffer.toString("utf8"),
+      sizeBytes: buffer.byteLength
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Failed to read "${filePath}": ${describeError(error)}`
+    };
   }
-  const result = file.result;
-  if (!result) {
-    lines.push(`  ${colors.red("No analysis result was returned.")}`);
-    lines.push("");
+}
+function toDisplayPath(filePath, cwd) {
+  const relativePath = relative(cwd, filePath);
+  const displayPath = relativePath.length > 0 ? relativePath : filePath;
+  return displayPath.split(sep).join("/");
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/utils/binding.ts
+var require2 = createRequire(import.meta.url);
+var cachedBinding;
+function loadBinding() {
+  if (cachedBinding) {
+    return cachedBinding;
+  }
+  try {
+    cachedBinding = require2("@zealakit/css-doctor-binding");
+    return cachedBinding;
+  } catch (error) {
+    throw new Error(
+      "Unable to load @zealakit/css-doctor-binding. Build it first with `pnpm --filter @zealakit/css-doctor-binding build`.\n" + describeError(error)
+    );
+  }
+}
+
+// src/utils/git-metadata.ts
+init_esm_shims();
+import { spawnSync } from "child_process";
+function readGitMetadata(cwd) {
+  try {
+    const commit = runGit(cwd, ["rev-parse", "HEAD"]);
+    const branch = runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const status = runGit(cwd, ["status", "--porcelain"]);
+    if (!commit && !branch) {
+      return {};
+    }
+    return {
+      commit: commit || void 0,
+      branch: branch || void 0,
+      dirty: status === void 0 ? void 0 : status.length > 0
+    };
+  } catch {
+    return {};
+  }
+}
+function runGit(cwd, args) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0 || typeof result.stdout !== "string") {
+    return void 0;
+  }
+  return result.stdout.trim();
+}
+
+// src/utils/baseline-io.ts
+async function createBaselineSnapshot(options) {
+  const cwd = options.cwd;
+  const errors = [];
+  if (options.patterns.length === 0) {
+    return {
+      ok: false,
+      errors: [
+        'No CSS files or glob patterns were provided. Example: css-doctor baseline create "src/**/*.css"'
+      ]
+    };
+  }
+  if (!await isDirectory(cwd)) {
+    return {
+      ok: false,
+      errors: [
+        `Working directory does not exist or is not a directory: ${cwd}`
+      ]
+    };
+  }
+  let files = [];
+  try {
+    files = await resolveCssFiles(options.patterns, cwd);
+  } catch (error) {
+    return {
+      ok: false,
+      errors: [`Failed to resolve CSS files: ${describeError(error)}`]
+    };
+  }
+  if (files.length === 0) {
+    return {
+      ok: false,
+      errors: [`No CSS files matched: ${options.patterns.join(", ")}`]
+    };
+  }
+  try {
+    const binding = loadBinding();
+    const batchFiles = [];
+    for (const file of files) {
+      const read = await readCssFile(file);
+      if (!read.ok) {
+        errors.push(`${toDisplayPath(file, cwd)}: ${read.error}`);
+        continue;
+      }
+      batchFiles.push({
+        path: toDisplayPath(file, cwd),
+        cssContent: read.content,
+        sizeBytes: read.sizeBytes
+      });
+    }
+    if (batchFiles.length === 0) {
+      return {
+        ok: false,
+        errors: errors.length > 0 ? errors : ["No CSS files could be read for baseline creation."]
+      };
+    }
+    const git = options.includeGit === false ? void 0 : readGitMetadata(cwd);
+    const json = binding.createBaseline({
+      files: batchFiles,
+      toolVersion: package_default.version,
+      createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      patterns: options.patterns,
+      threshold: options.threshold ?? void 0,
+      project: {
+        root: "."
+      },
+      git
+    });
+    const document = JSON.parse(json);
+    return {
+      ok: true,
+      json,
+      document,
+      files: batchFiles.length
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      errors: [...errors, describeError(error)]
+    };
+  }
+}
+async function readBaselineFile(absolutePath) {
+  try {
+    const json = await readFile2(absolutePath, "utf8");
+    return { ok: true, json };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return {
+        ok: false,
+        error: `Baseline not found at ${absolutePath}. Create one with \`css-doctor baseline create\`.`
+      };
+    }
+    return {
+      ok: false,
+      error: `Failed to read baseline ${absolutePath}: ${describeError(error)}`
+    };
+  }
+}
+async function writeBaselineFile(absolutePath, json) {
+  try {
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, `${json.trimEnd()}
+`, "utf8");
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Failed to write baseline ${absolutePath}: ${describeError(error)}`
+    };
+  }
+}
+async function removeBaselineFile(absolutePath) {
+  try {
+    await unlink(absolutePath);
+    return { ok: true };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return {
+        ok: false,
+        error: `Baseline not found at ${absolutePath}.`
+      };
+    }
+    return {
+      ok: false,
+      error: `Failed to remove baseline ${absolutePath}: ${describeError(error)}`
+    };
+  }
+}
+function validateBaselineJson(json, toolVersion = package_default.version) {
+  const binding = loadBinding();
+  return binding.validateBaseline(json, toolVersion);
+}
+
+// src/utils/config.ts
+init_esm_shims();
+import { readFile as readFile3 } from "fs/promises";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+var DEFAULT_BASELINE_PATH = ".css-doctor/baseline.json";
+var DEFAULT_CONFIG_PATH = ".css-doctor/config.json";
+var DEFAULT_CONFIG = {
+  baseline: DEFAULT_BASELINE_PATH,
+  patterns: [],
+  threshold: null,
+  regression: {
+    enabled: true,
+    scoreTolerance: 1,
+    sizeIncreasePercent: 10,
+    sizeAbsoluteToleranceBytes: 1024,
+    maxNewErrors: null,
+    maxNewWarnings: null
+  },
+  qualityGates: {
+    minScore: null,
+    maxCssSize: null,
+    maxSizeIncreasePercent: null,
+    maxNewErrors: null,
+    maxNewWarnings: null,
+    failOnRegression: false,
+    failOnNewErrors: false,
+    failOnNewDiagnostics: false
+  }
+};
+async function loadProjectConfig(cwd, configPath) {
+  const absoluteConfigPath = resolve2(cwd, configPath ?? DEFAULT_CONFIG_PATH);
+  const errors = [];
+  try {
+    const raw = await readFile3(absoluteConfigPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const config = normalizeConfig(parsed, errors);
+    return {
+      config,
+      path: absoluteConfigPath,
+      errors
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return {
+        config: structuredClone(DEFAULT_CONFIG),
+        path: null,
+        errors: []
+      };
+    }
+    return {
+      config: structuredClone(DEFAULT_CONFIG),
+      path: absoluteConfigPath,
+      errors: [
+        `Failed to load config ${absoluteConfigPath}: ${describeError(error)}`
+      ]
+    };
+  }
+}
+function resolveBaselinePath(cwd, baselinePath) {
+  return isAbsolute2(baselinePath) ? baselinePath : resolve2(cwd, baselinePath);
+}
+function normalizeConfig(value, errors) {
+  const config = structuredClone(DEFAULT_CONFIG);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    errors.push("Config root must be a JSON object.");
+    return config;
+  }
+  const root = value;
+  if (root.baseline !== void 0) {
+    if (typeof root.baseline !== "string" || root.baseline.trim() === "") {
+      errors.push("`baseline` must be a non-empty string path.");
+    } else {
+      config.baseline = root.baseline;
+    }
+  }
+  if (root.patterns !== void 0) {
+    if (!Array.isArray(root.patterns) || root.patterns.some((pattern) => typeof pattern !== "string")) {
+      errors.push("`patterns` must be an array of strings.");
+    } else {
+      config.patterns = root.patterns;
+    }
+  }
+  if (root.threshold !== void 0) {
+    if (typeof root.threshold !== "number" || !Number.isInteger(root.threshold) || root.threshold < 0) {
+      errors.push("`threshold` must be a non-negative integer.");
+    } else {
+      config.threshold = root.threshold;
+    }
+  }
+  if (root.regression !== void 0) {
+    Object.assign(
+      config.regression,
+      normalizeRegression(root.regression, errors)
+    );
+  }
+  if (root.qualityGates !== void 0) {
+    Object.assign(
+      config.qualityGates,
+      normalizeQualityGates(root.qualityGates, errors)
+    );
+  }
+  return config;
+}
+function normalizeRegression(value, errors) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    errors.push("`regression` must be an object.");
+    return {};
+  }
+  const source = value;
+  const result = {};
+  if (source.enabled !== void 0) {
+    if (typeof source.enabled !== "boolean") {
+      errors.push("`regression.enabled` must be a boolean.");
+    } else {
+      result.enabled = source.enabled;
+    }
+  }
+  assignNumber(
+    source,
+    "scoreTolerance",
+    result,
+    "scoreTolerance",
+    errors,
+    "`regression.scoreTolerance`",
+    { integer: true, min: 0, max: 100 }
+  );
+  assignNumber(
+    source,
+    "sizeIncreasePercent",
+    result,
+    "sizeIncreasePercent",
+    errors,
+    "`regression.sizeIncreasePercent`",
+    { min: 0 }
+  );
+  assignNumber(
+    source,
+    "sizeAbsoluteToleranceBytes",
+    result,
+    "sizeAbsoluteToleranceBytes",
+    errors,
+    "`regression.sizeAbsoluteToleranceBytes`",
+    { integer: true, min: 0 }
+  );
+  assignNullableInteger(
+    source,
+    "maxNewErrors",
+    result,
+    "maxNewErrors",
+    errors,
+    "`regression.maxNewErrors`"
+  );
+  assignNullableInteger(
+    source,
+    "maxNewWarnings",
+    result,
+    "maxNewWarnings",
+    errors,
+    "`regression.maxNewWarnings`"
+  );
+  return result;
+}
+function normalizeQualityGates(value, errors) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    errors.push("`qualityGates` must be an object.");
+    return {};
+  }
+  const source = value;
+  const result = {};
+  assignNullableInteger(
+    source,
+    "minScore",
+    result,
+    "minScore",
+    errors,
+    "`qualityGates.minScore`",
+    { max: 100 }
+  );
+  assignNullableInteger(
+    source,
+    "maxCssSize",
+    result,
+    "maxCssSize",
+    errors,
+    "`qualityGates.maxCssSize`"
+  );
+  assignNumber(
+    source,
+    "maxSizeIncreasePercent",
+    result,
+    "maxSizeIncreasePercent",
+    errors,
+    "`qualityGates.maxSizeIncreasePercent`",
+    { min: 0, nullable: true }
+  );
+  assignNullableInteger(
+    source,
+    "maxNewErrors",
+    result,
+    "maxNewErrors",
+    errors,
+    "`qualityGates.maxNewErrors`"
+  );
+  assignNullableInteger(
+    source,
+    "maxNewWarnings",
+    result,
+    "maxNewWarnings",
+    errors,
+    "`qualityGates.maxNewWarnings`"
+  );
+  for (const key of [
+    "failOnRegression",
+    "failOnNewErrors",
+    "failOnNewDiagnostics"
+  ]) {
+    if (source[key] !== void 0) {
+      if (typeof source[key] !== "boolean") {
+        errors.push(`\`qualityGates.${key}\` must be a boolean.`);
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+function assignNumber(source, sourceKey, target, targetKey, errors, label3, options = {}) {
+  if (source[sourceKey] === void 0) {
+    return;
+  }
+  if (options.nullable && source[sourceKey] === null) {
+    target[targetKey] = null;
+    return;
+  }
+  const value = source[sourceKey];
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    errors.push(`${label3} must be a number.`);
+    return;
+  }
+  if (options.integer && !Number.isInteger(value)) {
+    errors.push(`${label3} must be an integer.`);
+    return;
+  }
+  if (options.min !== void 0 && value < options.min) {
+    errors.push(`${label3} must be >= ${options.min}.`);
+    return;
+  }
+  if (options.max !== void 0 && value > options.max) {
+    errors.push(`${label3} must be <= ${options.max}.`);
+    return;
+  }
+  target[targetKey] = value;
+}
+function assignNullableInteger(source, sourceKey, target, targetKey, errors, label3, options = {}) {
+  if (source[sourceKey] === void 0) {
+    return;
+  }
+  if (source[sourceKey] === null) {
+    target[targetKey] = null;
+    return;
+  }
+  const value = source[sourceKey];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    errors.push(`${label3} must be a non-negative integer or null.`);
+    return;
+  }
+  if (options.max !== void 0 && value > options.max) {
+    errors.push(`${label3} must be <= ${options.max}.`);
+    return;
+  }
+  target[targetKey] = value;
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/commands/baseline.ts
+function registerBaselineCommand(program3) {
+  const baseline = program3.command("baseline").description("Create, inspect, validate, or remove a CSS quality baseline");
+  baseline.command("create").description("Create a baseline from the current CSS Health Score").argument(
+    "[patterns...]",
+    "CSS files or glob patterns (falls back to config.patterns)"
+  ).option(
+    "-o, --output <path>",
+    `Baseline output path (default: ${DEFAULT_BASELINE_PATH})`
+  ).option("--config <path>", "Project config path").option(
+    "--threshold <number>",
+    "Selector-count threshold stored with the baseline",
+    parseNonNegativeInteger
+  ).option("-j, --json", "Emit JSON instead of a human summary").action(async (patterns, options) => {
+    const report = await runBaselineCreate(patterns ?? [], options);
+    writeBaselineReport(report, options.json === true);
+    process.exitCode = report.success ? 0 : 1;
+  });
+  baseline.command("show").description("Display baseline metadata and scores").option(
+    "-b, --baseline <path>",
+    `Baseline path (default: ${DEFAULT_BASELINE_PATH})`
+  ).option("--config <path>", "Project config path").option("-j, --json", "Emit JSON instead of a human summary").action(async (options) => {
+    const report = await runBaselineShow(options);
+    writeBaselineReport(report, options.json === true);
+    process.exitCode = report.success ? 0 : 1;
+  });
+  baseline.command("validate").description("Validate baseline schema and compatibility").option(
+    "-b, --baseline <path>",
+    `Baseline path (default: ${DEFAULT_BASELINE_PATH})`
+  ).option("--config <path>", "Project config path").option("-j, --json", "Emit JSON instead of a human summary").action(async (options) => {
+    const report = await runBaselineValidate(options);
+    writeBaselineReport(report, options.json === true);
+    process.exitCode = report.success ? 0 : 1;
+  });
+  baseline.command("remove").description("Delete the baseline file").option(
+    "-b, --baseline <path>",
+    `Baseline path (default: ${DEFAULT_BASELINE_PATH})`
+  ).option("--config <path>", "Project config path").option("-j, --json", "Emit JSON instead of a human summary").action(async (options) => {
+    const report = await runBaselineRemove(options);
+    writeBaselineReport(report, options.json === true);
+    process.exitCode = report.success ? 0 : 1;
+  });
+}
+async function runBaselineCreate(patterns, options = {}) {
+  const cwd = resolve3(options.cwd ?? process.cwd());
+  const loaded = await loadProjectConfig(cwd, options.config);
+  const errors = [...loaded.errors];
+  const effectivePatterns = patterns.length > 0 ? patterns : loaded.config.patterns;
+  const baselinePath = resolveBaselinePath(
+    cwd,
+    options.output ?? loaded.config.baseline
+  );
+  const snapshot = await createBaselineSnapshot({
+    cwd,
+    patterns: effectivePatterns,
+    threshold: options.threshold ?? loaded.config.threshold
+  });
+  if (!snapshot.ok) {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action: "create",
+      success: false,
+      errors: [...errors, ...snapshot.errors],
+      warnings: [],
+      baselinePath: toDisplayPath(baselinePath, cwd),
+      baseline: null
+    };
+  }
+  const written = await writeBaselineFile(baselinePath, snapshot.json);
+  if (!written.ok) {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action: "create",
+      success: false,
+      errors: [...errors, written.error],
+      warnings: [],
+      baselinePath: toDisplayPath(baselinePath, cwd),
+      baseline: null
+    };
+  }
+  return {
+    schemaVersion: 1,
+    command: "baseline",
+    action: "create",
+    success: errors.length === 0,
+    errors,
+    warnings: [],
+    baselinePath: toDisplayPath(baselinePath, cwd),
+    baseline: snapshot.document
+  };
+}
+async function runBaselineShow(options = {}) {
+  return readAndReport("show", options);
+}
+async function runBaselineValidate(options = {}) {
+  const cwd = resolve3(options.cwd ?? process.cwd());
+  const loaded = await loadProjectConfig(cwd, options.config);
+  const errors = [...loaded.errors];
+  const warnings = [];
+  const baselinePath = resolveBaselinePath(
+    cwd,
+    options.baseline ?? loaded.config.baseline
+  );
+  const displayPath = toDisplayPath(baselinePath, cwd);
+  const read = await readBaselineFile(baselinePath);
+  if (!read.ok) {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action: "validate",
+      success: false,
+      errors: [...errors, read.error],
+      warnings,
+      baselinePath: displayPath,
+      baseline: null
+    };
+  }
+  try {
+    const validation = validateBaselineJson(read.json);
+    if (validation.status === "incompatible") {
+      errors.push(validation.message ?? "Baseline is incompatible.");
+    } else if (validation.status === "softWarning" && validation.message) {
+      warnings.push(validation.message);
+    }
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action: "validate",
+      success: errors.length === 0,
+      errors,
+      warnings,
+      baselinePath: displayPath,
+      baseline: JSON.parse(read.json)
+    };
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action: "validate",
+      success: false,
+      errors: [
+        ...errors,
+        error instanceof Error ? error.message : String(error)
+      ],
+      warnings,
+      baselinePath: displayPath,
+      baseline: null
+    };
+  }
+}
+async function runBaselineRemove(options = {}) {
+  const cwd = resolve3(options.cwd ?? process.cwd());
+  const loaded = await loadProjectConfig(cwd, options.config);
+  const errors = [...loaded.errors];
+  const baselinePath = resolveBaselinePath(
+    cwd,
+    options.baseline ?? loaded.config.baseline
+  );
+  const displayPath = toDisplayPath(baselinePath, cwd);
+  const removed = await removeBaselineFile(baselinePath);
+  if (!removed.ok) {
+    errors.push(removed.error);
+  }
+  return {
+    schemaVersion: 1,
+    command: "baseline",
+    action: "remove",
+    success: errors.length === 0,
+    errors,
+    warnings: [],
+    baselinePath: displayPath,
+    baseline: null
+  };
+}
+async function readAndReport(action, options) {
+  const cwd = resolve3(options.cwd ?? process.cwd());
+  const loaded = await loadProjectConfig(cwd, options.config);
+  const errors = [...loaded.errors];
+  const baselinePath = resolveBaselinePath(
+    cwd,
+    options.baseline ?? loaded.config.baseline
+  );
+  const displayPath = toDisplayPath(baselinePath, cwd);
+  const read = await readBaselineFile(baselinePath);
+  if (!read.ok) {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action,
+      success: false,
+      errors: [...errors, read.error],
+      warnings: [],
+      baselinePath: displayPath,
+      baseline: null
+    };
+  }
+  try {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action,
+      success: errors.length === 0,
+      errors,
+      warnings: [],
+      baselinePath: displayPath,
+      baseline: JSON.parse(read.json)
+    };
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      command: "baseline",
+      action,
+      success: false,
+      errors: [
+        ...errors,
+        `Corrupted baseline JSON at ${displayPath}: ${error instanceof Error ? error.message : String(error)}`
+      ],
+      warnings: [],
+      baselinePath: displayPath,
+      baseline: null
+    };
+  }
+}
+function writeBaselineReport(report, json) {
+  if (json) {
+    process.stdout.write(`${formatJsonReport(report)}
+`);
+    return;
+  }
+  if (!report.success) {
+    process.stdout.write(
+      `css-doctor baseline ${report.action} failed:
+${report.errors.map((error) => `  - ${error}`).join("\n")}
+`
+    );
+    return;
+  }
+  if (report.action === "remove") {
+    process.stdout.write(`Removed baseline ${report.baselinePath}
+`);
+    return;
+  }
+  if (report.action === "create") {
+    process.stdout.write(
+      `Created baseline ${report.baselinePath}` + (report.baseline ? ` \xB7 score ${report.baseline.health.overall}/100 \xB7 ${report.baseline.files.length} files
+` : "\n")
+    );
+  } else if (report.baseline) {
+    const health = report.baseline.health;
+    process.stdout.write(
+      [
+        `Baseline ${report.baselinePath}`,
+        `  schema ${report.baseline.schemaVersion} \xB7 tool ${report.baseline.toolVersion}`,
+        `  created ${report.baseline.createdAt}`,
+        `  score ${health.overall}/100 ${health.grade} (${health.status})`,
+        `  ${health.files} files \xB7 ${health.rules} rules \xB7 ${health.sizeBytes} bytes`,
+        ...report.warnings.map((warning) => `  warning: ${warning}`),
+        ""
+      ].join("\n")
+    );
+  }
+  for (const warning of report.warnings) {
+    if (report.action === "create") {
+      process.stderr.write(`css-doctor: ${warning}
+`);
+    }
+  }
+}
+function parseNonNegativeInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("must be a non-negative integer");
+  }
+  return parsed;
+}
+
+// src/commands/check.ts
+init_esm_shims();
+import { createRequire as createRequire2 } from "module";
+import { performance } from "perf_hooks";
+import { resolve as resolve4 } from "path";
+
+// src/formatters/health-terminal.ts
+init_esm_shims();
+var import_picocolors = __toESM(require_picocolors(), 1);
+var DEFAULT_TOP_ISSUES = 8;
+var BAR_WIDTH = 36;
+function formatHealthTerminalReport(report, options = {}) {
+  const colors = import_picocolors.default.createColors(
+    options.color ?? import_picocolors.default.isColorSupported
+  );
+  const columns = Math.max(
+    48,
+    Math.min(options.columns ?? detectColumns(), 88)
+  );
+  const topIssues = options.topIssues ?? DEFAULT_TOP_ISSUES;
+  const lines = [];
+  const rule = colors.dim("\u2500".repeat(Math.min(columns, 64)));
+  lines.push("");
+  lines.push(
+    `  ${colors.bold(colors.cyan("CSS DOCTOR"))}${pad(
+      columns - 22,
+      ""
+    )}${colors.dim("HEALTH REPORT")}`
+  );
+  lines.push("");
+  lines.push(`  ${colors.bold("Overall Health")}`);
+  lines.push("");
+  lines.push(
+    `       ${scoreColor(report.overall, colors)(colors.bold(`${report.overall}/100`))}   ${colors.bold(report.grade)}  ${statusLabel(report.status, colors)}`
+  );
+  lines.push("");
+  lines.push(`  ${scoreBar(report.overall, colors)}`);
+  lines.push("");
+  lines.push(
+    `  ${colors.dim(
+      `Analyzed ${report.summary.files} file${report.summary.files === 1 ? "" : "s"} \xB7 ${formatNumber(report.summary.rules)} rules \xB7 ${formatNumber(report.summary.declarations)} declarations`
+    )}`
+  );
+  lines.push(
+    `  ${colors.dim(
+      `Total size ${formatBytes(report.summary.sizeBytes)} \xB7 Analysis completed in ${formatDuration(report.summary.analysisMs)}`
+    )}`
+  );
+  lines.push("");
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${colors.bold("HEALTH BREAKDOWN")}`);
+  lines.push("");
+  for (const dimension of report.dimensions) {
+    const label3 = dimensionLabel(dimension.id).padEnd(24);
+    const scoreText = dimension.score === void 0 || dimension.score === null ? "  n/a" : `${String(dimension.score).padStart(3, " ")}/100`;
+    const bar = dimension.score === void 0 || dimension.score === null ? colors.dim("\u2591".repeat(20)) : miniBar(dimension.score, colors);
+    lines.push(`  ${label3}${scoreText}  ${bar}`);
+  }
+  lines.push("");
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${colors.bold("DIAGNOSTICS")}`);
+  lines.push("");
+  lines.push(
+    `  ${colors.red("\u2716")}  ${report.summary.errors} Error${report.summary.errors === 1 ? "" : "s"}`
+  );
+  lines.push(
+    `  ${colors.yellow("\u25B2")}  ${report.summary.warnings} Warning${report.summary.warnings === 1 ? "" : "s"}`
+  );
+  lines.push(
+    `  ${colors.cyan("\u25CF")}  ${report.summary.suggestions} Suggestion${report.summary.suggestions === 1 ? "" : "s"}`
+  );
+  if (report.diagnostics.length > 0) {
+    lines.push("");
+    lines.push(`  ${colors.bold("TOP ISSUES")}`);
+    lines.push("");
+    const shown = report.diagnostics.slice(0, topIssues);
+    for (const diagnostic of shown) {
+      const marker = diagnostic.severity === "error" ? colors.red("\u2716") : diagnostic.severity === "warning" ? colors.yellow("\u25B2") : colors.cyan("\u25CF");
+      lines.push(`  ${marker}  ${colors.bold(titleFromCode(diagnostic.code))}`);
+      const where = [
+        diagnostic.filePath,
+        diagnostic.location ? `${diagnostic.location.line}:${diagnostic.location.column}` : void 0
+      ].filter(Boolean).join(":");
+      if (where) {
+        lines.push(`     ${colors.dim(where)}`);
+      }
+      if (diagnostic.selector) {
+        lines.push(`     ${colors.magenta(diagnostic.selector)}`);
+      }
+      lines.push(`     ${colors.dim(diagnostic.remediation)}`);
+      lines.push("");
+    }
+    if (report.diagnostics.length > shown.length) {
+      lines.push(
+        `  ${colors.dim(
+          `\u2026 and ${report.diagnostics.length - shown.length} more (see --json for full list)`
+        )}`
+      );
+      lines.push("");
+    }
+  }
+  if (report.recommendations.length > 0) {
+    lines.push(`  ${colors.bold("RECOMMENDATIONS")}`);
+    lines.push("");
+    report.recommendations.forEach((recommendation, index) => {
+      lines.push(`  ${index + 1}. ${recommendation}`);
+    });
+    lines.push("");
+  }
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${finalStatusLine(report, colors)}`);
+  lines.push("");
+  lines.push(
+    `  ${colors.dim("Run `css-doctor health --help` for more options.")}`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function formatCompactHealthSummary(report, options = {}) {
+  const colors = import_picocolors.default.createColors(
+    options.color ?? import_picocolors.default.isColorSupported
+  );
+  return `${colors.bold("Health")} ${scoreColor(
+    report.overall,
+    colors
+  )(
+    `${report.overall}/100`
+  )} ${colors.bold(report.grade)} ${colors.dim(`(${report.status})`)} ${colors.dim("\xB7")} ${report.summary.errors} err ${colors.dim("\xB7")} ${report.summary.warnings} warn ${colors.dim("\xB7")} ${report.summary.suggestions} info`;
+}
+function finalStatusLine(report, colors) {
+  if (report.overall >= 90) {
+    return `${colors.green(colors.bold("HEALTHY"))}  CSS quality is within recommended limits.`;
+  }
+  if (report.overall >= 70) {
+    return `${colors.yellow(colors.bold("NEEDS ATTENTION"))}  Address the top warnings before release.`;
+  }
+  return `${colors.red(colors.bold("CRITICAL"))}  CSS quality is below recommended limits.`;
+}
+function scoreColor(score, colors) {
+  if (score >= 90) {
+    return colors.green;
+  }
+  if (score >= 70) {
+    return colors.yellow;
+  }
+  return colors.red;
+}
+function statusLabel(status, colors) {
+  const label3 = status.charAt(0).toUpperCase() + status.slice(1);
+  if (status === "excellent" || status === "good") {
+    return colors.green(label3);
+  }
+  if (status === "fair") {
+    return colors.yellow(label3);
+  }
+  return colors.red(label3);
+}
+function scoreBar(score, colors) {
+  const filled = Math.round(score / 100 * BAR_WIDTH);
+  const empty = Math.max(0, BAR_WIDTH - filled);
+  return `${scoreColor(score, colors)("\u2588".repeat(filled))}${colors.dim("\u2591".repeat(empty))}`;
+}
+function miniBar(score, colors) {
+  const width = 20;
+  const filled = Math.round(score / 100 * width);
+  return `${scoreColor(score, colors)("\u2588".repeat(filled))}${colors.dim("\u2591".repeat(width - filled))}`;
+}
+function dimensionLabel(id) {
+  switch (id) {
+    case "selectorComplexity":
+      return "Selector Complexity";
+    case "duplicateRules":
+      return "Duplicate Rules";
+    case "cssSizeEfficiency":
+      return "CSS Size Efficiency";
+    case "deadCss":
+      return "Dead CSS";
+    case "variableConsistency":
+      return "Variable Consistency";
+    default:
+      return id;
+  }
+}
+function titleFromCode(code) {
+  const leaf = code.split(".").pop() ?? code;
+  return leaf.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function detectColumns() {
+  const columns = process.stdout.columns;
+  return typeof columns === "number" && columns > 0 ? columns : 80;
+}
+function pad(width, text) {
+  return " ".repeat(Math.max(1, width - text.length));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function formatDuration(ms) {
+  if (ms < 1) {
+    return `${ms.toFixed(2)} ms`;
+  }
+  if (ms < 1e3) {
+    return `${ms.toFixed(1)} ms`;
+  }
+  return `${(ms / 1e3).toFixed(2)} s`;
+}
+function formatNumber(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+
+// src/formatters/terminal.ts
+init_esm_shims();
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var TOP_SELECTOR_LIMIT = 5;
+function terminalExitCode(report) {
+  return report.success ? 0 : 1;
+}
+function formatTerminalReport(report, options = {}) {
+  const colors = import_picocolors2.default.createColors(
+    options.color ?? import_picocolors2.default.isColorSupported
+  );
+  const lines = [];
+  const separator = colors.dim("\u2500".repeat(64));
+  lines.push(
+    `${colors.bold(colors.cyan("css-doctor"))} ${colors.dim(`v${report.version}`)} ${colors.dim("\xB7")} ${colors.dim("check")}`
+  );
+  lines.push(
+    `${colors.dim("patterns")} ${report.patterns.length > 0 ? report.patterns.join(", ") : "(none)"}`
+  );
+  lines.push(separator);
+  if (report.errors.length > 0) {
+    lines.push(colors.red(colors.bold("ERRORS")));
+    for (const error of report.errors) {
+      lines.push(`  ${colors.red("\u2716")} ${error}`);
+    }
+    lines.push("");
+  }
+  for (const file of report.files) {
+    lines.push(...formatFile(file, colors));
+  }
+  if (report.files.length === 0 && report.errors.length === 0) {
+    lines.push(colors.yellow("No files were analyzed."));
+    lines.push("");
+  }
+  lines.push(separator);
+  lines.push(...formatSummary(report, colors));
+  return lines.join("\n");
+}
+function formatFile(file, colors) {
+  const status = fileStatus(file);
+  const lines = [];
+  lines.push(
+    `${statusBadge(status, colors)} ${colors.bold(file.path)} ${colors.dim(`\xB7 ${formatBytes2(file.sizeBytes)}`)}`
+  );
+  if (!file.ok) {
+    lines.push(`  ${colors.red(file.error ?? "Unknown error")}`);
+    lines.push("");
     return lines;
   }
-  const { stats } = result;
+  const result = file.result;
+  if (!result) {
+    lines.push(`  ${colors.red("No analysis result was returned.")}`);
+    lines.push("");
+    return lines;
+  }
+  const { stats } = result;
+  lines.push(
+    `  ${colors.dim("selectors")} ${stats.selectorCount} ${colors.dim("\xB7")} ${colors.dim("rules")} ${stats.ruleCount} ${colors.dim("\xB7")} ${colors.dim("declarations")} ${stats.declarationCount + stats.importantDeclarationCount}`
+  );
+  lines.push(
+    `  ${colors.dim("analysis")} ${formatDuration2(file.analysisMs)} ${colors.dim("\xB7")} ${colors.dim("read")} ${formatDuration2(file.readMs)} ${colors.dim("\xB7")} ${colors.dim("total")} ${formatDuration2(file.totalMs)}`
+  );
+  if (file.issues.length > 0) {
+    lines.push("");
+    lines.push(
+      `  ${colors.yellow("\u26A0")} ${colors.bold("Diagnostics")} ${colors.dim(`(${file.issues.length})`)}`
+    );
+    for (const issue of file.issues) {
+      lines.push(`    ${formatIssue(issue, colors)}`);
+    }
+  }
+  if (result.selectors.length > 0) {
+    lines.push("");
+    lines.push(...formatTopSelectors(result, colors));
+  }
+  lines.push("");
+  return lines;
+}
+function formatTopSelectors(result, colors) {
+  const top = topSelectors(result.selectors, TOP_SELECTOR_LIMIT);
+  const total = result.selectors.length;
+  const heading = total > top.length ? `Top selectors (${top.length} of ${total})` : `Top selectors (${total})`;
+  const lines = [`  ${colors.bold(heading)}`];
+  top.forEach((selector, index) => {
+    const frequency = selector.count > 1 ? ` ${colors.yellow(`\xD7${selector.count}`)}` : "";
+    lines.push(
+      `    ${colors.dim(`${String(index + 1).padStart(2, " ")}.`)} ${selector.raw}${frequency} ${colors.dim(`(${selector.specificity})`)}`
+    );
+  });
+  return lines;
+}
+function topSelectors(selectors, limit) {
+  const entries = /* @__PURE__ */ new Map();
+  selectors.forEach((selector, index) => {
+    const existing = entries.get(selector.raw);
+    if (existing) {
+      existing.count += 1;
+      return;
+    }
+    entries.set(selector.raw, {
+      raw: selector.raw,
+      count: 1,
+      firstIndex: index,
+      specificity: `${selector.specificity.ids},${selector.specificity.classes},${selector.specificity.types}`
+    });
+  });
+  return [...entries.values()].sort(
+    (left, right) => right.count - left.count || left.firstIndex - right.firstIndex
+  ).slice(0, limit);
+}
+function formatIssue(issue, colors) {
+  const location = issue.location ? `${issue.location.line}:${issue.location.column}` : "\u2014";
+  const tag = issue.kind === "syntax" ? colors.yellow("syntax") : issue.kind === "threshold" ? colors.yellow("threshold") : issue.kind === "empty-rule" ? colors.magenta("dead code") : colors.magenta("duplicate");
+  return `${colors.dim(location.padEnd(7))} ${tag}  ${issue.message}`;
+}
+function formatSummary(report, colors) {
+  const { summary } = report;
+  const status = reportStatus(report);
+  const lines = [];
+  lines.push(
+    `${statusBadge(status, colors)} ${summary.files} file${summary.files === 1 ? "" : "s"} ${colors.dim("\xB7")} ${formatBytes2(summary.totalSizeBytes)} ${colors.dim("\xB7")} ${summary.selectors} selectors ${colors.dim("\xB7")} ${formatDuration2(summary.totalMs)}`
+  );
+  lines.push(
+    `  ${colors.dim("analyzed")} ${summary.analyzed} ${colors.dim("\xB7")} ${colors.dim("failed")} ${summary.failed} ${colors.dim("\xB7")} ${colors.dim("warnings")} ${summary.warnings} ${colors.dim("\xB7")} ${colors.dim("hints")} ${summary.hints}`
+  );
+  lines.push(
+    `  ${colors.dim("rules")} ${summary.rules} ${colors.dim("\xB7")} ${colors.dim("declarations")} ${summary.declarations} ${colors.dim("\xB7")} ${colors.dim("analysis")} ${formatDuration2(summary.analysisMs)}`
+  );
+  if (report.threshold !== null) {
+    lines.push(`  ${colors.dim("selector threshold")} ${report.threshold}`);
+  }
+  return lines;
+}
+function fileStatus(file) {
+  if (!file.ok) {
+    return "ERROR";
+  }
+  return file.issues.length > 0 ? "WARNING" : "SUCCESS";
+}
+function reportStatus(report) {
+  if (!report.success || report.errors.length > 0 || report.summary.failed > 0) {
+    return "ERROR";
+  }
+  return report.summary.issues > 0 ? "WARNING" : "SUCCESS";
+}
+function statusBadge(status, colors) {
+  switch (status) {
+    case "SUCCESS":
+      return colors.bgGreen(colors.black(" SUCCESS "));
+    case "WARNING":
+      return colors.bgYellow(colors.black(" WARNING "));
+    case "ERROR":
+      return colors.bgRed(colors.white(" ERROR "));
+  }
+}
+function formatBytes2(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDuration2(milliseconds) {
+  if (!Number.isFinite(milliseconds)) {
+    return "\u2014";
+  }
+  return milliseconds < 1 ? `${milliseconds.toFixed(2)} ms` : `${milliseconds.toFixed(1)} ms`;
+}
+
+// src/commands/check.ts
+var require3 = createRequire2(import.meta.url);
+var cachedBinding2;
+function loadBinding2() {
+  if (cachedBinding2) {
+    return cachedBinding2;
+  }
+  try {
+    cachedBinding2 = require3("@zealakit/css-doctor-binding");
+    return cachedBinding2;
+  } catch (error) {
+    throw new Error(
+      "Unable to load @zealakit/css-doctor-binding. Build it first with `pnpm --filter @zealakit/css-doctor-binding build`.\n" + describeError(error)
+    );
+  }
+}
+function registerCheckCommand(program3) {
+  program3.command("check").description("Analyze CSS files and report diagnostics").argument(
+    "[patterns...]",
+    "CSS files or glob patterns (quote globs to let css-doctor expand them)"
+  ).option("-j, --json", "Output raw JSON for piping and CI/CD").option(
+    "--threshold <number>",
+    "Warn when a file contains more than <number> selectors",
+    parseThreshold
+  ).option(
+    "--fail-under <number>",
+    "Exit with code 1 when overall health score is below <number> (0-100)",
+    parseScore
+  ).action(async (patterns, options) => {
+    const report = await runCheck(patterns ?? [], {
+      threshold: options.threshold,
+      failUnder: options.failUnder
+    });
+    if (options.json === true) {
+      process.stdout.write(`${formatJsonReport(report)}
+`);
+    } else {
+      let output = formatTerminalReport(report);
+      if (report.health) {
+        output += `
+${formatCompactHealthSummary(report.health)}
+`;
+      }
+      process.stdout.write(`${output}
+`);
+    }
+    process.exitCode = terminalExitCode(report);
+  });
+}
+function parseThreshold(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("threshold must be a non-negative integer");
+  }
+  return parsed;
+}
+function parseScore(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) {
+    throw new InvalidArgumentError("must be an integer between 0 and 100");
+  }
+  return parsed;
+}
+async function runCheck(patterns, options = {}) {
+  const startedAt = performance.now();
+  const cwd = resolve4(options.cwd ?? process.cwd());
+  const threshold = options.threshold ?? null;
+  const failUnder = options.failUnder ?? null;
+  const errors = [];
+  const results = [];
+  let files = [];
+  if (threshold !== null && (!Number.isInteger(threshold) || threshold < 0)) {
+    errors.push("Threshold must be a non-negative integer.");
+  }
+  if (failUnder !== null && (failUnder < 0 || failUnder > 100)) {
+    errors.push("--fail-under must be an integer between 0 and 100.");
+  }
+  if (patterns.length === 0) {
+    errors.push(
+      'No CSS files or glob patterns were provided. Example: css-doctor check "src/**/*.css"'
+    );
+  } else if (!await isDirectory(cwd)) {
+    errors.push(
+      `Working directory does not exist or is not a directory: ${cwd}`
+    );
+  } else {
+    try {
+      files = await resolveCssFiles(patterns, cwd);
+      if (files.length === 0) {
+        errors.push(`No CSS files matched: ${patterns.join(", ")}`);
+      }
+    } catch (error) {
+      errors.push(`Failed to resolve CSS files: ${describeError(error)}`);
+    }
+  }
+  let health = null;
+  if (errors.length === 0) {
+    try {
+      const binding = loadBinding2();
+      const analyze = binding.analyzeCss;
+      for (const file of files) {
+        results.push(await checkFile(file, cwd, threshold, analyze));
+      }
+      const healthFiles = [];
+      for (const file of files) {
+        const read = await readCssFile(file);
+        if (!read.ok) {
+          continue;
+        }
+        healthFiles.push({
+          cssContent: read.content,
+          filePath: toDisplayPath(file, cwd),
+          sizeBytes: read.sizeBytes
+        });
+      }
+      if (healthFiles.length > 0) {
+        health = binding.evaluateCssHealthBatch({
+          files: healthFiles,
+          thresholds: threshold === null ? void 0 : {
+            manySelectors: threshold
+          }
+        });
+      }
+    } catch (error) {
+      errors.push(describeError(error));
+    }
+  }
+  const issues = results.flatMap((file) => file.issues);
+  const warnings = issues.filter((issue) => issue.kind === "syntax").length;
+  const analyzed = results.filter((file) => file.ok).length;
+  const failed = results.length - analyzed;
+  const summary = {
+    files: results.length,
+    analyzed,
+    failed,
+    filesWithIssues: results.filter((file) => file.issues.length > 0).length,
+    totalSizeBytes: results.reduce((total, file) => total + file.sizeBytes, 0),
+    rules: sum(results, (file) => file.result?.stats.ruleCount ?? 0),
+    selectors: sum(results, (file) => file.result?.stats.selectorCount ?? 0),
+    declarations: sum(
+      results,
+      (file) => (file.result?.stats.declarationCount ?? 0) + (file.result?.stats.importantDeclarationCount ?? 0)
+    ),
+    warnings,
+    hints: issues.length - warnings,
+    issues: issues.length,
+    analysisMs: roundMs(
+      results.reduce((total, file) => total + file.analysisMs, 0)
+    ),
+    totalMs: elapsedMs(startedAt)
+  };
+  const belowFloor = failUnder !== null && health !== null && health.overall < failUnder ? [
+    `Overall health score ${health.overall} is below --fail-under ${failUnder}.`
+  ] : [];
+  return {
+    schemaVersion: 1,
+    command: "check",
+    version: package_default.version,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd,
+    patterns,
+    threshold,
+    failUnder,
+    success: errors.length === 0 && failed === 0 && belowFloor.length === 0,
+    errors: [...errors, ...belowFloor],
+    files: results,
+    summary,
+    health
+  };
+}
+async function checkFile(filePath, cwd, threshold, analyze) {
+  const path2 = toDisplayPath(filePath, cwd);
+  const readStartedAt = performance.now();
+  const read = await readCssFile(filePath);
+  const readMs = elapsedMs(readStartedAt);
+  if (!read.ok) {
+    return {
+      path: path2,
+      absolutePath: filePath,
+      sizeBytes: 0,
+      ok: false,
+      totalMs: readMs,
+      readMs,
+      analysisMs: 0,
+      issues: [],
+      error: read.error
+    };
+  }
+  const analysisStartedAt = performance.now();
+  try {
+    const result = analyze(read.content);
+    const analysisMs = elapsedMs(analysisStartedAt);
+    return {
+      path: path2,
+      absolutePath: filePath,
+      sizeBytes: read.sizeBytes,
+      ok: true,
+      totalMs: roundMs(readMs + analysisMs),
+      readMs,
+      analysisMs,
+      issues: collectIssues(result, threshold),
+      result
+    };
+  } catch (error) {
+    const analysisMs = elapsedMs(analysisStartedAt);
+    return {
+      path: path2,
+      absolutePath: filePath,
+      sizeBytes: read.sizeBytes,
+      ok: false,
+      totalMs: roundMs(readMs + analysisMs),
+      readMs,
+      analysisMs,
+      issues: [],
+      error: `Failed to analyze file: ${describeError(error)}`
+    };
+  }
+}
+function collectIssues(result, threshold) {
+  const issues = [];
+  for (const warning of result.warnings) {
+    issues.push({
+      kind: "syntax",
+      severity: "warning",
+      message: warning.message,
+      ...warning.location ? { location: warning.location } : {}
+    });
+  }
+  const parentRuleIndices = new Set(
+    result.rules.map((rule) => rule.parentRuleIndex).filter((index) => index !== void 0)
+  );
+  for (const rule of result.rules) {
+    const hasNoDeclarations = rule.declarationCount === 0 && rule.importantDeclarationCount === 0;
+    const hasNoNestedRules = !parentRuleIndices.has(rule.index);
+    if (hasNoDeclarations && hasNoNestedRules) {
+      const selectorText = rule.selectorIndices.map((index) => result.selectors[index]?.raw).filter((value) => value !== void 0).join(", ");
+      issues.push({
+        kind: "empty-rule",
+        severity: "warning",
+        message: selectorText.length > 0 ? `Rule "${selectorText}" has no declarations and no nested rules (dead code candidate).` : "Rule has no declarations and no nested rules (dead code candidate).",
+        location: rule.location,
+        ...selectorText.length > 0 ? { selector: selectorText } : {}
+      });
+    }
+  }
+  const seenSelectors = /* @__PURE__ */ new Map();
+  for (const selector of result.selectors) {
+    const first = seenSelectors.get(selector.raw);
+    if (!first) {
+      seenSelectors.set(selector.raw, selector);
+      continue;
+    }
+    const firstRule = result.rules[first.ruleIndex];
+    const currentRule = result.rules[selector.ruleIndex];
+    issues.push({
+      kind: "duplicate-selector",
+      severity: "warning",
+      message: `Selector "${selector.raw}" is defined in multiple rules` + (firstRule ? ` (first at line ${firstRule.location.line})` : "") + "; verify whether this is intentional.",
+      ...currentRule ? { location: currentRule.location } : {},
+      selector: selector.raw
+    });
+  }
+  if (threshold !== null && result.selectors.length > threshold) {
+    issues.push({
+      kind: "threshold",
+      severity: "warning",
+      message: `Selector threshold exceeded: ${result.selectors.length} selectors found (threshold: ${threshold}).`
+    });
+  }
+  return issues.sort(compareIssues);
+}
+function compareIssues(left, right) {
+  const leftLine = left.location?.line ?? Number.MAX_SAFE_INTEGER;
+  const rightLine = right.location?.line ?? Number.MAX_SAFE_INTEGER;
+  const lineDifference = leftLine - rightLine;
+  if (lineDifference !== 0) {
+    return lineDifference;
+  }
+  const columnDifference = (left.location?.column ?? 0) - (right.location?.column ?? 0);
+  if (columnDifference !== 0) {
+    return columnDifference;
+  }
+  return left.kind.localeCompare(right.kind);
+}
+function sum(files, select) {
+  return files.reduce((total, file) => total + select(file), 0);
+}
+function elapsedMs(startedAt) {
+  return roundMs(performance.now() - startedAt);
+}
+function roundMs(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+
+// src/commands/diff.ts
+init_esm_shims();
+import { resolve as resolve5 } from "path";
+
+// src/formatters/regression-terminal.ts
+init_esm_shims();
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+function formatRegressionTerminalReport(report, options = {}) {
+  const colors = import_picocolors3.default.createColors(
+    options.color ?? import_picocolors3.default.isColorSupported
+  );
+  const columns = Math.max(
+    48,
+    Math.min(options.columns ?? detectColumns2(), 88)
+  );
+  const verbose = options.verbose === true;
+  const lines = [];
+  const rule = colors.dim("\u2500".repeat(Math.min(columns, 64)));
+  lines.push("");
+  lines.push(
+    `  ${colors.bold(colors.cyan("CSS DOCTOR"))}${pad2(
+      columns - 28,
+      ""
+    )}${colors.dim("REGRESSION REPORT")}`
+  );
+  lines.push("");
+  lines.push(`  ${colors.bold("Overall Health")}`);
+  lines.push("");
+  lines.push(
+    `       ${scoreColor2(
+      report.current.score,
+      colors
+    )(
+      colors.bold(`${report.current.score}/100`)
+    )}   ${colors.bold(report.current.grade)}  ${statusWord(
+      report.current.status,
+      colors
+    )}`
+  );
+  lines.push("");
+  lines.push(`  ${label("Baseline").padEnd(14)}${report.baseline.score}/100`);
+  lines.push(`  ${label("Current").padEnd(14)}${report.current.score}/100`);
+  lines.push(
+    `  ${label("Change").padEnd(14)}${formatSigned(
+      report.changes.score,
+      "points",
+      colors
+    )}`
+  );
+  lines.push("");
+  lines.push(`  ${statusBanner(report.status, colors)}`);
+  lines.push("");
+  lines.push(
+    `  ${colors.dim(
+      `Analyzed ${report.current.files} files \xB7 ${formatNumber2(report.current.rules)} rules \xB7 ${formatNumber2(report.current.declarations)} declarations`
+    )}`
+  );
+  if (report.warnings.length > 0) {
+    lines.push("");
+    for (const warning of report.warnings) {
+      lines.push(`  ${colors.yellow("!")} ${colors.dim(warning)}`);
+    }
+  }
+  lines.push("");
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${colors.bold("DIMENSION COMPARISON")}`);
+  lines.push("");
   lines.push(
-    `  ${colors.dim("selectors")} ${stats.selectorCount} ${colors.dim("\xB7")} ${colors.dim("rules")} ${stats.ruleCount} ${colors.dim("\xB7")} ${colors.dim("declarations")} ${stats.declarationCount + stats.importantDeclarationCount}`
+    `  ${"Dimension".padEnd(26)}${"Baseline".padStart(8)}  ${"Current".padStart(8)}  ${"Change".padStart(7)}`
   );
+  lines.push("");
+  for (const dimension of report.changes.dimensions) {
+    lines.push(`  ${formatDimensionRow(dimension, colors)}`);
+  }
+  lines.push("");
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${colors.bold("CSS SIZE ANALYSIS")}`);
+  lines.push("");
   lines.push(
-    `  ${colors.dim("analysis")} ${formatDuration(file.analysisMs)} ${colors.dim("\xB7")} ${colors.dim("read")} ${formatDuration(file.readMs)} ${colors.dim("\xB7")} ${colors.dim("total")} ${formatDuration(file.totalMs)}`
+    `  ${formatMetricLine(
+      "Total size",
+      formatBytes3(report.changes.cssSize.baseline),
+      formatBytes3(report.changes.cssSize.current),
+      report.changes.cssSize.changePercent,
+      colors
+    )}`
   );
-  if (file.issues.length > 0) {
+  lines.push(
+    `  ${formatMetricLine(
+      "Rules",
+      formatNumber2(report.changes.rules.baseline),
+      formatNumber2(report.changes.rules.current),
+      report.changes.rules.changePercent,
+      colors
+    )}`
+  );
+  lines.push(
+    `  ${formatMetricLine(
+      "Declarations",
+      formatNumber2(report.changes.declarations.baseline),
+      formatNumber2(report.changes.declarations.current),
+      report.changes.declarations.changePercent,
+      colors
+    )}`
+  );
+  const largest = [...report.files.modified].filter((file) => (file.sizeChangePercent ?? 0) > 0).sort(
+    (left, right) => (right.sizeChangePercent ?? 0) - (left.sizeChangePercent ?? 0)
+  ).slice(0, verbose ? 10 : 3);
+  if (largest.length > 0) {
+    lines.push("");
+    lines.push(`  ${colors.bold("LARGEST INCREASES")}`);
+    lines.push("");
+    for (const file of largest) {
+      lines.push(`  ${file.path}`);
+      lines.push(
+        `    ${formatBytes3(file.baselineSizeBytes ?? 0)} \u2192 ${formatBytes3(
+          file.currentSizeBytes ?? 0
+        )}    ${formatPercent(file.sizeChangePercent, colors)}`
+      );
+      lines.push("");
+    }
+  }
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${colors.bold("DIAGNOSTIC CHANGES")}`);
+  lines.push("");
+  lines.push(
+    `  ${colors.red("+")} ${report.diagnostics.new.length} New issues`
+  );
+  lines.push(
+    `  ${colors.green("-")} ${report.diagnostics.resolved.length} Resolved issues`
+  );
+  lines.push(
+    `  ${colors.dim("=")} ${report.diagnostics.persistent.length} Persistent issues`
+  );
+  const newIssues = report.diagnostics.new.slice(0, verbose ? 20 : 5);
+  if (newIssues.length > 0) {
+    lines.push("");
+    lines.push(`  ${colors.bold("NEW ISSUES")}`);
+    lines.push("");
+    for (const diagnostic of newIssues) {
+      const marker = diagnostic.severity === "error" ? colors.red("\u2716") : colors.yellow("\u25B2");
+      lines.push(`  ${marker} ${colors.bold(titleFromCode2(diagnostic.code))}`);
+      const where = [diagnostic.filePath, diagnostic.selector].filter(Boolean).join(" \xB7 ");
+      if (where) {
+        lines.push(`    ${colors.dim(where)}`);
+      }
+    }
+    if (report.diagnostics.new.length > newIssues.length) {
+      lines.push("");
+      lines.push(
+        `  ${colors.dim(
+          `\u2026 and ${report.diagnostics.new.length - newIssues.length} more`
+        )}`
+      );
+    }
+  }
+  if (report.files.added.length > 0 || report.files.removed.length > 0 || report.files.regressed.length > 0) {
+    lines.push("");
+    lines.push(rule);
+    lines.push("");
+    lines.push(`  ${colors.bold("FILE CHANGES")}`);
     lines.push("");
     lines.push(
-      `  ${colors.yellow("\u26A0")} ${colors.bold("Diagnostics")} ${colors.dim(`(${file.issues.length})`)}`
+      `  + ${report.files.added.length} added \xB7 - ${report.files.removed.length} removed \xB7 ~ ${report.files.modified.length} modified`
     );
-    for (const issue of file.issues) {
-      lines.push(`    ${formatIssue(issue, colors)}`);
+    if (verbose) {
+      for (const file of report.files.added.slice(0, 10)) {
+        lines.push(`  ${colors.green("+")} ${file.path}`);
+      }
+      for (const file of report.files.removed.slice(0, 10)) {
+        lines.push(`  ${colors.red("-")} ${file.path}`);
+      }
+      for (const file of report.files.regressed.slice(0, 10)) {
+        lines.push(`  ${colors.yellow("~")} ${file.path} (size growth)`);
+      }
+    }
+  }
+  if (report.qualityGates && report.qualityGates.results.length > 0) {
+    lines.push("");
+    lines.push(rule);
+    lines.push("");
+    lines.push(...formatQualityGates(report.qualityGates, colors));
+  }
+  lines.push("");
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${finalStatusLine2(report.status, colors)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatQualityGates(gates, colors) {
+  const lines = [`  ${colors.bold("QUALITY GATES")}`, ""];
+  for (const result of gates.results) {
+    const marker = result.passed ? colors.green("\u2713") : colors.red("\u2717");
+    lines.push(
+      `  ${marker} ${result.label.padEnd(26)} ${colors.dim(result.detail)}`
+    );
+  }
+  lines.push("");
+  lines.push(
+    `  RESULT: ${gates.passed ? colors.green(colors.bold("PASSED")) : colors.red(colors.bold("FAILED"))}`
+  );
+  if (!gates.passed && gates.failureSummary) {
+    lines.push("");
+    lines.push(`  ${gates.failureSummary}`);
+  }
+  return lines;
+}
+function formatDimensionRow(dimension, colors) {
+  const labelText = dimensionLabel2(dimension.id).padEnd(26);
+  const baseline = dimension.baseline === null || dimension.baseline === void 0 ? "n/a".padStart(8) : String(dimension.baseline).padStart(8);
+  const current = dimension.current === null || dimension.current === void 0 ? "n/a".padStart(8) : String(dimension.current).padStart(8);
+  const changeText = dimension.change === null || dimension.change === void 0 ? "n/a" : dimension.change > 0 ? `+${dimension.change}` : `${dimension.change}`;
+  const meaningful = dimension.change !== null && dimension.change !== void 0 && Math.abs(dimension.change) > 1;
+  const changeColored = dimension.change === null || dimension.change === void 0 ? colors.dim(changeText.padStart(7)) : dimension.change > 0 ? colors.green(changeText.padStart(7)) : dimension.change < 0 ? colors.red(changeText.padStart(7)) : colors.dim(changeText.padStart(7));
+  const row = `${labelText}${baseline}  ${current}  ${changeColored}`;
+  return meaningful ? row : colors.dim(
+    `${labelText}${baseline}  ${current}  ${changeText.padStart(7)}`
+  );
+}
+function formatMetricLine(labelText, baseline, current, percent, colors) {
+  return `${labelText.padEnd(14)}${baseline} \u2192 ${current}   ${formatPercent(
+    percent,
+    colors
+  )}`;
+}
+function statusBanner(status, colors) {
+  const text = `STATUS: ${status.toUpperCase()}`;
+  switch (status) {
+    case "healthy":
+    case "improved":
+      return colors.green(colors.bold(text));
+    case "mixed":
+    case "inconclusive":
+      return colors.yellow(colors.bold(text));
+    case "regressed":
+      return colors.red(colors.bold(text));
+    default:
+      return colors.bold(text);
+  }
+}
+function finalStatusLine2(status, colors) {
+  switch (status) {
+    case "healthy":
+      return `${colors.green(colors.bold("HEALTHY"))}  No meaningful CSS regression detected.`;
+    case "improved":
+      return `${colors.green(colors.bold("IMPROVED"))}  CSS quality improved relative to baseline.`;
+    case "mixed":
+      return `${colors.yellow(colors.bold("MIXED"))}  Improvements and regressions coexist.`;
+    case "inconclusive":
+      return `${colors.yellow(colors.bold("INCONCLUSIVE"))}  Insufficient comparable data.`;
+    case "regressed":
+      return `${colors.red(colors.bold("REGRESSED"))}  CSS quality deteriorated relative to baseline.`;
+    default:
+      return status;
+  }
+}
+function scoreColor2(score, colors) {
+  if (score >= 90) {
+    return colors.green;
+  }
+  if (score >= 70) {
+    return colors.yellow;
+  }
+  return colors.red;
+}
+function statusWord(status, colors) {
+  const labelText = status.charAt(0).toUpperCase() + status.slice(1);
+  if (status === "excellent" || status === "good") {
+    return colors.green(labelText);
+  }
+  if (status === "fair") {
+    return colors.yellow(labelText);
+  }
+  return colors.red(labelText);
+}
+function formatSigned(value, unit, colors) {
+  return `${formatSignedNumber(value, colors)} ${unit}`;
+}
+function formatSignedNumber(value, colors) {
+  const text = value > 0 ? `+${value}` : `${value}`;
+  if (value > 0) {
+    return colors.green(text);
+  }
+  if (value < 0) {
+    return colors.red(text);
+  }
+  return colors.dim(text);
+}
+function formatPercent(value, colors) {
+  if (value === null || value === void 0) {
+    return colors.dim("n/a");
+  }
+  const text = `${value > 0 ? "+" : ""}${value.toFixed(1)}%`;
+  if (value > 0) {
+    return colors.red(text);
+  }
+  if (value < 0) {
+    return colors.green(text);
+  }
+  return colors.dim(text);
+}
+function dimensionLabel2(id) {
+  switch (id) {
+    case "selectorComplexity":
+      return "Selector Complexity";
+    case "duplicateRules":
+      return "Duplicate Rules";
+    case "cssSizeEfficiency":
+      return "CSS Size Efficiency";
+    case "deadCss":
+      return "Dead CSS";
+    case "variableConsistency":
+      return "Variable Consistency";
+    default:
+      return id;
+  }
+}
+function titleFromCode2(code) {
+  const leaf = code.split(".").pop() ?? code;
+  return leaf.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function detectColumns2() {
+  const columns = process.stdout.columns;
+  return typeof columns === "number" && columns > 0 ? columns : 80;
+}
+function pad2(width, text) {
+  return " ".repeat(Math.max(1, width - text.length));
+}
+function label(text) {
+  return text;
+}
+function formatBytes3(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function formatNumber2(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+
+// src/commands/diff.ts
+function registerDiffCommand(program3) {
+  program3.command("diff").description("Compare current CSS quality against a committed baseline").argument(
+    "[patterns...]",
+    "CSS files or glob patterns (falls back to config.patterns or baseline patterns)"
+  ).option(
+    "-b, --baseline <path>",
+    `Baseline path (default: ${DEFAULT_BASELINE_PATH})`
+  ).option("--config <path>", "Project config path").option(
+    "--threshold <number>",
+    "Selector-count threshold for current analysis",
+    parseNonNegativeInteger2
+  ).option("--fail-on-regression", "Exit 1 when status is regressed or mixed").option("--fail-on-new-errors", "Exit 1 when new error diagnostics appear").option(
+    "--fail-on-new-diagnostics",
+    "Exit 1 when any new diagnostics appear"
+  ).option(
+    "--max-size-increase <value>",
+    "Fail when CSS size grows by more than this percent (e.g. 10 or 10%)",
+    parsePercent
+  ).option(
+    "--max-new-errors <number>",
+    "Fail when new error count exceeds this value",
+    parseNonNegativeInteger2
+  ).option(
+    "--max-new-warnings <number>",
+    "Fail when new warning count exceeds this value",
+    parseNonNegativeInteger2
+  ).option(
+    "--min-score <number>",
+    "Fail when current overall score is below this value",
+    parseScore2
+  ).option(
+    "--score-tolerance <number>",
+    "Ignore overall/dimension score deltas within this absolute tolerance",
+    parseNonNegativeInteger2
+  ).option("-v, --verbose", "Show detailed file and diagnostic lists").option("-j, --json", "Output raw JSON for piping and CI/CD").action(async (patterns, options) => {
+    const report = await runDiff(patterns ?? [], options);
+    if (options.json === true) {
+      process.stdout.write(`${formatJsonReport(report)}
+`);
+    } else if (report.regression) {
+      process.stdout.write(
+        `${formatRegressionTerminalReport(report.regression, {
+          verbose: options.verbose === true
+        })}
+`
+      );
+      if (report.errors.length > 0) {
+        process.stderr.write(
+          `css-doctor: ${report.errors.join("\ncss-doctor: ")}
+`
+        );
+      }
+    } else {
+      process.stdout.write(
+        `css-doctor diff failed:
+${report.errors.map((error) => `  - ${error}`).join("\n")}
+`
+      );
+    }
+    process.exitCode = report.success ? 0 : 1;
+  });
+}
+async function runDiff(patterns, options = {}) {
+  const cwd = resolve5(options.cwd ?? process.cwd());
+  const loaded = await loadProjectConfig(cwd, options.config);
+  const errors = [...loaded.errors];
+  const warnings = [];
+  const baselinePath = resolveBaselinePath(
+    cwd,
+    options.baseline ?? loaded.config.baseline
+  );
+  const displayPath = toDisplayPath(baselinePath, cwd);
+  const stored = await readBaselineFile(baselinePath);
+  if (!stored.ok) {
+    return {
+      schemaVersion: 1,
+      command: "diff",
+      success: false,
+      errors: [...errors, stored.error],
+      warnings,
+      baselinePath: displayPath,
+      regression: null
+    };
+  }
+  try {
+    const validation = validateBaselineJson(stored.json);
+    if (validation.status === "incompatible") {
+      return {
+        schemaVersion: 1,
+        command: "diff",
+        success: false,
+        errors: [
+          ...errors,
+          validation.message ?? "Baseline is incompatible with this tool version."
+        ],
+        warnings,
+        baselinePath: displayPath,
+        regression: null
+      };
+    }
+    if (validation.status === "softWarning" && validation.message) {
+      warnings.push(validation.message);
+    }
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      command: "diff",
+      success: false,
+      errors: [
+        ...errors,
+        error instanceof Error ? error.message : String(error)
+      ],
+      warnings,
+      baselinePath: displayPath,
+      regression: null
+    };
+  }
+  let baselinePatterns = [];
+  try {
+    const parsed = JSON.parse(stored.json);
+    baselinePatterns = parsed.config?.patterns ?? [];
+  } catch {
+    baselinePatterns = [];
+  }
+  const effectivePatterns = patterns.length > 0 ? patterns : options.patterns && options.patterns.length > 0 ? options.patterns : loaded.config.patterns.length > 0 ? loaded.config.patterns : baselinePatterns;
+  const current = await createBaselineSnapshot({
+    cwd,
+    patterns: effectivePatterns,
+    threshold: options.threshold ?? loaded.config.threshold
+  });
+  if (!current.ok) {
+    return {
+      schemaVersion: 1,
+      command: "diff",
+      success: false,
+      errors: [...errors, ...current.errors],
+      warnings,
+      baselinePath: displayPath,
+      regression: null
+    };
+  }
+  try {
+    const binding = loadBinding();
+    const compareOptions = {
+      scoreTolerance: options.scoreTolerance ?? loaded.config.regression.scoreTolerance,
+      sizeAbsoluteToleranceBytes: loaded.config.regression.sizeAbsoluteToleranceBytes,
+      sizeIncreasePercent: loaded.config.regression.sizeIncreasePercent
+    };
+    const gates = buildGateConfig(options, loaded.config);
+    const regressionJson = binding.compareBaselines(
+      stored.json,
+      current.json,
+      compareOptions,
+      gates
+    );
+    const regression = JSON.parse(regressionJson);
+    warnings.push(...regression.warnings ?? []);
+    const gateFailed = regression.qualityGates ? regression.qualityGates.passed === false : false;
+    const setupOk = errors.length === 0;
+    return {
+      schemaVersion: 1,
+      command: "diff",
+      success: setupOk && !gateFailed,
+      errors: [
+        ...errors,
+        ...gateFailed && regression.qualityGates?.failureSummary ? [`Quality gates failed: ${regression.qualityGates.failureSummary}`] : []
+      ],
+      warnings,
+      baselinePath: displayPath,
+      regression
+    };
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      command: "diff",
+      success: false,
+      errors: [
+        ...errors,
+        error instanceof Error ? error.message : String(error)
+      ],
+      warnings,
+      baselinePath: displayPath,
+      regression: null
+    };
+  }
+}
+function buildGateConfig(options, config) {
+  const maxSizeIncrease = options.maxSizeIncrease !== void 0 ? typeof options.maxSizeIncrease === "number" ? options.maxSizeIncrease : parsePercent(String(options.maxSizeIncrease)) : config.qualityGates.maxSizeIncreasePercent ?? config.regression.sizeIncreasePercent;
+  const minScore = options.minScore ?? config.qualityGates.minScore ?? void 0;
+  const maxNewErrors = options.maxNewErrors ?? config.qualityGates.maxNewErrors ?? config.regression.maxNewErrors ?? void 0;
+  const maxNewWarnings = options.maxNewWarnings ?? config.qualityGates.maxNewWarnings ?? config.regression.maxNewWarnings ?? void 0;
+  const failOnRegression = options.failOnRegression === true || config.qualityGates.failOnRegression === true;
+  const failOnNewErrors = options.failOnNewErrors === true || config.qualityGates.failOnNewErrors === true;
+  const failOnNewDiagnostics = options.failOnNewDiagnostics === true || config.qualityGates.failOnNewDiagnostics === true;
+  const gates = {};
+  if (minScore !== null && minScore !== void 0) {
+    gates.minScore = minScore;
+  }
+  if (options.maxSizeIncrease !== void 0 || config.qualityGates.maxSizeIncreasePercent !== null || failOnRegression) {
+    if (options.maxSizeIncrease !== void 0 || config.qualityGates.maxSizeIncreasePercent !== null) {
+      gates.maxSizeIncreasePercent = maxSizeIncrease ?? void 0;
+    }
+  }
+  if (maxNewErrors !== null && maxNewErrors !== void 0) {
+    gates.maxNewErrors = maxNewErrors;
+  }
+  if (maxNewWarnings !== null && maxNewWarnings !== void 0) {
+    gates.maxNewWarnings = maxNewWarnings;
+  }
+  if (failOnRegression) {
+    gates.failOnRegression = true;
+  }
+  if (failOnNewErrors) {
+    gates.failOnNewErrors = true;
+  }
+  if (failOnNewDiagnostics) {
+    gates.failOnNewDiagnostics = true;
+  }
+  return gates;
+}
+function parseNonNegativeInteger2(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("must be a non-negative integer");
+  }
+  return parsed;
+}
+function parseScore2(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) {
+    throw new InvalidArgumentError("must be an integer between 0 and 100");
+  }
+  return parsed;
+}
+function parsePercent(value) {
+  const trimmed = value.trim().endsWith("%") ? value.trim().slice(0, -1) : value.trim();
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("must be a non-negative percent (e.g. 10%)");
+  }
+  return parsed;
+}
+
+// src/commands/fix.ts
+init_esm_shims();
+import { stat as stat2 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+
+// src/formatters/optimization-terminal.ts
+init_esm_shims();
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+function formatOptimizationTerminalReport(report, options = {}) {
+  const colors = import_picocolors4.default.createColors(
+    options.color ?? import_picocolors4.default.isColorSupported
+  );
+  const columns = Math.max(
+    48,
+    Math.min(options.columns ?? detectColumns3(), 88)
+  );
+  const verbose = options.verbose === true;
+  const lines = [];
+  const rule = colors.dim("\u2500".repeat(Math.min(columns, 64)));
+  lines.push("");
+  lines.push(
+    `  ${colors.bold(colors.cyan("CSS DOCTOR"))}${pad3(
+      columns - 30,
+      ""
+    )}${colors.dim(
+      options.dryRun === true ? "OPTIMIZATION PREVIEW" : "OPTIMIZATION REPORT"
+    )}`
+  );
+  lines.push("");
+  lines.push(
+    `  ${colors.bold(
+      options.dryRun === true ? "Optimization preview" : "Optimization completed"
+    )}`
+  );
+  lines.push("");
+  lines.push(
+    `  ${label2("Original size").padEnd(20)}${formatBytes4(report.input.bytes)}`
+  );
+  lines.push(
+    `  ${label2("Emitted total").padEnd(20)}${formatBytes4(report.output.bytes)}`
+  );
+  const eliminated = report.impact.bytesEliminated;
+  const elimPct = report.impact.eliminationPercent;
+  lines.push(
+    `  ${label2("Eliminated").padEnd(20)}${formatSignedBytes(eliminated, colors)}${elimPct === null || elimPct === void 0 ? "" : colors.dim(
+      `  (${elimPct > 0 ? "+" : ""}${elimPct.toFixed(1)}% vs reference)`
+    )}`
+  );
+  if (report.impact.redistributedBytes !== 0) {
+    lines.push(
+      `  ${colors.dim(
+        `Redistributed (split duplication): ${formatSignedBytes(report.impact.redistributedBytes, colors)}`
+      )}`
+    );
+  }
+  lines.push("");
+  lines.push(`  ${label2("Files analyzed").padEnd(20)}${report.input.files}`);
+  lines.push(
+    `  ${label2("Output chunks").padEnd(20)}${report.impact.chunksCreated}`
+  );
+  lines.push(
+    `  ${label2("Selectors removed").padEnd(20)}${report.impact.selectorsRemoved}`
+  );
+  lines.push(
+    `  ${label2("Variables chunks").padEnd(20)}${report.impact.variablesChunks}`
+  );
+  lines.push("");
+  lines.push(
+    `  ${colors.dim(`Processing time  ${formatDuration3(report.analysisMs)}`)}`
+  );
+  lines.push("");
+  lines.push(rule);
+  lines.push("");
+  lines.push(`  ${colors.bold("OPTIMIZATION BREAKDOWN")}`);
+  lines.push("");
+  lines.push(
+    `  ${statusLine("Minification", report.operations.minified, colors)}`
+  );
+  lines.push(
+    `  ${statusLine("Page coverage splitting", report.operations.pageCoverageSplit, colors)}`
+  );
+  lines.push(
+    `  ${statusLine("Size budget splitting", report.operations.sizeBudgetSplit, colors)}`
+  );
+  lines.push(
+    `  ${statusLine("Variable isolation", report.operations.variablesIsolated, colors)}`
+  );
+  lines.push(
+    `  ${statusLine("Dead CSS elimination", report.operations.deadCodeEliminated, colors)}`
+  );
+  if (report.chunks.length > 0) {
+    lines.push("");
+    lines.push(`  ${colors.bold("OUTPUT DISTRIBUTION")}`);
+    lines.push("");
+    const shown = report.chunks.slice(0, verbose ? 20 : 8);
+    for (const chunk of shown) {
+      const mark = chunk.oversized ? colors.yellow("\u25B2") : colors.dim("\xB7");
+      lines.push(
+        `  ${mark} ${chunk.name.padEnd(24)} ${formatBytes4(chunk.sizeBytes)}`
+      );
+    }
+    if (report.chunks.length > shown.length) {
+      lines.push(
+        `  ${colors.dim(`\u2026 and ${report.chunks.length - shown.length} more chunks`)}`
+      );
+    }
+  }
+  const decisions = report.decisions.slice(0, verbose ? 30 : 8);
+  if (decisions.length > 0) {
+    lines.push("");
+    lines.push(rule);
+    lines.push("");
+    lines.push(`  ${colors.bold("OPTIMIZATION DECISIONS")}`);
+    lines.push("");
+    for (const decision of decisions) {
+      lines.push(...formatDecision(decision, colors));
+    }
+    if (report.decisions.length > decisions.length) {
+      lines.push(
+        `  ${colors.dim(
+          `\u2026 and ${report.decisions.length - decisions.length} more (use --verbose or --json)`
+        )}`
+      );
+    }
+  }
+  if (report.warnings.length > 0) {
+    lines.push("");
+    for (const warning of report.warnings) {
+      lines.push(`  ${colors.yellow("!")} ${warning}`);
     }
   }
-  if (result.selectors.length > 0) {
+  if (options.dryRun === true) {
     lines.push("");
-    lines.push(...formatTopSelectors(result, colors));
-  }
-  lines.push("");
-  return lines;
-}
-function formatTopSelectors(result, colors) {
-  const top = topSelectors(result.selectors, TOP_SELECTOR_LIMIT);
-  const total = result.selectors.length;
-  const heading = total > top.length ? `Top selectors (${top.length} of ${total})` : `Top selectors (${total})`;
-  const lines = [`  ${colors.bold(heading)}`];
-  top.forEach((selector, index) => {
-    const frequency = selector.count > 1 ? ` ${colors.yellow(`\xD7${selector.count}`)}` : "";
+    lines.push(rule);
+    lines.push("");
+    lines.push(`  ${colors.bold("No files were modified.")}`);
     lines.push(
-      `    ${colors.dim(`${String(index + 1).padStart(2, " ")}.`)} ${selector.raw}${frequency} ${colors.dim(`(${selector.specificity})`)}`
+      `  ${colors.dim("Run without --dry-run and with --out-dir to emit chunks.")}`
     );
-  });
-  return lines;
-}
-function topSelectors(selectors, limit) {
-  const entries = /* @__PURE__ */ new Map();
-  selectors.forEach((selector, index) => {
-    const existing = entries.get(selector.raw);
-    if (existing) {
-      existing.count += 1;
-      return;
-    }
-    entries.set(selector.raw, {
-      raw: selector.raw,
-      count: 1,
-      firstIndex: index,
-      specificity: `${selector.specificity.ids},${selector.specificity.classes},${selector.specificity.types}`
-    });
-  });
-  return [...entries.values()].sort(
-    (left, right) => right.count - left.count || left.firstIndex - right.firstIndex
-  ).slice(0, limit);
-}
-function formatIssue(issue, colors) {
-  const location = issue.location ? `${issue.location.line}:${issue.location.column}` : "\u2014";
-  const tag = issue.kind === "syntax" ? colors.yellow("syntax") : issue.kind === "threshold" ? colors.yellow("threshold") : issue.kind === "empty-rule" ? colors.magenta("dead code") : colors.magenta("duplicate");
-  return `${colors.dim(location.padEnd(7))} ${tag}  ${issue.message}`;
+  }
+  lines.push("");
+  return lines.join("\n");
 }
-function formatSummary(report, colors) {
-  const { summary } = report;
-  const status = reportStatus(report);
+function formatFixTerminalReport(results, options = {}) {
+  const colors = import_picocolors4.default.createColors(
+    options.color ?? import_picocolors4.default.isColorSupported
+  );
+  const columns = Math.max(
+    48,
+    Math.min(options.columns ?? detectColumns3(), 88)
+  );
   const lines = [];
+  const rule = colors.dim("\u2500".repeat(Math.min(columns, 64)));
+  const safe = results.reduce((sum2, result) => sum2 + result.plan.safeCount, 0);
+  const review = results.reduce(
+    (sum2, result) => sum2 + result.plan.reviewCount,
+    0
+  );
+  const unsafe = results.reduce(
+    (sum2, result) => sum2 + result.plan.unsafeCount,
+    0
+  );
+  const applied = results.reduce(
+    (sum2, result) => sum2 + result.plan.items.filter((item) => item.applied).length,
+    0
+  );
+  const changedFiles = results.filter((result) => result.changed).length;
+  const issues = results.reduce(
+    (sum2, result) => sum2 + result.plan.items.length,
+    0
+  );
+  lines.push("");
   lines.push(
-    `${statusBadge(status, colors)} ${summary.files} file${summary.files === 1 ? "" : "s"} ${colors.dim("\xB7")} ${formatBytes(summary.totalSizeBytes)} ${colors.dim("\xB7")} ${summary.selectors} selectors ${colors.dim("\xB7")} ${formatDuration(summary.totalMs)}`
+    `  ${colors.bold(colors.cyan("CSS DOCTOR"))}${pad3(
+      columns - 22,
+      ""
+    )}${colors.dim("FIX REPORT")}`
   );
+  lines.push("");
+  lines.push(`  ${colors.bold("Fix analysis completed")}`);
+  lines.push("");
+  lines.push(`  ${issues} issues detected`);
+  lines.push(`  ${safe} safe fixes available`);
+  lines.push(`  ${review} review-required fixes`);
+  lines.push(`  ${unsafe} unsafe fixes skipped by default`);
+  lines.push("");
+  lines.push(`  Applied:`);
   lines.push(
-    `  ${colors.dim("analyzed")} ${summary.analyzed} ${colors.dim("\xB7")} ${colors.dim("failed")} ${summary.failed} ${colors.dim("\xB7")} ${colors.dim("warnings")} ${summary.warnings} ${colors.dim("\xB7")} ${colors.dim("hints")} ${summary.hints}`
+    `    ${colors.green("\u2713")} ${applied} fix occurrence(s)${options.dryRun === true ? colors.dim(" (dry-run)") : ""}`
   );
+  lines.push("");
+  lines.push(`  Skipped:`);
+  lines.push(`    ${colors.yellow("\u25B2")} ${review} fixes require review`);
+  lines.push(`    ${colors.red("\u2715")} ${unsafe} fixes may change CSS behavior`);
+  lines.push("");
   lines.push(
-    `  ${colors.dim("rules")} ${summary.rules} ${colors.dim("\xB7")} ${colors.dim("declarations")} ${summary.declarations} ${colors.dim("\xB7")} ${colors.dim("analysis")} ${formatDuration(summary.analysisMs)}`
+    `  Files ${options.dryRun === true ? "that would change" : "modified"}: ${changedFiles}`
   );
-  if (report.threshold !== null) {
-    lines.push(`  ${colors.dim("selector threshold")} ${report.threshold}`);
+  if (options.verbose === true) {
+    lines.push("");
+    lines.push(rule);
+    lines.push("");
+    for (const result of results) {
+      if (!result.filePath) {
+        continue;
+      }
+      lines.push(`  ${result.filePath}`);
+      for (const item of result.plan.items.slice(0, 10)) {
+        const marker = item.applied ? colors.green("\u2713") : colors.dim("\xB7");
+        lines.push(`    ${marker} ${item.rule} \u2014 ${item.message}`);
+      }
+    }
   }
-  return lines;
+  if (options.dryRun === true) {
+    lines.push("");
+    lines.push(`  ${colors.bold("No files were modified.")}`);
+    lines.push(
+      `  ${colors.dim("Re-run without --dry-run to apply Safe fixes.")}`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
 }
-function fileStatus(file) {
-  if (!file.ok) {
-    return "ERROR";
+function formatUnifiedDiff(filePath, before, after, options = {}) {
+  if (before === after) {
+    return "";
   }
-  return file.issues.length > 0 ? "WARNING" : "SUCCESS";
+  const maxLines = options.maxLines ?? 80;
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  const lines = [`--- a/${filePath}`, `+++ b/${filePath}`, `@@ preview @@`];
+  for (const line of beforeLines.slice(0, Math.floor(maxLines / 2))) {
+    lines.push(`-${line}`);
+  }
+  for (const line of afterLines.slice(0, Math.floor(maxLines / 2))) {
+    lines.push(`+${line}`);
+  }
+  if (beforeLines.length + afterLines.length > maxLines) {
+    lines.push(`\\ No newline / truncated for preview`);
+  }
+  return `${lines.join("\n")}
+`;
 }
-function reportStatus(report) {
-  if (!report.success || report.errors.length > 0 || report.summary.failed > 0) {
-    return "ERROR";
+function formatDecision(decision, colors) {
+  const marker = decision.type === "oversized-chunk" || decision.type === "retain-uncertain" ? colors.yellow("\u25B2") : decision.changed ? colors.green("\u2713") : colors.cyan("\u25CF");
+  const lines = [`  ${marker} ${colors.bold(decision.title)}`];
+  if (decision.source.selector) {
+    lines.push(`    ${colors.magenta(decision.source.selector)}`);
   }
-  return report.summary.issues > 0 ? "WARNING" : "SUCCESS";
+  lines.push(`    ${colors.dim(decision.explanation)}`);
+  return [...lines, ""];
 }
-function statusBadge(status, colors) {
-  switch (status) {
-    case "SUCCESS":
-      return colors.bgGreen(colors.black(" SUCCESS "));
-    case "WARNING":
-      return colors.bgYellow(colors.black(" WARNING "));
-    case "ERROR":
-      return colors.bgRed(colors.white(" ERROR "));
+function statusLine(labelText, enabled, colors) {
+  return `${labelText.padEnd(24)} ${enabled ? colors.green("Completed") : colors.dim("Skipped")}`;
+}
+function formatSignedBytes(value, colors) {
+  const abs = formatBytes4(Math.abs(value));
+  if (value > 0) {
+    return colors.green(`+${abs}`);
   }
+  if (value < 0) {
+    return colors.red(`-${abs}`);
+  }
+  return colors.dim(abs);
 }
-function formatBytes(bytes) {
+function label2(text) {
+  return text;
+}
+function detectColumns3() {
+  const columns = process.stdout.columns;
+  return typeof columns === "number" && columns > 0 ? columns : 80;
+}
+function pad3(width, text) {
+  return " ".repeat(Math.max(1, width - text.length));
+}
+function formatBytes4(bytes) {
   if (bytes < 1024) {
     return `${bytes} B`;
   }
   if (bytes < 1024 * 1024) {
     return `${(bytes / 1024).toFixed(1)} KB`;
   }
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
 }
-function formatDuration(milliseconds) {
-  if (!Number.isFinite(milliseconds)) {
-    return "\u2014";
+function formatDuration3(ms) {
+  if (ms < 1) {
+    return `${ms.toFixed(2)} ms`;
   }
-  return milliseconds < 1 ? `${milliseconds.toFixed(2)} ms` : `${milliseconds.toFixed(1)} ms`;
+  if (ms < 1e3) {
+    return `${ms.toFixed(1)} ms`;
+  }
+  return `${(ms / 1e3).toFixed(2)} s`;
 }
 
-// src/utils/file.ts
+// src/utils/atomic-write.ts
 init_esm_shims();
-var import_fast_glob = __toESM(require_out4(), 1);
-import { readFile, stat } from "fs/promises";
-import { isAbsolute, relative, resolve, sep } from "path";
-var DEFAULT_IGNORES = ["**/node_modules/**", "**/.git/**"];
-async function isFile(filePath) {
+import { randomBytes } from "crypto";
+import {
+  chmod,
+  copyFile,
+  mkdir as mkdir2,
+  rename,
+  unlink as unlink2,
+  writeFile as writeFile2
+} from "fs/promises";
+import { dirname as dirname2, join } from "path";
+async function atomicWriteFile(absolutePath, content, options = {}) {
+  const directory = dirname2(absolutePath);
+  const tempPath = join(
+    directory,
+    `.css-doctor-${randomBytes(8).toString("hex")}.tmp`
+  );
   try {
-    return (await stat(filePath)).isFile();
-  } catch {
-    return false;
+    await mkdir2(directory, { recursive: true });
+    if (options.backup === true) {
+      try {
+        await copyFile(absolutePath, `${absolutePath}.bak`);
+      } catch {
+      }
+    }
+    await writeFile2(tempPath, content, "utf8");
+    if (options.mode !== void 0) {
+      await chmod(tempPath, options.mode);
+    }
+    await rename(tempPath, absolutePath);
+    return { ok: true };
+  } catch (error) {
+    try {
+      await unlink2(tempPath);
+    } catch {
+    }
+    return {
+      ok: false,
+      error: `Failed to write ${absolutePath}: ${describeError(error)}`
+    };
   }
 }
-async function isDirectory(directoryPath) {
+
+// src/commands/fix.ts
+function registerFixCommand(program3) {
+  program3.command("fix").description("Plan or apply Safe CSS autofixes").argument(
+    "[patterns...]",
+    "CSS files or glob patterns (required unless --list)"
+  ).option("--list", "List available autofix rules and exit").option("--dry-run", "Preview fixes without writing files").option("--write", "Apply Safe fixes to source files").option(
+    "--rule <id>",
+    "Only consider this fix rule id (repeatable)",
+    collectRule,
+    []
+  ).option("--backup", "Write `.bak` copies before modifying files").option("--diff", "Show unified diffs for changed files").option("-v, --verbose", "List per-file fix items").option("-j, --json", "Emit JSON").action(
+    async (patterns, options) => {
+      if (options.list === true) {
+        const report2 = await runFixList();
+        if (options.json === true) {
+          process.stdout.write(`${formatJsonReport(report2)}
+`);
+        } else {
+          process.stdout.write(`${formatFixCatalog(report2.catalog ?? [])}
+`);
+        }
+        process.exitCode = report2.success ? 0 : 1;
+        return;
+      }
+      if (options.write === true && options.dryRun === true) {
+        process.stderr.write(
+          "css-doctor: --write and --dry-run are mutually exclusive.\n"
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const dryRun = options.write !== true;
+      const report = await runFix(patterns ?? [], {
+        ...options,
+        dryRun,
+        rules: options.rule ?? options.rules
+      });
+      if (options.json === true) {
+        process.stdout.write(`${formatJsonReport(report)}
+`);
+      } else if (report.files.length > 0) {
+        process.stdout.write(
+          `${formatFixTerminalReport(
+            report.files.map((file) => file.result),
+            {
+              dryRun: report.dryRun,
+              verbose: options.verbose === true
+            }
+          )}
+`
+        );
+        if (options.diff === true) {
+          for (const file of report.files) {
+            if (file.diff) {
+              process.stdout.write(`${file.diff}
+`);
+            }
+          }
+        }
+        if (report.errors.length > 0) {
+          process.stderr.write(
+            `css-doctor: ${report.errors.join("\ncss-doctor: ")}
+`
+          );
+        }
+      } else {
+        process.stdout.write(
+          `css-doctor fix failed:
+${report.errors.map((error) => `  - ${error}`).join("\n")}
+`
+        );
+      }
+      process.exitCode = report.success ? 0 : 1;
+    }
+  );
+}
+async function runFixList() {
   try {
-    return (await stat(directoryPath)).isDirectory();
-  } catch {
-    return false;
+    const binding = loadBinding();
+    const catalog = JSON.parse(binding.listCssFixes());
+    return {
+      schemaVersion: 1,
+      command: "fix",
+      success: true,
+      dryRun: true,
+      errors: [],
+      catalog,
+      files: []
+    };
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      command: "fix",
+      success: false,
+      dryRun: true,
+      errors: [describeError(error)],
+      files: []
+    };
   }
 }
-async function resolveCssFiles(patterns, cwd) {
-  const files = /* @__PURE__ */ new Set();
-  const globPatterns = [];
-  for (const pattern of patterns) {
-    const absolutePath = isAbsolute(pattern) ? pattern : resolve(cwd, pattern);
-    if (await isFile(absolutePath)) {
-      files.add(absolutePath);
-    } else {
-      globPatterns.push(pattern);
-    }
-  }
-  if (globPatterns.length > 0) {
-    const matches = await (0, import_fast_glob.default)(globPatterns, {
-      cwd,
-      absolute: true,
-      onlyFiles: true,
-      unique: true,
-      dot: false,
-      followSymbolicLinks: true,
-      ignore: DEFAULT_IGNORES
-    });
-    for (const match of matches) {
-      files.add(resolve(match));
-    }
+async function runFix(patterns, options = {}) {
+  const cwd = resolve6(options.cwd ?? process.cwd());
+  const dryRun = options.dryRun !== false;
+  const errors = [];
+  const files = [];
+  if (patterns.length === 0) {
+    return {
+      schemaVersion: 1,
+      command: "fix",
+      success: false,
+      dryRun,
+      errors: [
+        'No CSS files or glob patterns were provided. Example: css-doctor fix "src/**/*.css" --dry-run'
+      ],
+      files: []
+    };
   }
-  return [...files].sort((left, right) => left.localeCompare(right));
-}
-async function readCssFile(filePath) {
-  try {
-    const buffer = await readFile(filePath);
+  if (!await isDirectory(cwd)) {
     return {
-      ok: true,
-      content: buffer.toString("utf8"),
-      sizeBytes: buffer.byteLength
+      schemaVersion: 1,
+      command: "fix",
+      success: false,
+      dryRun,
+      errors: [
+        `Working directory does not exist or is not a directory: ${cwd}`
+      ],
+      files: []
     };
+  }
+  let cssFiles = [];
+  try {
+    cssFiles = await resolveCssFiles(patterns, cwd);
+    if (cssFiles.length === 0) {
+      errors.push(`No CSS files matched: ${patterns.join(", ")}`);
+    }
   } catch (error) {
+    errors.push(`Failed to resolve CSS files: ${describeError(error)}`);
+  }
+  if (errors.length > 0) {
     return {
-      ok: false,
-      error: `Failed to read "${filePath}": ${describeError(error)}`
+      schemaVersion: 1,
+      command: "fix",
+      success: false,
+      dryRun,
+      errors,
+      files: []
     };
   }
+  try {
+    const binding = loadBinding();
+    for (const absolute of cssFiles) {
+      const displayPath = toDisplayPath(absolute, cwd);
+      const read = await readCssFile(absolute);
+      if (!read.ok) {
+        errors.push(`${displayPath}: ${read.error}`);
+        continue;
+      }
+      let mode;
+      try {
+        mode = (await stat2(absolute)).mode;
+      } catch {
+        mode = void 0;
+      }
+      const result = JSON.parse(
+        binding.applyCssFixes({
+          cssContent: read.content,
+          filePath: displayPath,
+          dryRun,
+          rules: options.rules && options.rules.length > 0 ? options.rules : void 0,
+          includeReview: false
+        })
+      );
+      let diff;
+      if (options.diff === true && result.changed) {
+        diff = formatUnifiedDiff(
+          displayPath,
+          result.originalCss,
+          result.fixedCss
+        );
+      }
+      if (!dryRun && result.changed) {
+        const written = await atomicWriteFile(absolute, result.fixedCss, {
+          mode,
+          backup: options.backup === true
+        });
+        if (!written.ok) {
+          errors.push(written.error);
+          continue;
+        }
+      }
+      files.push({ path: displayPath, result, diff });
+    }
+  } catch (error) {
+    errors.push(describeError(error));
+  }
+  return {
+    schemaVersion: 1,
+    command: "fix",
+    success: errors.length === 0,
+    dryRun,
+    errors,
+    files
+  };
 }
-function toDisplayPath(filePath, cwd) {
-  const relativePath = relative(cwd, filePath);
-  const displayPath = relativePath.length > 0 ? relativePath : filePath;
-  return displayPath.split(sep).join("/");
+function collectRule(value, previous) {
+  previous.push(value);
+  return previous;
 }
-function describeError(error) {
-  if (error instanceof Error) {
-    return error.message;
+function formatFixCatalog(catalog) {
+  const lines = ["", "  Available autofix rules", ""];
+  for (const entry of catalog) {
+    lines.push(`  [${entry.safety}] ${entry.id}`);
+    lines.push(`    ${entry.description}`);
+    lines.push(`    ${entry.reason}`);
+    lines.push("");
   }
-  return String(error);
+  lines.push("  Only [safe] rules are applied by default.");
+  lines.push("");
+  return lines.join("\n");
 }
 
-// src/commands/check.ts
-var require2 = createRequire(import.meta.url);
-var cachedBinding;
-function loadBinding() {
-  if (cachedBinding) {
-    return cachedBinding;
+// src/commands/health.ts
+init_esm_shims();
+import { createRequire as createRequire3 } from "module";
+import { resolve as resolve7 } from "path";
+var require4 = createRequire3(import.meta.url);
+var cachedBinding3;
+function loadBinding3() {
+  if (cachedBinding3) {
+    return cachedBinding3;
   }
   try {
-    cachedBinding = require2("@zealakit/css-doctor-binding");
-    return cachedBinding;
+    cachedBinding3 = require4("@zealakit/css-doctor-binding");
+    return cachedBinding3;
   } catch (error) {
     throw new Error(
       "Unable to load @zealakit/css-doctor-binding. Build it first with `pnpm --filter @zealakit/css-doctor-binding build`.\n" + describeError(error)
     );
   }
 }
-function registerCheckCommand(program3) {
-  program3.command("check").description("Analyze CSS files and report diagnostics").argument(
+function registerHealthCommand(program3) {
+  program3.command("health").description("Evaluate CSS Health Score with dimension breakdown").argument(
     "[patterns...]",
     "CSS files or glob patterns (quote globs to let css-doctor expand them)"
   ).option("-j, --json", "Output raw JSON for piping and CI/CD").option(
     "--threshold <number>",
-    "Warn when a file contains more than <number> selectors",
-    parseThreshold
+    "Warn in size/complexity checks when a file has more than <number> selectors",
+    parseNonNegativeInteger3
+  ).option(
+    "--fail-under <number>",
+    "Exit with code 1 when overall health score is below <number> (0-100)",
+    parseScore3
   ).action(async (patterns, options) => {
-    const report = await runCheck(patterns ?? [], {
-      threshold: options.threshold
+    const report = await runHealth(patterns ?? [], {
+      threshold: options.threshold,
+      failUnder: options.failUnder
     });
     if (options.json === true) {
       process.stdout.write(`${formatJsonReport(report)}
 `);
-    } else {
-      process.stdout.write(`${formatTerminalReport(report)}
+    } else if (report.health) {
+      process.stdout.write(`${formatHealthTerminalReport(report.health)}
 `);
+      if (report.errors.length > 0) {
+        process.stderr.write(
+          `css-doctor: ${report.errors.join("\ncss-doctor: ")}
+`
+        );
+      }
+    } else {
+      process.stdout.write(
+        `css-doctor health failed:
+${report.errors.map((error) => `  - ${error}`).join("\n")}
+`
+      );
     }
-    process.exitCode = terminalExitCode(report);
+    process.exitCode = healthExitCode(report);
   });
 }
-function parseThreshold(value) {
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new InvalidArgumentError("threshold must be a non-negative integer");
-  }
-  return parsed;
-}
-async function runCheck(patterns, options = {}) {
-  const startedAt = performance.now();
-  const cwd = resolve2(options.cwd ?? process.cwd());
+async function runHealth(patterns, options = {}) {
+  const cwd = resolve7(options.cwd ?? process.cwd());
   const threshold = options.threshold ?? null;
+  const failUnder = options.failUnder ?? null;
   const errors = [];
-  const results = [];
-  let files = [];
+  if (failUnder !== null && (failUnder < 0 || failUnder > 100)) {
+    errors.push("--fail-under must be an integer between 0 and 100.");
+  }
   if (threshold !== null && (!Number.isInteger(threshold) || threshold < 0)) {
     errors.push("Threshold must be a non-negative integer.");
   }
+  let files = [];
   if (patterns.length === 0) {
     errors.push(
-      'No CSS files or glob patterns were provided. Example: css-doctor check "src/**/*.css"'
+      'No CSS files or glob patterns were provided. Example: css-doctor health "src/**/*.css"'
     );
   } else if (!await isDirectory(cwd)) {
     errors.push(
@@ -9357,182 +11802,383 @@ async function runCheck(patterns, options = {}) {
       errors.push(`Failed to resolve CSS files: ${describeError(error)}`);
     }
   }
-  if (errors.length === 0) {
-    try {
-      const analyze = loadBinding().analyzeCss;
-      for (const file of files) {
-        results.push(await checkFile(file, cwd, threshold, analyze));
-      }
-    } catch (error) {
-      errors.push(describeError(error));
-    }
-  }
-  const issues = results.flatMap((file) => file.issues);
-  const warnings = issues.filter((issue) => issue.kind === "syntax").length;
-  const analyzed = results.filter((file) => file.ok).length;
-  const failed = results.length - analyzed;
-  const summary = {
-    files: results.length,
-    analyzed,
-    failed,
-    filesWithIssues: results.filter((file) => file.issues.length > 0).length,
-    totalSizeBytes: results.reduce((total, file) => total + file.sizeBytes, 0),
-    rules: sum(results, (file) => file.result?.stats.ruleCount ?? 0),
-    selectors: sum(results, (file) => file.result?.stats.selectorCount ?? 0),
-    declarations: sum(
-      results,
-      (file) => (file.result?.stats.declarationCount ?? 0) + (file.result?.stats.importantDeclarationCount ?? 0)
-    ),
-    warnings,
-    hints: issues.length - warnings,
-    issues: issues.length,
-    analysisMs: roundMs(
-      results.reduce((total, file) => total + file.analysisMs, 0)
-    ),
-    totalMs: elapsedMs(startedAt)
-  };
-  return {
-    schemaVersion: 1,
-    command: "check",
-    version: package_default.version,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cwd,
-    patterns,
-    threshold,
-    success: errors.length === 0 && failed === 0,
-    errors,
-    files: results,
-    summary
-  };
-}
-async function checkFile(filePath, cwd, threshold, analyze) {
-  const path2 = toDisplayPath(filePath, cwd);
-  const readStartedAt = performance.now();
-  const read = await readCssFile(filePath);
-  const readMs = elapsedMs(readStartedAt);
-  if (!read.ok) {
+  if (errors.length > 0) {
     return {
-      path: path2,
-      absolutePath: filePath,
-      sizeBytes: 0,
-      ok: false,
-      totalMs: readMs,
-      readMs,
-      analysisMs: 0,
-      issues: [],
-      error: read.error
+      schemaVersion: 1,
+      command: "health",
+      success: false,
+      errors,
+      patterns,
+      threshold,
+      failUnder,
+      health: null
     };
   }
-  const analysisStartedAt = performance.now();
   try {
-    const result = analyze(read.content);
-    const analysisMs = elapsedMs(analysisStartedAt);
+    const binding = loadBinding3();
+    const batchFiles = [];
+    for (const file of files) {
+      const read = await readCssFile(file);
+      if (!read.ok) {
+        errors.push(`${toDisplayPath(file, cwd)}: ${read.error}`);
+        continue;
+      }
+      batchFiles.push({
+        cssContent: read.content,
+        filePath: toDisplayPath(file, cwd),
+        sizeBytes: read.sizeBytes
+      });
+    }
+    if (batchFiles.length === 0) {
+      return {
+        schemaVersion: 1,
+        command: "health",
+        success: false,
+        errors: errors.length > 0 ? errors : ["No CSS files could be read for health scoring."],
+        patterns,
+        threshold,
+        failUnder,
+        health: null
+      };
+    }
+    const health = binding.evaluateCssHealthBatch({
+      files: batchFiles,
+      thresholds: threshold === null ? void 0 : {
+        manySelectors: threshold
+      }
+    });
+    const belowFloor = failUnder !== null && health.overall < failUnder ? [
+      `Overall health score ${health.overall} is below --fail-under ${failUnder}.`
+    ] : [];
     return {
-      path: path2,
-      absolutePath: filePath,
-      sizeBytes: read.sizeBytes,
-      ok: true,
-      totalMs: roundMs(readMs + analysisMs),
-      readMs,
-      analysisMs,
-      issues: collectIssues(result, threshold),
-      result
+      schemaVersion: 1,
+      command: "health",
+      success: errors.length === 0 && belowFloor.length === 0,
+      errors: [...errors, ...belowFloor],
+      patterns,
+      threshold,
+      failUnder,
+      health
     };
   } catch (error) {
-    const analysisMs = elapsedMs(analysisStartedAt);
     return {
-      path: path2,
-      absolutePath: filePath,
-      sizeBytes: read.sizeBytes,
-      ok: false,
-      totalMs: roundMs(readMs + analysisMs),
-      readMs,
-      analysisMs,
-      issues: [],
-      error: `Failed to analyze file: ${describeError(error)}`
+      schemaVersion: 1,
+      command: "health",
+      success: false,
+      errors: [describeError(error)],
+      patterns,
+      threshold,
+      failUnder,
+      health: null
     };
   }
 }
-function collectIssues(result, threshold) {
-  const issues = [];
-  for (const warning of result.warnings) {
-    issues.push({
-      kind: "syntax",
-      severity: "warning",
-      message: warning.message,
-      ...warning.location ? { location: warning.location } : {}
-    });
+function healthExitCode(report) {
+  return report.success ? 0 : 1;
+}
+function parseNonNegativeInteger3(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("must be a non-negative integer");
   }
-  const parentRuleIndices = new Set(
-    result.rules.map((rule) => rule.parentRuleIndex).filter((index) => index !== void 0)
+  return parsed;
+}
+function parseScore3(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) {
+    throw new InvalidArgumentError("must be an integer between 0 and 100");
+  }
+  return parsed;
+}
+
+// src/commands/optimize.ts
+init_esm_shims();
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join2, resolve as resolve8 } from "path";
+function registerOptimizeCommand(program3) {
+  registerOptimizeLikeCommand(
+    program3,
+    "optimize",
+    "Preview or emit CSS optimization results with explanations"
   );
-  for (const rule of result.rules) {
-    const hasNoDeclarations = rule.declarationCount === 0 && rule.importantDeclarationCount === 0;
-    const hasNoNestedRules = !parentRuleIndices.has(rule.index);
-    if (hasNoDeclarations && hasNoNestedRules) {
-      const selectorText = rule.selectorIndices.map((index) => result.selectors[index]?.raw).filter((value) => value !== void 0).join(", ");
-      issues.push({
-        kind: "empty-rule",
-        severity: "warning",
-        message: selectorText.length > 0 ? `Rule "${selectorText}" has no declarations and no nested rules (dead code candidate).` : "Rule has no declarations and no nested rules (dead code candidate).",
-        location: rule.location,
-        ...selectorText.length > 0 ? { selector: selectorText } : {}
+}
+function registerSplitCommand(program3) {
+  registerOptimizeLikeCommand(
+    program3,
+    "split",
+    "Preview page-coverage / size-budget CSS splitting"
+  );
+}
+function registerOptimizeLikeCommand(program3, name, description) {
+  program3.command(name).description(description).argument(
+    "[patterns...]",
+    "CSS files or glob patterns (quote globs to let css-doctor expand them)"
+  ).option("--dry-run", "Analyze and report without writing files").option("--write", "Write emitted chunks to --out-dir").option("--explain", "Include optimization decision explanations").option("--diff", "Include concise unified diffs for emitted CSS").option("-v, --verbose", "Show more decisions and chunks").option("-j, --json", "Emit JSON").option("--report <path>", "Write the JSON report to a file").option("--out-dir <path>", "Directory for emitted chunks when writing").option("--minify", "Minify emitted CSS").option("--no-minify", "Disable minification").option(
+    "--page-usage <json>",
+    "JSON map of page name \u2192 class name arrays for coverage splitting"
+  ).option(
+    "--min-page-ratio <number>",
+    "Minimum coverage ratio for common CSS (0-1)",
+    parseRatio
+  ).option(
+    "--max-chunk-size <bytes>",
+    "Size budget per body chunk in bytes",
+    parsePositiveInteger
+  ).option("--no-page-coverage", "Disable page-coverage splitting").option("--no-size-budget", "Disable size-budget splitting").option("--no-isolate-variables", "Disable CSS variable isolation").action(
+    async (patterns, options) => {
+      if (options.write === true && options.dryRun === true) {
+        process.stderr.write(
+          "css-doctor: --write and --dry-run are mutually exclusive.\n"
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const dryRun = options.write !== true;
+      const report = await runOptimize(patterns ?? [], {
+        ...options,
+        dryRun,
+        commandName: name,
+        minify: options.minify !== false
       });
+      if (options.report) {
+        const reportPath = resolve8(
+          options.cwd ?? process.cwd(),
+          options.report
+        );
+        try {
+          await mkdir3(dirname3(reportPath), { recursive: true });
+          await writeFile3(
+            reportPath,
+            `${formatJsonReport(report)}
+`,
+            "utf8"
+          );
+        } catch (error) {
+          process.stderr.write(
+            `css-doctor: failed to write --report ${reportPath}: ${describeError(error)}
+`
+          );
+          process.exitCode = 1;
+          return;
+        }
+      }
+      if (options.json === true) {
+        process.stdout.write(`${formatJsonReport(report)}
+`);
+      } else if (report.files.length > 0) {
+        for (const file of report.files) {
+          process.stdout.write(
+            `${formatOptimizationTerminalReport(file.report, {
+              dryRun: report.dryRun,
+              verbose: options.verbose === true || options.explain === true
+            })}
+`
+          );
+          if (options.diff === true && file.diff) {
+            process.stdout.write(`${file.diff}
+`);
+          }
+        }
+        if (report.errors.length > 0) {
+          process.stderr.write(
+            `css-doctor: ${report.errors.join("\ncss-doctor: ")}
+`
+          );
+        }
+      } else {
+        process.stdout.write(
+          `css-doctor ${name} failed:
+${report.errors.map((error) => `  - ${error}`).join("\n")}
+`
+        );
+      }
+      process.exitCode = report.success ? 0 : 1;
     }
+  );
+}
+async function runOptimize(patterns, options = {}) {
+  const cwd = resolve8(options.cwd ?? process.cwd());
+  const command = options.commandName ?? "optimize";
+  const dryRun = options.dryRun !== false;
+  const errors = [];
+  const warnings = [];
+  const files = [];
+  if (patterns.length === 0) {
+    errors.push(
+      `No CSS files or glob patterns were provided. Example: css-doctor ${command} "src/**/*.css" --dry-run`
+    );
+  } else if (!await isDirectory(cwd)) {
+    errors.push(
+      `Working directory does not exist or is not a directory: ${cwd}`
+    );
   }
-  const seenSelectors = /* @__PURE__ */ new Map();
-  for (const selector of result.selectors) {
-    const first = seenSelectors.get(selector.raw);
-    if (!first) {
-      seenSelectors.set(selector.raw, selector);
-      continue;
+  let pageUsage = {};
+  if (options.pageUsage) {
+    const parsedUsage = parsePageUsage(options.pageUsage);
+    if (!parsedUsage.ok) {
+      errors.push(parsedUsage.error);
+    } else {
+      pageUsage = parsedUsage.value;
     }
-    const firstRule = result.rules[first.ruleIndex];
-    const currentRule = result.rules[selector.ruleIndex];
-    issues.push({
-      kind: "duplicate-selector",
-      severity: "warning",
-      message: `Selector "${selector.raw}" is defined in multiple rules` + (firstRule ? ` (first at line ${firstRule.location.line})` : "") + "; verify whether this is intentional.",
-      ...currentRule ? { location: currentRule.location } : {},
-      selector: selector.raw
-    });
   }
-  if (threshold !== null && result.selectors.length > threshold) {
-    issues.push({
-      kind: "threshold",
-      severity: "warning",
-      message: `Selector threshold exceeded: ${result.selectors.length} selectors found (threshold: ${threshold}).`
-    });
+  let cssFiles = [];
+  if (errors.length === 0) {
+    try {
+      cssFiles = await resolveCssFiles(patterns, cwd);
+      if (cssFiles.length === 0) {
+        errors.push(`No CSS files matched: ${patterns.join(", ")}`);
+      }
+    } catch (error) {
+      errors.push(`Failed to resolve CSS files: ${describeError(error)}`);
+    }
   }
-  return issues.sort(compareIssues);
-}
-function compareIssues(left, right) {
-  const leftLine = left.location?.line ?? Number.MAX_SAFE_INTEGER;
-  const rightLine = right.location?.line ?? Number.MAX_SAFE_INTEGER;
-  const lineDifference = leftLine - rightLine;
-  if (lineDifference !== 0) {
-    return lineDifference;
+  const outDir = options.outDir ? resolve8(cwd, options.outDir) : null;
+  if (!dryRun && !outDir) {
+    errors.push(
+      "Writing chunks requires --out-dir (or omit --write for dry-run)."
+    );
   }
-  const columnDifference = (left.location?.column ?? 0) - (right.location?.column ?? 0);
-  if (columnDifference !== 0) {
-    return columnDifference;
+  if (errors.length > 0) {
+    return {
+      schemaVersion: 1,
+      command,
+      success: false,
+      dryRun,
+      errors,
+      warnings,
+      patterns,
+      files: [],
+      outDir
+    };
   }
-  return left.kind.localeCompare(right.kind);
+  try {
+    const binding = loadBinding();
+    const pipelineOptions = {
+      pageUsage,
+      pageCoverage: {
+        enabled: options.noPageCoverage !== true,
+        minPageRatio: options.minPageRatio
+      },
+      sizeBudget: {
+        enabled: options.noSizeBudget !== true,
+        maxChunkSize: options.maxChunkSize,
+        isolateVariables: options.noIsolateVariables !== true
+      },
+      minify: options.minify !== false
+    };
+    for (const absolute of cssFiles) {
+      const read = await readCssFile(absolute);
+      const displayPath = toDisplayPath(absolute, cwd);
+      if (!read.ok) {
+        errors.push(`${displayPath}: ${read.error}`);
+        continue;
+      }
+      const explained = binding.optimizeCssExplained(
+        {
+          cssContent: read.content,
+          ...pipelineOptions
+        },
+        options.verbose === true ? 200 : 40
+      );
+      const report = JSON.parse(explained.reportJson);
+      warnings.push(...report.warnings);
+      const chunks = explained.pipeline.chunks.map((chunk) => ({
+        name: chunk.name,
+        css: chunk.css,
+        sizeBytes: chunk.sizeBytes
+      }));
+      let diff;
+      if (options.diff === true) {
+        const combined = chunks.map((chunk) => `/* ${chunk.name} */
+${chunk.css}`).join("\n\n");
+        diff = formatUnifiedDiff(displayPath, read.content, combined, {
+          maxLines: options.verbose === true ? 200 : 80
+        });
+      }
+      if (!dryRun && outDir) {
+        await mkdir3(outDir, { recursive: true });
+        const stem = displayPath.replace(/[\\/]/g, "__").replace(/\.css$/i, "");
+        for (const chunk of chunks) {
+          await writeFile3(
+            join2(outDir, `${stem}.${chunk.name}.css`),
+            chunk.css,
+            "utf8"
+          );
+        }
+      }
+      files.push({ path: displayPath, report, chunks, diff });
+    }
+  } catch (error) {
+    errors.push(describeError(error));
+  }
+  return {
+    schemaVersion: 1,
+    command,
+    success: errors.length === 0,
+    dryRun,
+    errors,
+    warnings,
+    patterns,
+    files,
+    outDir
+  };
 }
-function sum(files, select) {
-  return files.reduce((total, file) => total + select(file), 0);
+function parsePageUsage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        ok: false,
+        error: "--page-usage must be a JSON object of page \u2192 string[]."
+      };
+    }
+    const value = {};
+    for (const [page, classes] of Object.entries(
+      parsed
+    )) {
+      if (!Array.isArray(classes) || classes.some((item) => typeof item !== "string")) {
+        return {
+          ok: false,
+          error: `--page-usage page "${page}" must map to an array of class name strings.`
+        };
+      }
+      value[page] = classes;
+    }
+    return { ok: true, value };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Invalid --page-usage JSON: ${describeError(error)}`
+    };
+  }
 }
-function elapsedMs(startedAt) {
-  return roundMs(performance.now() - startedAt);
+function parseRatio(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+    throw new InvalidArgumentError("must be a number between 0 and 1");
+  }
+  return parsed;
 }
-function roundMs(value) {
-  return Math.round(value * 1e3) / 1e3;
+function parsePositiveInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError("must be a positive integer");
+  }
+  return parsed;
 }
 
 // src/index.ts
 var program2 = new Command();
-program2.name("css-doctor").description("Diagnose CSS stylesheets with a native lightningcss engine").version(package_default.version, "-v, --version", "Output the version number").showHelpAfterError("(run with --help for usage information)").showSuggestionAfterError().exitOverride();
+program2.name("css-doctor").description(
+  "Diagnose, score, regress, explain, and safely optimize CSS with a native LightningCSS engine"
+).version(package_default.version, "-v, --version", "Output the version number").showHelpAfterError("(run with --help for usage information)").showSuggestionAfterError().exitOverride();
 registerCheckCommand(program2);
+registerHealthCommand(program2);
+registerBaselineCommand(program2);
+registerDiffCommand(program2);
+registerOptimizeCommand(program2);
+registerSplitCommand(program2);
+registerFixCommand(program2);
 try {
   await program2.parseAsync(process.argv);
 } catch (error) {