pickier 0.1.28 → 0.1.29

package/dist/src/index.js

@@ -9364,6 +9364,16 @@ function unmaskStrings(text, strings) {
     return text;
   return text.replace(/@@S(\d+)@@/g, (_, idx) => strings[Number(idx)] ?? "");
 }
+function collectIdentifierSet(text) {
+  const identifiers = new Set;
+  const identifierRe = /[$A-Z_][\w$]*/gi;
+  let match = identifierRe.exec(text);
+  while (match !== null) {
+    identifiers.add(match[0]);
+    match = identifierRe.exec(text);
+  }
+  return identifiers;
+}
 function formatImports(source) {
   const firstChar = source[0];
   if (firstChar !== "i" && firstChar !== " " && firstChar !== "\t" && firstChar !== "/" && firstChar !== `
@@ -9391,17 +9401,8 @@ function formatImports(source) {
     return source;
   const rest = lines.slice(idx).join(`
 `);
-  const codeText = rest;
-  const isWordChar = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$";
-  const used = (name) => {
-    for (let pos = codeText.indexOf(name, 0);pos !== -1; pos = codeText.indexOf(name, pos + name.length)) {
-      const before = pos > 0 ? codeText[pos - 1] : " ";
-      const after = pos + name.length < codeText.length ? codeText[pos + name.length] : " ";
-      if (!isWordChar(before) && !isWordChar(after))
-        return true;
-    }
-    return false;
-  };
+  const usedIdentifiers = collectIdentifierSet(rest);
+  const used = (name) => usedIdentifiers.has(name);
   for (const imp of imports) {
     if (imp.kind !== "value")
       continue;
@@ -20322,11 +20323,11 @@ var init_no_unused_vars = __esm(() => {
         }
       };
       computeTemplateLines();
+      const declRe = new RegExp("^\\s*(?:const|let|var)\\s+(.+?)" + ";" + "?\\s*$");
       for (let i = 0;i < lines.length; i++) {
         if (lineStartsInTemplate[i])
           continue;
         const line = lines[i];
-        const declRe = new RegExp("^\\s*(?:const|let|var)\\s+(.+?)" + ";" + "?\\s*$");
         const decl = line.match(declRe);
         if (!decl)
           continue;
@@ -21756,6 +21757,90 @@ function findTopLevelEquals(s) {
   }
   return -1;
 }
+function destructuringReassignsName(text, name) {
+  const re = new RegExp(`\\b${name}\\b`);
+  let i = 0;
+  let inStr = null;
+  let escaped = false;
+  while (i < text.length) {
+    const c = text[i];
+    if (escaped) {
+      escaped = false;
+      i++;
+      continue;
+    }
+    if (c === "\\" && inStr) {
+      escaped = true;
+      i++;
+      continue;
+    }
+    if (inStr) {
+      if (inStr === "single" && c === "'" || inStr === "double" && c === '"' || inStr === "template" && c === "`")
+        inStr = null;
+      i++;
+      continue;
+    }
+    if (c === "'") {
+      inStr = "single";
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      inStr = "double";
+      i++;
+      continue;
+    }
+    if (c === "`") {
+      inStr = "template";
+      i++;
+      continue;
+    }
+    if (c === "[" || c === "{") {
+      const open = c;
+      const close = c === "[" ? "]" : "}";
+      let depth = 1;
+      let j = i + 1;
+      while (j < text.length && depth > 0) {
+        const cj = text[j];
+        if (cj === "\\") {
+          j += 2;
+          continue;
+        }
+        if (cj === open)
+          depth++;
+        else if (cj === close)
+          depth--;
+        if (depth === 0)
+          break;
+        j++;
+      }
+      if (depth === 0 && j < text.length) {
+        let k = j + 1;
+        while (k < text.length && (text[k] === " " || text[k] === "\t" || text[k] === "\r" || text[k] === `
+`))
+          k++;
+        if (text[k] === "=" && text[k + 1] !== "=" && text[k + 1] !== ">") {
+          const inside = text.slice(i + 1, j);
+          if (re.test(inside)) {
+            const keyOnly = new RegExp(`\\b${name}\\b\\s*:`);
+            const valueAfterColon = new RegExp(`:\\s*\\b${name}\\b`);
+            if (open === "{") {
+              const isKeyOnly = keyOnly.test(inside) && !valueAfterColon.test(inside) && !new RegExp(`(?:^|[\\s,{])\\s*${name}\\s*(?:,|\\s*=|\\s*})`).test(inside);
+              if (!isKeyOnly)
+                return true;
+            } else {
+              return true;
+            }
+          }
+        }
+      }
+      i = j + 1;
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
 function analyzeLetDecl(line, text) {
   const declRe = new RegExp("^\\s*(?:let|var)\\s+(.+?)" + ";" + "?\\s*$");
   const decl = line.match(declRe);
@@ -21793,7 +21878,8 @@ function analyzeLetDecl(line, text) {
     const assignPattern = `\\b${name}\\s*(?:${assignOps.map((op) => op.replace(/[|\\^$*+?.(){}[\]]/g, (r) => `\\${r}`)).join("|")})`;
     const directAssign = new RegExp(assignPattern).test(rest);
     const incDecChanged = new RegExp(`(?:^|[^$w])(?:\\+\\+|--)\\s*${name}\\b|\\b${name}\\s*(?:\\+\\+|--)`).test(rest);
-    result.push({ name, fixable: !directAssign && !incDecChanged });
+    const destructReassigned = destructuringReassignsName(rest, name);
+    result.push({ name, fixable: !directAssign && !incDecChanged && !destructReassigned });
   }
   return result;
 }
@@ -21822,8 +21908,20 @@ var init_prefer_const = __esm(() => {
     },
     fix: (text) => {
       const lines = text.split(/\r?\n/);
+      const disabledLines = new Set;
+      const disableNextRe = /(?:eslint|pickier)-disable-next-line\b([^*\n]*)/;
+      for (let i = 0;i < lines.length; i++) {
+        const m = lines[i].match(disableNextRe);
+        if (!m)
+          continue;
+        const ruleList = m[1].trim();
+        if (ruleList === "" || /\bprefer-const\b/.test(ruleList))
+          disabledLines.add(i + 2);
+      }
       let changed = false;
       for (let i = 0;i < lines.length; i++) {
+        if (disabledLines.has(i + 1))
+          continue;
         const line = lines[i];
         if (!/^\s*let\b/.test(line))
           continue;
@@ -28473,14 +28571,27 @@ function getVariantPriority(cls) {
   }
   return priority;
 }
+function getClassSortKey(cls) {
+  const cached = sortKeyCache.get(cls);
+  if (cached)
+    return cached;
+  const key = {
+    group: getGroupIndex(cls),
+    variant: getVariantPriority(cls)
+  };
+  sortKeyCache.set(cls, key);
+  return key;
+}
 function sortClasses(classes) {
   return [...classes].sort((a, b) => {
-    const ga = getGroupIndex(a);
-    const gb = getGroupIndex(b);
+    const aKey = getClassSortKey(a);
+    const bKey = getClassSortKey(b);
+    const ga = aKey.group;
+    const gb = bKey.group;
     if (ga !== gb)
       return ga - gb;
-    const va = getVariantPriority(a);
-    const vb = getVariantPriority(b);
+    const va = aKey.variant;
+    const vb = bKey.variant;
     if (va !== vb)
       return va - vb;
     return a.localeCompare(b);
@@ -28499,6 +28610,8 @@ function looksLikeJsExpression(value) {
 }
 function extractClassValues(content) {
   const matches = [];
+  if (!content.includes("class") && !content.includes("clsx") && !content.includes("cn(") && !content.includes("tw(") && !content.includes("cva(") && !content.includes("tv("))
+    return matches;
   for (const re of [ATTR_RE, ATTR_TMPL_RE, UTIL_FN_RE]) {
     re.lastIndex = 0;
     let m;
@@ -28545,7 +28658,7 @@ function isSorted(classes) {
   const sorted = sortClasses(classes);
   return classes.every((c, i) => c === sorted[i]);
 }
-var GROUP_ORDER, VARIANT_RE, ATTR_RE, ATTR_TMPL_RE, UTIL_FN_RE, sortTailwindClassesRule;
+var GROUP_ORDER, VARIANT_RE, sortKeyCache, ATTR_RE, ATTR_TMPL_RE, UTIL_FN_RE, sortTailwindClassesRule;
 var init_tailwind_classes = __esm(() => {
   GROUP_ORDER = [
     [/^(block|inline|inline-block|flex|inline-flex|grid|inline-grid|flow-root|contents|hidden|table|table-caption|table-cell|table-column|table-column-group|table-footer-group|table-header-group|table-row-group|table-row|list-item|subgrid)$/, 0],
@@ -28569,6 +28682,7 @@ var init_tailwind_classes = __esm(() => {
     [/^(sr-only|not-sr-only)$/, 15]
   ];
   VARIANT_RE = /^([a-z0-9][-a-z0-9]{0,50}:)+(?!\[)/;
+  sortKeyCache = new Map;
   ATTR_RE = /\b(?:class|className|:class)\s*=\s*(?:"([^"]*?)"|'([^']*?)')/g;
   ATTR_TMPL_RE = /\b(?:class|className|:class)\s*=\s*\{`([^`]*?)`\}/g;
   UTIL_FN_RE = /\b(?:clsx|cn|tw|cva|tv)\s*\(\s*(?:"([^"]*?)"|'([^']*?)')/g;
@@ -37167,15 +37281,7 @@ function globToRegex(pattern) {
   }
   return new RegExp(`^${src}$`);
 }
-function matchesAnyPattern(filePath, patterns) {
-  for (const p of patterns) {
-    const re = globToRegex(p);
-    if (re.test(filePath) || re.test(filePath.replace(/\\/g, "/")))
-      return true;
-  }
-  return false;
-}
-function* walkDir(dir, ignore, dot, cwd) {
+function* walkDirWithMatcher(dir, ignoreMatcher, dot) {
   let entries;
   try {
     entries = readdirSync8(dir);
@@ -37186,8 +37292,7 @@ function* walkDir(dir, ignore, dot, cwd) {
     if (!dot && name.startsWith("."))
       continue;
     const full = join10(dir, name);
-    const rel = full.startsWith(`${cwd}/`) ? full.slice(cwd.length + 1) : full;
-    if (ignore.length && matchesAnyPattern(rel, ignore))
+    if (ignoreMatcher(full))
       continue;
     let st;
     try {
@@ -37196,17 +37301,21 @@ function* walkDir(dir, ignore, dot, cwd) {
       continue;
     }
     if (st.isDirectory()) {
-      yield* walkDir(full, ignore, dot, cwd);
+      yield* walkDirWithMatcher(full, ignoreMatcher, dot);
     } else {
       yield full;
     }
   }
 }
+function* walkDir(dir, ignore, dot, cwd) {
+  yield* walkDirWithMatcher(dir, createIgnoreMatcher(ignore, cwd), dot);
+}
 async function glob(patterns, opts = {}) {
   const cwd = opts.cwd ?? process21.cwd();
   const ignore = opts.ignore ?? [];
   const dot = opts.dot ?? false;
   const absolute = opts.absolute ?? true;
+  const ignoreMatcher = createIgnoreMatcher(ignore, cwd);
   if (typeof globalThis.Bun?.Glob !== "undefined") {
     const BunGlob = globalThis.Bun.Glob;
     const results2 = [];
@@ -37215,7 +37324,7 @@ async function glob(patterns, opts = {}) {
       for await (const file of g.scan({ cwd, dot, onlyFiles: opts.onlyFiles ?? true, followSymlinks: false })) {
         const full = isAbsolute6(file) ? file : join10(cwd, file);
         const rel = full.startsWith(`${cwd}/`) ? full.slice(cwd.length + 1) : full;
-        if (ignore.length && matchesAnyPattern(rel, ignore))
+        if (ignoreMatcher(full))
           continue;
         results2.push(absolute ? full : rel);
       }
@@ -37230,7 +37339,7 @@ async function glob(patterns, opts = {}) {
         const st = statSync5(full);
         if (!st.isDirectory()) {
           const rel = full.startsWith(`${cwd}/`) ? full.slice(cwd.length + 1) : full;
-          if (!ignore.length || !matchesAnyPattern(rel, ignore))
+          if (!ignoreMatcher(full))
             results.push(absolute ? full : rel);
         } else {
           for (const f of walkDir(full, ignore, dot, cwd))
@@ -37405,36 +37514,60 @@ function isCodeFile(file, allowedExts) {
 function toPosixPath(p) {
   return p.replace(/\\/g, "/").replace(/\/+/g, "/");
 }
-function shouldIgnorePath(absPath, ignoreGlobs) {
-  const isOutsideProject = !absPath.startsWith(process21.cwd());
-  const universalIgnores = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"];
-  const effectiveIgnores = isOutsideProject ? ignoreGlobs.filter((pattern) => universalIgnores.includes(pattern)) : ignoreGlobs;
-  const rel = toPosixPath(isOutsideProject ? absPath : absPath.slice(process21.cwd().length));
-  for (const g of effectiveIgnores) {
+function compileIgnoreGlobs(ignoreGlobs) {
+  const compiled = [];
+  for (const g of ignoreGlobs) {
     const gg = toPosixPath(g.trim());
+    if (!gg)
+      continue;
     const filePattern = gg.match(/\*\*\/\*\.(.+)$/);
     if (filePattern) {
-      const extension = filePattern[1];
-      if (rel.endsWith(`.${extension}`))
-        return true;
+      compiled.push({ raw: gg, kind: "extension", value: filePattern[1] });
       continue;
     }
     const m = gg.match(/\*\*\/(.+?)\/\*\*$/);
     if (m) {
-      const name = m[1];
-      if (rel.includes(`/${name}/`) || rel.endsWith(`/${name}`))
-        return true;
+      compiled.push({ raw: gg, kind: "segment", value: m[1] });
       continue;
     }
     const m2 = gg.match(/\*\*\/(.+)$/);
     if (m2) {
-      const name = m2[1].replace(/\/$/, "");
-      if (rel.includes(`/${name}/`) || rel.endsWith(`/${name}`))
-        return true;
-      continue;
+      compiled.push({ raw: gg, kind: "suffix", value: m2[1].replace(/\/$/, "") });
+    }
+  }
+  return compiled;
+}
+function createIgnoreMatcher(ignoreGlobs, cwd = process21.cwd()) {
+  if (ignoreGlobs.length === 0)
+    return () => false;
+  const compiled = compileIgnoreGlobs(ignoreGlobs);
+  if (compiled.length === 0)
+    return () => false;
+  const universalRaw = new Set(UNIVERSAL_IGNORES);
+  return (absPath) => {
+    const normalizedAbs = toPosixPath(absPath);
+    const normalizedCwd = toPosixPath(cwd).replace(/\/$/, "");
+    const isOutsideProject = !normalizedAbs.startsWith(normalizedCwd);
+    const rel = isOutsideProject ? normalizedAbs : normalizedAbs.slice(normalizedCwd.length);
+    for (const pattern of compiled) {
+      if (isOutsideProject && !universalRaw.has(pattern.raw))
+        continue;
+      if (pattern.kind === "extension") {
+        if (rel.endsWith(`.${pattern.value}`))
+          return true;
+        continue;
+      }
+      if (pattern.kind === "segment" || pattern.kind === "suffix") {
+        const name = pattern.value;
+        if (rel.includes(`/${name}/`) || rel.endsWith(`/${name}`))
+          return true;
+      }
     }
-  }
-  return false;
+    return false;
+  };
+}
+function shouldIgnorePath(absPath, ignoreGlobs) {
+  return createIgnoreMatcher(ignoreGlobs)(absPath);
 }
 var MAX_FIXER_PASSES = 5, ENV, UNIVERSAL_IGNORES, colors, _cachedDefaultConfig = null;
 var init_utils3 = __esm(() => {
@@ -37646,6 +37779,7 @@ async function runFormat(globs, options) {
     return !absBase.startsWith(process23.cwd());
   });
   const globIgnores = isGlobbingOutsideProject ? [...UNIVERSAL_IGNORES] : cfg.ignores;
+  const ignoreMatcher = createIgnoreMatcher(globIgnores);
   let entries = [];
   const simpleDirPattern = patterns.length === 1 && /\*\*\/\*$/.test(patterns[0]);
   if (simpleDirPattern) {
@@ -37660,7 +37794,7 @@ async function runFormat(globs, options) {
         for (const it of items) {
           const full = join8(dir, it);
           const st = statSync4(full);
-          if (shouldIgnorePath(full, globIgnores))
+          if (ignoreMatcher(full))
             continue;
           if (st.isDirectory())
             stack.push(full);
@@ -37686,7 +37820,7 @@ async function runFormat(globs, options) {
   }
   trace("globbed entries", entries.length);
   const files = entries.filter((f) => {
-    if (shouldIgnorePath(f, globIgnores))
+    if (ignoreMatcher(f))
       return false;
     const idx = f.lastIndexOf(".");
     if (idx < 0)
@@ -37758,24 +37892,21 @@ function trace2(...args) {
     getLogger2().error("[pickier:trace]", args);
 }
 async function lintText(text, cfg, filePath = "untitled", signal) {
-  if (signal?.aborted) {
+  if (signal?.aborted)
     throw new Error("AbortError");
-  }
-  const cfg2 = cfg;
-  cfg2._internalSkipPluginRulesInScan = true;
-  const issues = scanContent(filePath, text, cfg);
+  const suppress = parseDisableDirectives(text);
+  const commentLines = getCommentLines(text);
+  const issues = scanContentOptimized(filePath, text, cfg, suppress, commentLines);
   if (signal?.aborted)
     throw new Error("AbortError");
   try {
     const pluginIssues = await applyPlugins(filePath, text, cfg);
-    const suppress = parseDisableDirectives(text);
-    const commentLines = getCommentLines(text);
     for (const i of pluginIssues) {
       if (signal?.aborted)
         throw new Error("AbortError");
       if (isSuppressed(i.ruleId, i.line, suppress))
         continue;
-      if (commentLines.has(i.line))
+      if (commentLines.has(i.line) && shouldSkipCommentOnlyPluginIssue(i.ruleId))
         continue;
       issues.push({
         filePath: i.filePath,
@@ -37809,6 +37940,7 @@ async function runLintProgrammatic(globs, options, signal) {
     return !absBase.startsWith(process25.cwd());
   });
   const globIgnores = isGlobbingOutsideProject ? [...UNIVERSAL_IGNORES] : cfg.ignores;
+  const ignoreMatcher = createIgnoreMatcher(globIgnores);
   let entries = [];
   const nonGlobSingle = patterns.length === 1 && !/[*?[\]{}()!]/.test(patterns[0]);
   if (nonGlobSingle) {
@@ -37834,7 +37966,7 @@ async function runLintProgrammatic(globs, options, signal) {
         for (const it of items) {
           const full = join11(dir, it);
           const st = statSync6(full);
-          if (shouldIgnorePath(full, globIgnores))
+          if (ignoreMatcher(full))
             continue;
           if (st.isDirectory())
             stack.push(full);
@@ -37873,7 +38005,7 @@ async function runLintProgrammatic(globs, options, signal) {
       cntNodeModules++;
       continue;
     }
-    if (shouldIgnorePath(f, globIgnores)) {
+    if (ignoreMatcher(f)) {
       cntIgnored++;
       continue;
     }
@@ -37886,15 +38018,12 @@ async function runLintProgrammatic(globs, options, signal) {
   }
   trace2("filter:programmatic", { total: cntTotal, included: cntIncluded, node_modules: cntNodeModules, ignored: cntIgnored, wrongExt: cntWrongExt });
   const concurrency = ENV.CONCURRENCY;
-  const limit = createLimiter(concurrency);
   const processFile = async (file) => {
     if (signal?.aborted)
       throw new Error("AbortError");
     const src = readFileSync10(file, "utf8");
     const suppress = parseDisableDirectives(src);
     const commentLines = getCommentLines(src);
-    const cfgAny = cfg;
-    cfgAny._internalSkipPluginRulesInScan = true;
     let issues = scanContentOptimized(file, src, cfg, suppress, commentLines);
     try {
       const pluginIssues = await applyPlugins(file, src, cfg);
@@ -37903,7 +38032,7 @@ async function runLintProgrammatic(globs, options, signal) {
           throw new Error("AbortError");
         if (isSuppressed(i.ruleId, i.line, suppress))
           continue;
-        if (commentLines.has(i.line))
+        if (commentLines.has(i.line) && shouldSkipCommentOnlyPluginIssue(i.ruleId))
           continue;
         issues.push({
           filePath: i.filePath,
@@ -37953,7 +38082,7 @@ async function runLintProgrammatic(globs, options, signal) {
     }
     return issues;
   };
-  const issueArrays = await Promise.all(files.map((file) => limit(() => processFile(file))));
+  const issueArrays = await processWithConcurrency(files, concurrency, processFile);
   const allIssues = issueArrays.flat();
   const errors = allIssues.filter((i) => i.severity === "error").length;
   const warnings = allIssues.filter((i) => i.severity === "warning").length;
@@ -37975,10 +38104,10 @@ function parseDisableDirectives(content) {
   for (let i = 0;i < lines.length; i++) {
     const t = lines[i].trim();
     const lineNo = i + 1;
-    const nextLineMatch = t.match(/^\/\/\s*(?:eslint|pickier)-disable-next-line\s+(\S.*)$/);
+    const nextLineMatch = t.match(/^\/\/\s*(?:eslint|pickier)-disable-next-line(?:\s+(\S.*))?$/);
     if (nextLineMatch) {
-      const ruleText = nextLineMatch[1].replace(/\s+--\s.*$/, "");
-      const list = ruleText.split(",").map((s) => s.trim()).filter(Boolean);
+      const ruleText = nextLineMatch[1]?.replace(/\s+--\s.*$/, "");
+      const list = ruleText ? ruleText.split(",").map((s) => s.trim()).filter(Boolean) : ["*"];
       if (list.length > 0) {
         const target = lineNo + 1;
         const set = nextLine.get(target) || new Set;
@@ -38069,23 +38198,6 @@ function parseDisableDirectives(content) {
   const sortedEnableLines = Array.from(rangeEnable.keys()).sort((a, b) => a - b);
   return { nextLine, fileLevel, rangeDisable, rangeEnable, sortedDisableLines, sortedEnableLines };
 }
-function binarySearchLargestLessThan(arr, target) {
-  if (arr.length === 0 || arr[0] >= target)
-    return -1;
-  let left = 0;
-  let right = arr.length - 1;
-  let result = -1;
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    if (arr[mid] < target) {
-      result = arr[mid];
-      left = mid + 1;
-    } else {
-      right = mid - 1;
-    }
-  }
-  return result;
-}
 function isSuppressed(ruleId, line, directives) {
   if (directives instanceof Map) {
     const set = directives.get(line);
@@ -38100,14 +38212,28 @@ function isSuppressed(ruleId, line, directives) {
   const nextLineSet = directives.nextLine.get(line);
   if (nextLineSet && matchesRule(ruleId, nextLineSet))
     return true;
-  const lastDisableLine = binarySearchLargestLessThan(directives.sortedDisableLines, line);
-  const lastEnableLine = binarySearchLargestLessThan(directives.sortedEnableLines, line);
-  if (lastDisableLine !== -1 && lastDisableLine > lastEnableLine) {
-    const disabledRules = directives.rangeDisable.get(lastDisableLine);
-    if (matchesRule(ruleId, disabledRules))
-      return true;
+  let disabled = false;
+  let disableIndex = 0;
+  let enableIndex = 0;
+  while (true) {
+    const nextDisable = disableIndex < directives.sortedDisableLines.length ? directives.sortedDisableLines[disableIndex] : Number.POSITIVE_INFINITY;
+    const nextEnable = enableIndex < directives.sortedEnableLines.length ? directives.sortedEnableLines[enableIndex] : Number.POSITIVE_INFINITY;
+    const nextDirectiveLine = Math.min(nextDisable, nextEnable);
+    if (nextDirectiveLine >= line)
+      break;
+    if (nextDisable === nextDirectiveLine) {
+      const disabledRules = directives.rangeDisable.get(nextDisable);
+      if (matchesRule(ruleId, disabledRules))
+        disabled = true;
+      disableIndex++;
+      continue;
+    }
+    const enabledRules = directives.rangeEnable.get(nextEnable);
+    if (enabledRules.has("*") || matchesRule(ruleId, enabledRules))
+      disabled = false;
+    enableIndex++;
   }
-  return false;
+  return disabled;
 }
 function matchesRule(ruleId, ruleSet) {
   if (ruleSet.size === 0)
@@ -38127,6 +38253,9 @@ function matchesRule(ruleId, ruleSet) {
   }
   return false;
 }
+function shouldSkipCommentOnlyPluginIssue(ruleId) {
+  return ruleId !== "spaced-comment" && !ruleId.endsWith("/spaced-comment");
+}
 function ensureHelpText(issue, ruleId) {
   if (issue.help) {
     return issue;
@@ -38163,8 +38292,22 @@ async function withTimeout2(p, ms, label) {
     throw e;
   }
 }
-async function applyPlugins(filePath, content, cfg) {
-  const issues = [];
+async function processWithConcurrency(items, concurrency, worker) {
+  const results = new Array(items.length);
+  if (items.length === 0)
+    return results;
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(Math.max(1, concurrency), items.length));
+  async function runWorker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await worker(items[index], index);
+    }
+  }
+  await Promise.all(Array.from({ length: workerCount }, runWorker));
+  return results;
+}
+function getPluginDefinitions(cfg) {
   let pluginDefs = getAllPlugins();
   if (cfg.plugins && cfg.plugins.length > 0) {
     const coreNames = new Set(["pickier", "style", "regexp", "ts"]);
@@ -38174,6 +38317,9 @@ async function applyPlugins(filePath, content, cfg) {
     for (const p of userPlugins)
       pluginDefs.push(p);
   }
+  return pluginDefs;
+}
+function getRulesConfig(cfg, pluginDefs) {
   const rulesConfig = { ...cfg.pluginRules || {} };
   if (cfg.rules?.noUnusedCapturingGroup)
     rulesConfig["regexp/no-unused-capturing-group"] = cfg.rules.noUnusedCapturingGroup;
@@ -38183,115 +38329,168 @@ async function applyPlugins(filePath, content, cfg) {
     "antfu/no-top-level-await": "ts/no-top-level-await"
   };
   for (const [alias, target] of Object.entries(ruleAliases)) {
-    if (rulesConfig[alias]) {
+    if (rulesConfig[alias])
       rulesConfig[target] = rulesConfig[alias];
-    }
   }
   for (const key of Object.keys(cfg.pluginRules || {})) {
     if (!key.includes("/")) {
       for (const p of pluginDefs) {
-        if (p.rules && Object.prototype.hasOwnProperty.call(p.rules, key)) {
+        if (p.rules && Object.prototype.hasOwnProperty.call(p.rules, key))
           rulesConfig[`${p.name}/${key}`] = cfg.pluginRules[key];
-        }
       }
     }
   }
-  const baseCtx = { filePath, config: cfg };
+  return rulesConfig;
+}
+function getPluginPlan(cfg) {
+  const cached = pluginPlanCache.get(cfg);
+  if (cached)
+    return cached;
+  const pluginDefs = getPluginDefinitions(cfg);
+  const rulesConfig = getRulesConfig(cfg, pluginDefs);
+  const checkRules = [];
+  const fixRules = [];
+  const fixableRuleIds = new Set(["no-debugger"]);
+  const fixableBareRuleNames = new Set(["no-debugger"]);
   const executedRules = new Set;
   for (const plugin of pluginDefs) {
-    const r = plugin.rules;
-    for (const ruleName in r) {
+    for (const ruleName in plugin.rules) {
       const fullRuleId = `${plugin.name}/${ruleName}`;
       const setting = getRuleSetting(rulesConfig, fullRuleId);
       if (!setting.enabled)
         continue;
-      if (executedRules.has(ruleName)) {
+      if (executedRules.has(ruleName))
         continue;
-      }
       executedRules.add(ruleName);
-      const rule = r[ruleName];
-      const overrideSeverity = setting.severity;
-      if (!rule || typeof rule.check !== "function") {
-        if (overrideSeverity === "error") {
-          issues.push({
-            filePath,
-            line: 1,
-            column: 1,
-            ruleId: `${fullRuleId}-internal`,
-            message: "Rule missing implementation (check function is undefined)",
-            severity: "error"
-          });
-        }
-        continue;
+      const rule = plugin.rules[ruleName];
+      const planned = {
+        pluginName: plugin.name,
+        ruleName,
+        fullRuleId,
+        rule,
+        severity: setting.severity,
+        options: setting.options
+      };
+      if (typeof rule?.check === "function")
+        checkRules.push(planned);
+      else if (setting.severity === "error") {
+        checkRules.push(planned);
+      }
+      if (typeof rule?.fix === "function") {
+        fixRules.push(planned);
+        fixableRuleIds.add(fullRuleId);
+        fixableBareRuleNames.add(ruleName);
+      }
+    }
+  }
+  const plan = { checkRules, fixRules, fixableRuleIds, fixableBareRuleNames };
+  pluginPlanCache.set(cfg, plan);
+  return plan;
+}
+function isShellPath(filePath, content) {
+  return /\.(?:sh|bash|zsh|ksh|dash)$/.test(filePath) || /^#!\s*(?:\/usr\/bin\/env\s+)?(?:ba|z|k|da)?sh\b/.test(content);
+}
+function isLockfilePath(filePath) {
+  return /(?:^|[/\\])(?:bun\.lock|bun\.lockb|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|npm-shrinkwrap\.json)$/.test(filePath);
+}
+function shouldRunPlannedRule(rule, filePath, content) {
+  switch (rule.pluginName) {
+    case "markdown":
+      return filePath.endsWith(".md");
+    case "shell":
+      return isShellPath(filePath, content);
+    case "publint":
+      return /(?:^|[/\\])package\.json$/.test(filePath);
+    case "lockfile":
+      return isLockfilePath(filePath);
+    case "node":
+    case "ts":
+    case "general":
+    case "quality":
+    case "eslint":
+    case "regexp":
+    case "unused-imports":
+    case "perfectionist":
+      return /\.(?:ts|js|tsx|jsx|mts|mjs|cts|cjs)$/.test(filePath);
+    default:
+      return true;
+  }
+}
+async function applyPlugins(filePath, content, cfg) {
+  const issues = [];
+  const plan = getPluginPlan(cfg);
+  const baseCtx = { filePath, config: cfg };
+  for (const planned of plan.checkRules) {
+    if (!shouldRunPlannedRule(planned, filePath, content))
+      continue;
+    const { fullRuleId, rule, severity: overrideSeverity } = planned;
+    if (!rule || typeof rule.check !== "function") {
+      if (overrideSeverity === "error") {
+        issues.push({
+          filePath,
+          line: 1,
+          column: 1,
+          ruleId: `${fullRuleId}-internal`,
+          message: "Rule missing implementation (check function is undefined)",
+          severity: "error"
+        });
       }
-      try {
-        trace2("rule:start", fullRuleId);
-        const ruleTimeoutMs = ENV.RULE_TIMEOUT_MS;
-        const ctx = { ...baseCtx, options: setting.options };
-        const out = await withTimeout2(Promise.resolve().then(() => rule.check(content, ctx)), ruleTimeoutMs, `rule:${fullRuleId}`);
-        trace2("rule:end", fullRuleId, Array.isArray(out) ? out.length : 0);
-        for (const i of out) {
-          const issueWithHelp = ensureHelpText(i, fullRuleId);
-          if (overrideSeverity)
-            issues.push({ ...issueWithHelp, severity: overrideSeverity });
-          else
-            issues.push(issueWithHelp);
-        }
-      } catch (e) {
+      continue;
+    }
+    try {
+      trace2("rule:start", fullRuleId);
+      const ruleTimeoutMs = ENV.RULE_TIMEOUT_MS;
+      const ctx = { ...baseCtx, options: planned.options };
+      const started = performance.now();
+      const out = await withTimeout2(Promise.resolve().then(() => rule.check(content, ctx)), ruleTimeoutMs, `rule:${fullRuleId}`);
+      const elapsed = performance.now() - started;
+      if (elapsed > ruleTimeoutMs) {
         issues.push({
           filePath,
           line: 1,
           column: 1,
           ruleId: `${fullRuleId}-internal`,
-          message: `Rule threw: ${e?.message || e}`,
+          message: `Rule exceeded timeout budget: ${Math.round(elapsed)}ms > ${ruleTimeoutMs}ms`,
           severity: "error"
         });
       }
+      trace2("rule:end", fullRuleId, Array.isArray(out) ? out.length : 0);
+      for (const i of out) {
+        const issueWithHelp = ensureHelpText(i, fullRuleId);
+        if (overrideSeverity)
+          issues.push({ ...issueWithHelp, severity: overrideSeverity });
+        else
+          issues.push(issueWithHelp);
+      }
+    } catch (e) {
+      issues.push({
+        filePath,
+        line: 1,
+        column: 1,
+        ruleId: `${fullRuleId}-internal`,
+        message: `Rule threw: ${e?.message || e}`,
+        severity: "error"
+      });
     }
   }
   return issues;
 }
 function applyPluginFixes(filePath, content, cfg) {
-  const pluginDefs = getAllPlugins();
-  if (cfg.plugins && cfg.plugins.length > 0) {
-    for (const p of cfg.plugins) {
-      if (typeof p === "string")
-        continue;
-      pluginDefs.push(p);
-    }
-  }
-  const rulesConfig = { ...cfg.pluginRules || {} };
-  if (cfg.rules?.noUnusedCapturingGroup)
-    rulesConfig["regexp/no-unused-capturing-group"] = cfg.rules.noUnusedCapturingGroup;
-  for (const key of Object.keys(cfg.pluginRules || {})) {
-    if (!key.includes("/")) {
-      for (const p of pluginDefs) {
-        if (p.rules && Object.prototype.hasOwnProperty.call(p.rules, key))
-          rulesConfig[`${p.name}/${key}`] = cfg.pluginRules[key];
-      }
-    }
-  }
+  const plan = getPluginPlan(cfg);
   const baseCtx = { filePath, config: cfg };
   let out = content;
   let changed = true;
   let passes = 0;
   while (changed && passes++ < MAX_FIXER_PASSES) {
     changed = false;
-    for (const plugin of pluginDefs) {
-      for (const ruleName in plugin.rules) {
-        const fullRuleId = `${plugin.name}/${ruleName}`;
-        const setting = getRuleSetting(rulesConfig, fullRuleId);
-        if (!setting.enabled)
-          continue;
-        const rule = plugin.rules[ruleName];
-        if (typeof rule.fix !== "function")
-          continue;
-        const ctx = { ...baseCtx, options: setting.options };
-        const next = rule.fix(out, ctx);
-        if (next !== out) {
-          out = next;
-          changed = true;
-        }
+    for (const planned of plan.fixRules) {
+      if (!shouldRunPlannedRule(planned, filePath, out))
+        continue;
+      const ctx = { ...baseCtx, options: planned.options };
+      const next = planned.rule.fix(out, ctx);
+      if (next !== out) {
+        out = next;
+        changed = true;
       }
     }
   }
@@ -38460,6 +38659,7 @@ function getCommentLines(content) {
   let state = "code";
   let lineNo = 1;
   let lineHasCode = false;
+  let lineSawComment = false;
   let lineStartedInBlockComment = false;
   for (let i = 0;i < content.length; i++) {
     const ch = content[i];
@@ -38469,11 +38669,14 @@ function getCommentLines(content) {
 `) {
       if (lineStartedInBlockComment && state === "block-comment") {
         commentLines.add(lineNo);
-      } else if (!lineHasCode && state !== "block-comment") {} else if (!lineHasCode) {
+      } else if (!lineHasCode && lineSawComment && state !== "block-comment") {
+        commentLines.add(lineNo);
+      } else if (!lineHasCode && state === "block-comment") {
         commentLines.add(lineNo);
       }
       lineNo++;
       lineHasCode = false;
+      lineSawComment = false;
       lineStartedInBlockComment = state === "block-comment";
       if (state === "line-comment") {
         state = "code";
@@ -38484,6 +38687,7 @@ function getCommentLines(content) {
       case "code":
         if (ch === "/" && next === "/") {
           state = "line-comment";
+          lineSawComment = true;
           i++;
         } else if (ch === "/" && next === "*") {
           let isRegex = false;
@@ -38525,6 +38729,7 @@ function getCommentLines(content) {
             }
             i--;
           } else {
+            lineSawComment = true;
             state = "block-comment";
             i++;
           }
@@ -38619,6 +38824,8 @@ function getCommentLines(content) {
   }
   if (lineStartedInBlockComment && state === "block-comment") {
     commentLines.add(lineNo);
+  } else if (!lineHasCode && lineSawComment && state !== "block-comment") {
+    commentLines.add(lineNo);
   } else if (!lineHasCode && state === "block-comment") {
     commentLines.add(lineNo);
   }
@@ -38635,6 +38842,10 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
   const quotesDisabled = quotesRuleSetting === "off";
   const skipQuotesCheck = quotesDisabled || fileExt === "json" || fileExt === "jsonc" || fileExt === "lock" || isMd || fileExt === "yaml" || fileExt === "yml" || fileExt === "stx" || fileExt === "html" || fileExt === "htm" || fileExt === "vue" || isShell || filePath.endsWith("bun.lock");
   const skipCodeRules = isMd || fileExt === "yaml" || fileExt === "yml" || fileExt === "json" || fileExt === "jsonc" || isShell;
+  const indentRuleSetting = cfg.rules?.indent ?? cfg.pluginRules?.indent ?? cfg.pluginRules?.["style/indent"];
+  const indentDisabled = indentRuleSetting === "off";
+  const isTemplate = fileExt === "stx" || fileExt === "html" || fileExt === "htm" || fileExt === "vue";
+  const shouldCheckIndent = !indentDisabled && !isMd && !isTemplate;
   let quotesReported = false;
   const sevMap = (s) => s === "warn" ? "warning" : s === "error" ? "error" : undefined;
   const wantDebugger = sevMap(cfg.rules.noDebugger);
@@ -38656,33 +38867,34 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
     }
   }
   const linesInTemplate = new Set;
-  let inTemplate = false;
-  let escaped = false;
-  let currentLine = 1;
-  for (let i = 0;i < content.length; i++) {
-    const ch = content[i];
-    if (escaped) {
-      escaped = false;
-      if (ch === `
+  if (content.includes("`")) {
+    let inTemplate = false;
+    let escaped = false;
+    let currentLine = 1;
+    for (let i = 0;i < content.length; i++) {
+      const ch = content[i];
+      if (escaped) {
+        escaped = false;
+        if (ch === `
 `)
-        currentLine++;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (ch === `
+          currentLine++;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === `
 `) {
-      currentLine++;
-      continue;
-    }
-    if (ch === "`") {
-      inTemplate = !inTemplate;
-      continue;
-    }
-    if (inTemplate) {
-      linesInTemplate.add(currentLine);
+        currentLine++;
+        continue;
+      }
+      if (ch === "`") {
+        inTemplate = !inTemplate;
+        continue;
+      }
+      if (inTemplate)
+        linesInTemplate.add(currentLine);
     }
   }
   for (let i = 0;i < lines.length; i++) {
@@ -38701,12 +38913,11 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
         quotesReported = true;
       }
     }
-    const indentRuleSetting = cfg.rules?.indent ?? cfg.pluginRules?.indent ?? cfg.pluginRules?.["style/indent"];
-    const indentDisabled = indentRuleSetting === "off";
-    const isTemplate = fileExt === "stx" || fileExt === "html" || fileExt === "htm" || fileExt === "vue";
-    const leadingMatch = line.match(/^[ \t]*/);
-    const leading = leadingMatch ? leadingMatch[0] : "";
-    if (!indentDisabled && !isMd && !isTemplate && leading.length > 0 && !linesInFencedCodeBlock.has(lineNo) && hasIndentIssue(leading, cfg.format.indent, cfg.format.indentStyle, line)) {
+    let wsEnd = 0;
+    while (wsEnd < line.length && (line.charCodeAt(wsEnd) === 32 || line.charCodeAt(wsEnd) === 9))
+      wsEnd++;
+    const leading = wsEnd > 0 ? line.slice(0, wsEnd) : "";
+    if (shouldCheckIndent && leading.length > 0 && !linesInFencedCodeBlock.has(lineNo) && hasIndentIssue(leading, cfg.format.indent, cfg.format.indentStyle, line)) {
       if (!isSuppressed("indent", lineNo, suppress))
         issues.push({ filePath, line: lineNo, column: 1, ruleId: "indent", message: "Incorrect indentation detected", severity: "warning", help: `Use ${cfg.format.indentStyle === "spaces" ? `${cfg.format.indent} spaces` : "tabs"} for indentation. Configure with format.indent and format.indentStyle in your config` });
     }
@@ -38811,24 +39022,43 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
     }
     if (!skipCodeRules && wantNoCondAssign && !linesInTemplate.has(lineNo)) {
       const strippedLine = stripComments2(stripRegexLiterals(line));
-      const checkCond = (cond) => /[^=!<>]=(?![=>])/.test(cond.replace(/'[^']*'|"[^"]*"/g, '""'));
-      const m1 = strippedLine.match(/\b(?:if|while)\s*\(([^)]*)\)/);
+      const conditionLine = strippedLine.replace(/'[^']*'|"[^"]*"/g, '""');
+      const checkCond = (cond) => /[^=!<>]=(?![=>])/.test(cond);
+      const m1 = conditionLine.match(/\b(?:if|while)\s*\(([^)]*)\)/);
       if (m1) {
         const cond = m1[1];
         if (checkCond(cond)) {
-          if (!isSuppressed("no-cond-assign", lineNo, suppress))
-            issues.push({ filePath, line: lineNo, column: Math.max(1, line.indexOf("(") + 1), ruleId: "no-cond-assign", message: "Unexpected assignment within a conditional expression", severity: wantNoCondAssign, help: "Use === or == for comparison instead of = (assignment). If assignment was intentional, wrap it in parentheses: if ((x = value))" });
+          if (!isSuppressed("no-cond-assign", lineNo, suppress)) {
+            issues.push({
+              filePath,
+              line: lineNo,
+              column: Math.max(1, line.indexOf("(") + 1),
+              ruleId: "no-cond-assign",
+              message: "Unexpected assignment within a conditional expression",
+              severity: wantNoCondAssign,
+              help: "Use === or == for comparison instead of = (assignment). Wrap intentional assignments in extra parentheses."
+            });
+          }
         }
       }
-      const mFor = strippedLine.match(/\bfor\s*\(([^)]*)\)/);
+      const mFor = conditionLine.match(/\bfor\s*\(([^)]*)\)/);
       if (mFor) {
         const inside = mFor[1];
         const parts = inside.split(";");
         if (parts.length >= 2) {
           const cond = parts[1];
           if (checkCond(cond)) {
-            if (!isSuppressed("no-cond-assign", lineNo, suppress))
-              issues.push({ filePath, line: lineNo, column: Math.max(1, line.indexOf("(") + 1), ruleId: "no-cond-assign", message: "Unexpected assignment within a conditional expression", severity: wantNoCondAssign, help: "Use === or == for comparison instead of = (assignment). If assignment was intentional, wrap it in parentheses: for (let i = 0; (x = arr[i]); i++)" });
+            if (!isSuppressed("no-cond-assign", lineNo, suppress)) {
+              issues.push({
+                filePath,
+                line: lineNo,
+                column: Math.max(1, line.indexOf("(") + 1),
+                ruleId: "no-cond-assign",
+                message: "Unexpected assignment within a conditional expression",
+                severity: wantNoCondAssign,
+                help: "Use === or == for comparison instead of = (assignment). Wrap intentional assignments in extra parentheses."
+              });
+            }
           }
         }
       }
@@ -38840,67 +39070,25 @@ function scanContent(filePath, content, cfg) {
   const suppress = parseDisableDirectives(content);
   const commentLines = getCommentLines(content);
   const issues = scanContentOptimized(filePath, content, cfg, suppress, commentLines);
-  if (!cfg._internalSkipPluginRulesInScan) {
-    try {
-      let pluginDefs = getAllPlugins();
-      if (cfg.plugins && cfg.plugins.length > 0) {
-        const coreNames = new Set(["pickier", "style", "regexp", "ts"]);
-        const userPlugins = cfg.plugins.filter((p) => typeof p !== "string");
-        const hasCoreMatch = userPlugins.some((p) => coreNames.has(p.name));
-        pluginDefs = hasCoreMatch ? pluginDefs : [];
-        for (const p of userPlugins)
-          pluginDefs.push(p);
-      }
-      const rulesConfig = { ...cfg.pluginRules || {} };
-      if (cfg.rules?.noUnusedCapturingGroup)
-        rulesConfig["regexp/no-unused-capturing-group"] = cfg.rules.noUnusedCapturingGroup;
-      for (const key of Object.keys(cfg.pluginRules || {})) {
-        if (!key.includes("/")) {
-          for (const p of pluginDefs) {
-            if (p.rules && Object.prototype.hasOwnProperty.call(p.rules, key))
-              rulesConfig[`${p.name}/${key}`] = cfg.pluginRules[key];
-          }
-        }
-      }
-      const isRuleEnabled = (ruleId) => {
-        const raw = rulesConfig[ruleId];
-        const setting = typeof raw === "string" ? raw : undefined;
-        return setting === "error" || setting === "warn" || setting === "warning";
-      };
-      const getRuleSeverity = (ruleId) => {
-        const raw = rulesConfig[ruleId];
-        const setting = typeof raw === "string" ? raw : undefined;
-        if (setting === "error")
-          return "error";
-        if (setting === "warn" || setting === "warning")
-          return "warning";
-        return;
-      };
-      const ctx = { filePath, config: cfg };
-      const executedRulesInScan = new Set;
-      for (const plugin of pluginDefs) {
-        const r = plugin.rules;
-        for (const ruleName in r) {
-          const fullRuleId = `${plugin.name}/${ruleName}`;
-          if (!isRuleEnabled(fullRuleId))
-            continue;
-          if (executedRulesInScan.has(ruleName))
-            continue;
-          executedRulesInScan.add(ruleName);
-          const rule = r[ruleName];
-          if (!rule || typeof rule.check !== "function")
-            continue;
-          const out = rule.check(content, ctx);
-          for (const i of out) {
-            if (!isSuppressed(i.ruleId, i.line, suppress)) {
-              const sev = getRuleSeverity(fullRuleId);
-              issues.push(sev ? { ...i, severity: sev } : i);
-            }
-          }
-        }
+  try {
+    const plan = getPluginPlan(cfg);
+    const ctx = { filePath, config: cfg };
+    for (const planned of plan.checkRules) {
+      if (!shouldRunPlannedRule(planned, filePath, content))
+        continue;
+      if (!planned.rule || typeof planned.rule.check !== "function")
+        continue;
+      const out = planned.rule.check(content, { ...ctx, options: planned.options });
+      for (const i of out) {
+        if (isSuppressed(i.ruleId, i.line, suppress))
+          continue;
+        if (commentLines.has(i.line) && shouldSkipCommentOnlyPluginIssue(i.ruleId))
+          continue;
+        const issueWithHelp = ensureHelpText(i, planned.fullRuleId);
+        issues.push(planned.severity ? { ...issueWithHelp, severity: planned.severity } : issueWithHelp);
       }
-    } catch {}
-  }
+    }
+  } catch {}
   return issues;
 }
 async function runLint(globs, options) {
@@ -38934,6 +39122,7 @@ async function runLint(globs, options) {
       return !absBase.startsWith(process25.cwd());
     });
     const globIgnores = isGlobbingOutsideProject ? [...UNIVERSAL_IGNORES] : cfg.ignores;
+    const ignoreMatcher = createIgnoreMatcher(globIgnores);
     if (enableDiagnostics) {
       getLogger2().info(`[pickier:diagnostics] Globbing outside project: ${isGlobbingOutsideProject}, ignore patterns: ${globIgnores.length}`);
       if (isGlobbingOutsideProject)
@@ -38970,7 +39159,7 @@ async function runLint(globs, options) {
           for (const it of items) {
             const full = join11(dir, it);
             const st = statSync6(full);
-            if (shouldIgnorePath(full, globIgnores))
+            if (ignoreMatcher(full))
               continue;
             if (st.isDirectory())
               stack.push(full);
@@ -39032,7 +39221,7 @@ async function runLint(globs, options) {
         cntNodeModules++;
         continue;
       }
-      if (shouldIgnorePath(f, globIgnores)) {
+      if (ignoreMatcher(f)) {
         cntIgnored++;
         continue;
       }
@@ -39063,7 +39252,6 @@ async function runLint(globs, options) {
       }
     }
     const concurrency = ENV.CONCURRENCY;
-    const limit = createLimiter(concurrency);
     if (enableDiagnostics)
       getLogger2().info(`[pickier:diagnostics] Starting to process ${files.length} files with concurrency ${concurrency}...`);
     let processedCount = 0;
@@ -39077,23 +39265,33 @@ async function runLint(globs, options) {
       const src = readFileSync10(file, "utf8");
       if (formatOnly) {
         const fixed = formatCode(src, cfg, file);
-        if (fixed !== src && !options.dryRun) {
-          writeFileSync11(file, fixed, "utf8");
+        if (fixed !== src) {
+          if (!options.dryRun) {
+            writeFileSync11(file, fixed, "utf8");
+          } else {
+            return [{
+              filePath: file,
+              line: 1,
+              column: 1,
+              ruleId: "format",
+              message: "File is not formatted",
+              severity: "error",
+              help: "Run pickier format with --write to apply formatting."
+            }];
+          }
         }
         return [];
       }
       const suppress = parseDisableDirectives(src);
       const isCodeFileForComments = /\.(?:ts|js|tsx|jsx|mts|mjs|cts|cjs)$/.test(file);
       const commentLines = isCodeFileForComments ? getCommentLines(src) : new Set;
-      const cfgAny = cfg;
-      cfgAny._internalSkipPluginRulesInScan = true;
       let issues = scanContentOptimized(file, src, cfg, suppress, commentLines);
       try {
         const pluginIssues = await applyPlugins(file, src, cfg);
         for (const i of pluginIssues) {
           if (isSuppressed(i.ruleId, i.line, suppress))
             continue;
-          if (commentLines.has(i.line))
+          if (commentLines.has(i.line) && shouldSkipCommentOnlyPluginIssue(i.ruleId))
             continue;
           issues.push({
             filePath: i.filePath,
@@ -39152,7 +39350,7 @@ async function runLint(globs, options) {
       trace2("scan done", relative7(process25.cwd(), file), issues.length);
       return issues;
     };
-    const issueArrays = await Promise.all(files.map((file) => limit(() => processFile(file))));
+    const issueArrays = await processWithConcurrency(files, concurrency, processFile);
     const allIssues = issueArrays.flat();
     if (enableDiagnostics)
       getLogger2().info(`[pickier:diagnostics] Processing complete! Found ${allIssues.length} issues total`);
@@ -39177,22 +39375,12 @@ async function runLint(globs, options) {
       const problemsText = total === 1 ? "problem" : "problems";
       const errorsText = errors === 1 ? "error" : "errors";
       const warningsText = warnings === 1 ? "warning" : "warnings";
-      const pluginDefs = getAllPlugins();
-      const fixableRuleIds = new Set;
-      fixableRuleIds.add("no-debugger");
-      for (const plugin of pluginDefs) {
-        for (const ruleName in plugin.rules) {
-          const rule = plugin.rules[ruleName];
-          if (rule && typeof rule.fix === "function") {
-            fixableRuleIds.add(`${plugin.name}/${ruleName}`);
-          }
-        }
-      }
+      const pluginPlan = getPluginPlan(cfg);
       let fixableErrors = 0;
       let fixableWarnings = 0;
       for (const issue of allIssues) {
         const ruleId = issue.ruleId;
-        const isFixable = fixableRuleIds.has(ruleId) || Array.from(fixableRuleIds).some((id) => id.endsWith(`/${ruleId}`));
+        const isFixable = pluginPlan.fixableRuleIds.has(ruleId) || pluginPlan.fixableBareRuleNames.has(ruleId);
         if (isFixable) {
           if (issue.severity === "error")
             fixableErrors++;
@@ -39233,13 +39421,14 @@ async function runLint(globs, options) {
     return 1;
   }
 }
-var _logger2 = null;
+var _logger2 = null, pluginPlanCache;
 var init_linter = __esm(() => {
   init_src();
   init_format();
   init_formatter();
   init_plugins();
   init_utils3();
+  pluginPlanCache = new WeakMap;
 });
 
 // src/run.ts
@@ -39261,6 +39450,8 @@ async function runUnified(globs, options) {
         const cfg = await loadConfigFromPath(options.config);
         const src = readFileSync11(filePath, "utf8");
         const fmt = formatCode(src, cfg, filePath);
+        if (options.check && fmt !== src)
+          return 1;
         if (options.write && fmt !== src) {
           writeFileSync12(filePath, fmt, "utf8");
         }
@@ -39327,6 +39518,7 @@ export {
   detectQuoteIssues,
   defaultConfig4 as defaultConfig,
   createLimiter,
+  createIgnoreMatcher,
   config5 as config,
   colors,
   colorize,