From 072d37e8e4f82454d2e187114d0194f26efc1bf0 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:23 -0500
Subject: [PATCH 01/33] perf(plugin): memoize closureCaptures per scope
 analysis and function node (#1039)

Nested callbacks now compute once and every enclosing function and
calling rule reuses the shared result; the defensive per-reference
containment re-filter is dropped (the walk already guarantees it).

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-closure-captures-memo.md      |   5 +
 .../plugin/semantic/closure-captures.test.ts  | 151 ++++++++++++++++++
 .../src/plugin/semantic/closure-captures.ts   |  56 +++++--
 3 files changed, 197 insertions(+), 15 deletions(-)
 create mode 100644 .changeset/perf-closure-captures-memo.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.test.ts

diff --git a/.changeset/perf-closure-captures-memo.md b/.changeset/perf-closure-captures-memo.md
new file mode 100644
index 0000000000..e77766ae83
--- /dev/null
+++ b/.changeset/perf-closure-captures-memo.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: memoize `closureCaptures` per (ScopeAnalysis, function node) so nested callbacks compute once and every calling rule reuses the result, and drop the redundant per-reference containment re-filter
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.test.ts
new file mode 100644
index 0000000000..9ce037de84
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.test.ts
@@ -0,0 +1,151 @@
+import { describe, expect, it } from "@voidzero-dev/vite-plus-test";
+import { closureCaptures } from "./closure-captures.js";
+import { analyzeScopes } from "./scope-analysis.js";
+import { attachParentReferences } from "../../test-utils/attach-parent-references.js";
+import { parseFixture } from "../../test-utils/parse-fixture.js";
+import type { EsTreeNode } from "../utils/es-tree-node.js";
+import { isFunctionLike } from "../utils/is-function-like.js";
+
+const analyze = (code: string) => {
+  const parsed = parseFixture(code);
+  attachParentReferences(parsed.program);
+  return { scopes: analyzeScopes(parsed.program), program: parsed.program };
+};
+
+const findFunctionNode = (root: EsTreeNode, name: string): EsTreeNode | null => {
+  let result: EsTreeNode | null = null;
+  const visit = (node: EsTreeNode): void => {
+    if (result) return;
+    if (
+      node.type === "FunctionDeclaration" &&
+      (node as { id?: { name?: string } }).id?.name === name
+    ) {
+      result = node;
+      return;
+    }
+    if (node.type === "VariableDeclarator") {
+      const declarator = node as { id?: { name?: string }; init?: EsTreeNode };
+      if (declarator.id?.name === name && declarator.init && isFunctionLike(declarator.init)) {
+        result = declarator.init;
+        return;
+      }
+    }
+    const record = node as unknown as Record<string, unknown>;
+    for (const key of Object.keys(record)) {
+      if (key === "parent") continue;
+      const child = record[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && "type" in item) {
+            visit(item as EsTreeNode);
+            if (result) return;
+          }
+        }
+      } else if (child && typeof child === "object" && "type" in (child as object)) {
+        visit(child as EsTreeNode);
+      }
+    }
+  };
+  visit(root);
+  return result;
+};
+
+const capturedNames = (captures: ReadonlyArray<{ resolvedSymbol: { name: string } | null }>) =>
+  captures.map((capture) => capture.resolvedSymbol?.name).sort();
+
+describe("closureCaptures", () => {
+  it("collects references whose binding lives outside the function", () => {
+    const { scopes, program } = analyze(`
+      const useGreeting = () => {
+        const greeting = "hi";
+        const speak = () => greeting;
+        return speak;
+      };
+    `);
+    const speak = findFunctionNode(program, "speak")!;
+    expect(capturedNames(closureCaptures(speak, scopes))).toEqual(["greeting"]);
+  });
+
+  it("excludes parameters and internal locals", () => {
+    const { scopes, program } = analyze(`
+      const shout = (subject) => {
+        const punctuation = "!";
+        return subject + punctuation;
+      };
+    `);
+    const shout = findFunctionNode(program, "shout")!;
+    expect(closureCaptures(shout, scopes)).toEqual([]);
+  });
+
+  it("excludes the function's own recursive self-reference", () => {
+    const { scopes, program } = analyze(`
+      function countdown(steps) {
+        if (steps === 0) return;
+        countdown(steps - 1);
+      }
+    `);
+    const countdown = findFunctionNode(program, "countdown")!;
+    expect(closureCaptures(countdown, scopes)).toEqual([]);
+  });
+
+  it("bubbles nested-function captures up to every enclosing function", () => {
+    const { scopes, program } = analyze(`
+      const useOuter = () => {
+        const outerValue = 1;
+        const middle = () => {
+          const middleValue = 2;
+          const inner = () => outerValue + middleValue;
+          return inner;
+        };
+        return middle;
+      };
+    `);
+    const middle = findFunctionNode(program, "middle")!;
+    const inner = findFunctionNode(program, "inner")!;
+    expect(capturedNames(closureCaptures(inner, scopes))).toEqual(["middleValue", "outerValue"]);
+    expect(capturedNames(closureCaptures(middle, scopes))).toEqual(["outerValue"]);
+    const useOuter = findFunctionNode(program, "useOuter")!;
+    expect(closureCaptures(useOuter, scopes)).toEqual([]);
+  });
+
+  it("excludes globals (unresolved references)", () => {
+    const { scopes, program } = analyze(`
+      const report = () => {
+        console.log(window.location.href);
+      };
+    `);
+    const report = findFunctionNode(program, "report")!;
+    expect(closureCaptures(report, scopes)).toEqual([]);
+  });
+
+  it("returns the memoized result on repeat calls with the same analysis", () => {
+    const { scopes, program } = analyze(`
+      const useCounter = () => {
+        const step = 1;
+        const increment = (count) => count + step;
+        return increment;
+      };
+    `);
+    const increment = findFunctionNode(program, "increment")!;
+    const firstResult = closureCaptures(increment, scopes);
+    const secondResult = closureCaptures(increment, scopes);
+    expect(secondResult).toBe(firstResult);
+    expect(capturedNames(secondResult)).toEqual(["step"]);
+  });
+
+  it("computes fresh results for a different ScopeAnalysis over the same AST", () => {
+    const { scopes, program } = analyze(`
+      const useLabel = () => {
+        const label = "x";
+        const describeLabel = () => label;
+        return describeLabel;
+      };
+    `);
+    const describeLabel = findFunctionNode(program, "describeLabel")!;
+    const firstResult = closureCaptures(describeLabel, scopes);
+    const freshScopes = analyzeScopes(program);
+    const freshResult = closureCaptures(describeLabel, freshScopes);
+    expect(freshResult).not.toBe(firstResult);
+    expect(capturedNames(freshResult)).toEqual(capturedNames(firstResult));
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.ts b/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.ts
index 0f1047fcaf..e5eb4cd851 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.ts
@@ -2,21 +2,10 @@ import type { EsTreeNode } from "../utils/es-tree-node.js";
 import type { ReferenceDescriptor, ScopeAnalysis } from "./scope-analysis.js";
 import { isDescendantScope } from "./scope-analysis.js";
 import { TYPE_POSITION_CHILD_KEYS } from "../constants/ts-type-position-keys.js";
-import { isAstDescendant } from "../utils/is-ast-descendant.js";
 import { isAstNode } from "../utils/is-ast-node.js";
 import { isFunctionLike } from "../utils/is-function-like.js";
 
-// True if `inner` is a descendant of `outer` (or equal) in the AST
-// tree. Used to filter references inside `functionNode`.
-// Returns every reference inside `functionNode`'s body whose binding
-// lives OUTSIDE the function — i.e. the closure-captured set. Useful
-// for exhaustive-deps to compute the actual set of values a hook
-// callback closes over.
-//
-// Excludes: globals (unresolved references), references whose binding
-// is the function itself (recursive call) or its parameters /
-// internal locals.
-export const closureCaptures = (
+const computeClosureCaptures = (
   functionNode: EsTreeNode,
   scopes: ScopeAnalysis,
 ): ReadonlyArray<ReferenceDescriptor> => {
@@ -72,7 +61,44 @@ export const closureCaptures = (
   };
   visit(functionNode);
 
-  // Filter out references whose identifier is OUTSIDE functionNode in
-  // the AST (defensive — shouldn't happen given our walk).
-  return out.filter((reference) => isAstDescendant(reference.identifier, functionNode));
+  // Every collected reference's identifier IS a walked descendant of
+  // `functionNode` (`referenceFor` is keyed by the identifier node, and
+  // bubbled inner captures sit inside inner subtrees), so no
+  // containment re-check is needed here.
+  return out;
+};
+
+// Memoized per (ScopeAnalysis, function node). The walk recurses into
+// inner functions through this entry point, so nested callbacks compute
+// once and every enclosing function — and every calling rule — reuses
+// the shared frozen-by-convention array (`ReadonlyArray`, callers only
+// iterate). Keyed on the ScopeAnalysis first because the semantic-
+// context fallback can mint throwaway stub analyses for the same AST.
+const capturesByAnalysis = new WeakMap<
+  ScopeAnalysis,
+  WeakMap<EsTreeNode, ReadonlyArray<ReferenceDescriptor>>
+>();
+
+// Returns every reference inside `functionNode`'s body whose binding
+// lives OUTSIDE the function — i.e. the closure-captured set. Useful
+// for exhaustive-deps to compute the actual set of values a hook
+// callback closes over.
+//
+// Excludes: globals (unresolved references), references whose binding
+// is the function itself (recursive call) or its parameters /
+// internal locals.
+export const closureCaptures = (
+  functionNode: EsTreeNode,
+  scopes: ScopeAnalysis,
+): ReadonlyArray<ReferenceDescriptor> => {
+  let capturesByFunction = capturesByAnalysis.get(scopes);
+  if (!capturesByFunction) {
+    capturesByFunction = new WeakMap();
+    capturesByAnalysis.set(scopes, capturesByFunction);
+  }
+  const memoizedCaptures = capturesByFunction.get(functionNode);
+  if (memoizedCaptures) return memoizedCaptures;
+  const computedCaptures = computeClosureCaptures(functionNode, scopes);
+  capturesByFunction.set(functionNode, computedCaptures);
+  return computedCaptures;
 };

From a1c8ee110e137bbc8771c8a471c20287cccd2b38 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:25 -0500
Subject: [PATCH 02/33] perf(plugin): index line starts once per content in
 security-scan locations (#1040)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

getLocationAtIndex sliced and split the whole content prefix on every
call — O(content) per regex match on the synchronous, event-loop-blocking
security scan. Build a per-content line-start table once and answer each
query with a binary search.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-security-scan-line-index.md   |   5 +
 .../utils/get-location-at-index.test.ts       | 123 ++++++++++++++++++
 .../utils/get-location-at-index.ts            |  51 +++++++-
 3 files changed, 173 insertions(+), 6 deletions(-)
 create mode 100644 .changeset/perf-security-scan-line-index.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.test.ts

diff --git a/.changeset/perf-security-scan-line-index.md b/.changeset/perf-security-scan-line-index.md
new file mode 100644
index 0000000000..a8e5975688
--- /dev/null
+++ b/.changeset/perf-security-scan-line-index.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: replace the security scan's per-match O(content) slice+split in `getLocationAtIndex` with a memoized per-content line-start index answered by binary search
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.test.ts
new file mode 100644
index 0000000000..679dd4c1c9
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vite-plus/test";
+import type { SourceLocation } from "./get-location-at-index.js";
+import { getLocationAtIndex } from "./get-location-at-index.js";
+
+// Reference: the previous slice+split implementation whose outputs are the
+// pinned contract (line/column are 1-based; `\r?\n` is the line separator).
+const referenceLocationAtIndex = (content: string, matchIndex: number): SourceLocation => {
+  if (matchIndex < 0) return { line: 1, column: 1 };
+  const prefix = content.slice(0, matchIndex);
+  const lines = prefix.split(/\r?\n/);
+  return {
+    line: lines.length,
+    column: (lines[lines.length - 1]?.length ?? 0) + 1,
+  };
+};
+
+describe("security-scan/utils/get-location-at-index", () => {
+  it("reports line 1 column 1 at index 0", () => {
+    expect(getLocationAtIndex("hello world", 0)).toEqual({ line: 1, column: 1 });
+  });
+
+  it("reports line 1 column 1 for a negative index", () => {
+    expect(getLocationAtIndex("hello world", -1)).toEqual({ line: 1, column: 1 });
+  });
+
+  it("reports line 1 column 1 for a NaN index", () => {
+    expect(getLocationAtIndex("ab\ncd", Number.NaN)).toEqual({ line: 1, column: 1 });
+  });
+
+  it("reports a 1-based column within the first line", () => {
+    expect(getLocationAtIndex("hello world", 6)).toEqual({ line: 1, column: 7 });
+  });
+
+  it("locates an index on a later LF line", () => {
+    expect(getLocationAtIndex("ab\ncd\nef", 4)).toEqual({ line: 2, column: 2 });
+  });
+
+  it("treats the index of a bare \\n as the end of its line", () => {
+    expect(getLocationAtIndex("ab\ncd", 2)).toEqual({ line: 1, column: 3 });
+  });
+
+  it("starts a new line right after a bare \\n", () => {
+    expect(getLocationAtIndex("ab\ncd", 3)).toEqual({ line: 2, column: 1 });
+  });
+
+  it("locates an index after a \\r\\n separator", () => {
+    expect(getLocationAtIndex("ab\r\ncd", 5)).toEqual({ line: 2, column: 2 });
+  });
+
+  it("treats the index of the \\r in \\r\\n as the end of its line", () => {
+    expect(getLocationAtIndex("ab\r\ncd", 2)).toEqual({ line: 1, column: 3 });
+  });
+
+  it("counts the \\r as a column when the index sits on the \\n of \\r\\n", () => {
+    expect(getLocationAtIndex("ab\r\ncd", 3)).toEqual({ line: 1, column: 4 });
+  });
+
+  it("starts a new line right after a \\r\\n separator", () => {
+    expect(getLocationAtIndex("ab\r\ncd", 4)).toEqual({ line: 2, column: 1 });
+  });
+
+  it("does not treat a lone \\r as a line separator", () => {
+    expect(getLocationAtIndex("ab\rcd", 4)).toEqual({ line: 1, column: 5 });
+  });
+
+  it("locates the end of content", () => {
+    expect(getLocationAtIndex("ab\ncd", 5)).toEqual({ line: 2, column: 3 });
+  });
+
+  it("locates the end of content after a trailing \\n", () => {
+    expect(getLocationAtIndex("ab\n", 3)).toEqual({ line: 2, column: 1 });
+  });
+
+  it("clamps a past-end index to the end of content", () => {
+    expect(getLocationAtIndex("ab\ncd", 50)).toEqual({ line: 2, column: 3 });
+    expect(getLocationAtIndex("hello world", 50)).toEqual({ line: 1, column: 12 });
+  });
+
+  it("handles empty content", () => {
+    expect(getLocationAtIndex("", 0)).toEqual({ line: 1, column: 1 });
+    expect(getLocationAtIndex("", 5)).toEqual({ line: 1, column: 1 });
+  });
+
+  it("handles consecutive newlines", () => {
+    expect(getLocationAtIndex("a\n\nb", 2)).toEqual({ line: 2, column: 1 });
+    expect(getLocationAtIndex("a\n\nb", 3)).toEqual({ line: 3, column: 1 });
+  });
+
+  it("handles mixed \\r\\n and \\n separators in one content", () => {
+    expect(getLocationAtIndex("a\r\nb\nc\r\nd", 8)).toEqual({ line: 4, column: 1 });
+  });
+
+  it("stays correct when queries alternate between contents", () => {
+    const firstContent = "ab\ncd\nef";
+    const secondContent = "one\r\ntwo\r\nthree";
+    expect(getLocationAtIndex(firstContent, 7)).toEqual({ line: 3, column: 2 });
+    expect(getLocationAtIndex(secondContent, 6)).toEqual({ line: 2, column: 2 });
+    expect(getLocationAtIndex(firstContent, 7)).toEqual({ line: 3, column: 2 });
+    expect(getLocationAtIndex(secondContent, 12)).toEqual({ line: 3, column: 3 });
+  });
+
+  it("matches the reference implementation on seeded pseudo-random contents", () => {
+    let seedState = 0x2f6e2b1;
+    const nextRandom = (): number => {
+      seedState = (seedState * 48271) % 0x7fffffff;
+      return seedState / 0x7fffffff;
+    };
+    const alphabet = ["a", "b", " ", "\n", "\r", "\r\n", "\t", "é", "x\ny"];
+    for (let contentRound = 0; contentRound < 60; contentRound += 1) {
+      const pieceCount = Math.floor(nextRandom() * 40);
+      let content = "";
+      for (let pieceIndex = 0; pieceIndex < pieceCount; pieceIndex += 1) {
+        content += alphabet[Math.floor(nextRandom() * alphabet.length)];
+      }
+      for (let queryRound = 0; queryRound < 25; queryRound += 1) {
+        const matchIndex = Math.floor(nextRandom() * (content.length + 3)) - 1;
+        expect(getLocationAtIndex(content, matchIndex)).toEqual(
+          referenceLocationAtIndex(content, matchIndex),
+        );
+      }
+    }
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.ts
index 4d49530912..8c830fb570 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/get-location-at-index.ts
@@ -3,13 +3,52 @@ export interface SourceLocation {
   readonly column: number;
 }
 
-// O(content) per call — memoizing line offsets is a tracked follow-up.
+interface ContentLineIndex {
+  readonly content: string;
+  readonly lineStartOffsets: ReadonlyArray<number>;
+}
+
+// Single-entry memo: the security scan is synchronous and processes one
+// file's content at a time (per-match exec loops query the same string
+// consecutively), so caching the last content's line index is enough and
+// stays bounded — it holds at most one content string reference.
+let lastContentLineIndex: ContentLineIndex | undefined;
+
+const buildLineStartOffsets = (content: string): number[] => {
+  const lineStartOffsets = [0];
+  for (
+    let newlineIndex = content.indexOf("\n");
+    newlineIndex !== -1;
+    newlineIndex = content.indexOf("\n", newlineIndex + 1)
+  ) {
+    lineStartOffsets.push(newlineIndex + 1);
+  }
+  return lineStartOffsets;
+};
+
+const getLineStartOffsets = (content: string): ReadonlyArray<number> => {
+  if (lastContentLineIndex?.content === content) return lastContentLineIndex.lineStartOffsets;
+  const lineStartOffsets = buildLineStartOffsets(content);
+  lastContentLineIndex = { content, lineStartOffsets };
+  return lineStartOffsets;
+};
+
 export const getLocationAtIndex = (content: string, matchIndex: number): SourceLocation => {
-  if (matchIndex < 0) return { line: 1, column: 1 };
-  const prefix = content.slice(0, matchIndex);
-  const lines = prefix.split(/\r?\n/);
+  if (Number.isNaN(matchIndex) || matchIndex < 0) return { line: 1, column: 1 };
+  const lineStartOffsets = getLineStartOffsets(content);
+  const boundedIndex = Math.min(Math.trunc(matchIndex), content.length);
+  let lowLineIndex = 0;
+  let highLineIndex = lineStartOffsets.length - 1;
+  while (lowLineIndex < highLineIndex) {
+    const midLineIndex = (lowLineIndex + highLineIndex + 1) >> 1;
+    if (lineStartOffsets[midLineIndex] <= boundedIndex) {
+      lowLineIndex = midLineIndex;
+    } else {
+      highLineIndex = midLineIndex - 1;
+    }
+  }
   return {
-    line: lines.length,
-    column: (lines[lines.length - 1]?.length ?? 0) + 1,
+    line: lowLineIndex + 1,
+    column: boundedIndex - lineStartOffsets[lowLineIndex] + 1,
   };
 };

From 5fec491e6844d73f658f355ae2cbe86285068f0e Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:28 -0500
Subject: [PATCH 03/33] perf(plugin): memoize getElementType per JSX opening
 element across a11y rules (#1041)

~30 a11y rules resolve the same opening element once per rule; cache the
result per node with a settings-identity guard (both hosts hand every
rule the same per-file settings object) and memoize the jsx-a11y settings
block per settings object.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-get-element-type-memo.md      |  5 +
 .../src/plugin/utils/get-element-type.test.ts | 94 +++++++++++++++++++
 .../src/plugin/utils/get-element-type.ts      | 66 ++++++++++---
 3 files changed, 150 insertions(+), 15 deletions(-)
 create mode 100644 .changeset/perf-get-element-type-memo.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.test.ts

diff --git a/.changeset/perf-get-element-type-memo.md b/.changeset/perf-get-element-type-memo.md
new file mode 100644
index 0000000000..1029d29c3c
--- /dev/null
+++ b/.changeset/perf-get-element-type-memo.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: memoize getElementType per JSX opening element (with a settings-identity guard) so the ~30 a11y rules resolve each element once instead of once per rule
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.test.ts
new file mode 100644
index 0000000000..e317ba1db3
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vite-plus/test";
+import { parseFixture } from "../../test-utils/parse-fixture.js";
+import type { EsTreeNode } from "./es-tree-node.js";
+import type { EsTreeNodeOfType } from "./es-tree-node-of-type.js";
+import { getElementType } from "./get-element-type.js";
+import { isNodeOfType } from "./is-node-of-type.js";
+import { walkAst } from "./walk-ast.js";
+
+const parseOpeningElement = (jsx: string): EsTreeNodeOfType<"JSXOpeningElement"> => {
+  const { program, errors } = parseFixture(`const rendered = ${jsx};`);
+  expect(errors).toEqual([]);
+  let openingElement: EsTreeNodeOfType<"JSXOpeningElement"> | null = null;
+  walkAst(program, (child: EsTreeNode) => {
+    if (openingElement) return false;
+    if (isNodeOfType(child, "JSXOpeningElement")) openingElement = child;
+  });
+  if (!openingElement) throw new Error("fixture has no JSX opening element");
+  return openingElement;
+};
+
+describe("getElementType", () => {
+  it("resolves intrinsic elements to their tag name", () => {
+    expect(getElementType(parseOpeningElement("<div />"), undefined)).toBe("div");
+    expect(getElementType(parseOpeningElement("<img src='x.png' />"), undefined)).toBe("img");
+  });
+
+  it("resolves custom components to their identifier name", () => {
+    expect(getElementType(parseOpeningElement("<Button />"), undefined)).toBe("Button");
+  });
+
+  it("flattens member-expression and namespaced names", () => {
+    expect(getElementType(parseOpeningElement("<Menu.Item />"), undefined)).toBe("Menu.Item");
+    expect(getElementType(parseOpeningElement("<svg:rect />"), undefined)).toBe("svg:rect");
+  });
+
+  it("returns the base name when settings carry no jsx-a11y block", () => {
+    expect(getElementType(parseOpeningElement("<Button />"), {})).toBe("Button");
+    expect(getElementType(parseOpeningElement("<Button />"), { "jsx-a11y": "bogus" })).toBe(
+      "Button",
+    );
+  });
+
+  it("maps components through settings['jsx-a11y'].components", () => {
+    const settings = { "jsx-a11y": { components: { Button: "button" } } };
+    expect(getElementType(parseOpeningElement("<Button />"), settings)).toBe("button");
+    expect(getElementType(parseOpeningElement("<Anchor />"), settings)).toBe("Anchor");
+  });
+
+  it("prefers the polymorphic prop's string value over the tag", () => {
+    const settings = { "jsx-a11y": { polymorphicPropName: "as" } };
+    expect(getElementType(parseOpeningElement("<Box as='span' />"), settings)).toBe("span");
+    expect(getElementType(parseOpeningElement("<Box AS='span' />"), settings)).toBe("span");
+  });
+
+  it("falls back past a non-string polymorphic prop value", () => {
+    const settings = {
+      "jsx-a11y": { polymorphicPropName: "as", components: { Box: "div" } },
+    };
+    expect(getElementType(parseOpeningElement("<Box as={tag} />"), settings)).toBe("div");
+    expect(getElementType(parseOpeningElement("<Box as />"), settings)).toBe("div");
+  });
+
+  it("prefers the polymorphic prop over a components mapping", () => {
+    const settings = {
+      "jsx-a11y": { polymorphicPropName: "as", components: { Box: "div" } },
+    };
+    expect(getElementType(parseOpeningElement("<Box as='nav' />"), settings)).toBe("nav");
+  });
+
+  it("returns a stable result on repeated calls with the same settings object", () => {
+    const settings = { "jsx-a11y": { components: { Button: "button" } } };
+    const openingElement = parseOpeningElement("<Button />");
+    expect(getElementType(openingElement, settings)).toBe("button");
+    expect(getElementType(openingElement, settings)).toBe("button");
+  });
+
+  it("does not leak a cached result across different settings objects for the same node", () => {
+    const openingElement = parseOpeningElement("<Button />");
+    const buttonSettings = { "jsx-a11y": { components: { Button: "button" } } };
+    const anchorSettings = { "jsx-a11y": { components: { Button: "a" } } };
+    expect(getElementType(openingElement, buttonSettings)).toBe("button");
+    expect(getElementType(openingElement, anchorSettings)).toBe("a");
+    expect(getElementType(openingElement, undefined)).toBe("Button");
+    expect(getElementType(openingElement, buttonSettings)).toBe("button");
+  });
+
+  it("does not leak a cached undefined-settings result into a mapped lookup", () => {
+    const openingElement = parseOpeningElement("<Button />");
+    expect(getElementType(openingElement, undefined)).toBe("Button");
+    expect(
+      getElementType(openingElement, { "jsx-a11y": { components: { Button: "button" } } }),
+    ).toBe("button");
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.ts
index 7244d785f4..b1606f22da 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/get-element-type.ts
@@ -9,13 +9,25 @@ interface JsxA11ySettings {
   polymorphicPropName?: string;
 }
 
+interface ElementTypeCacheEntry {
+  settings: Readonly<Record<string, unknown>> | undefined;
+  elementType: string;
+}
+
+const EMPTY_JSX_A11Y_SETTINGS: JsxA11ySettings = Object.freeze({});
+
+const jsxA11ySettingsCache = new WeakMap<Readonly<Record<string, unknown>>, JsxA11ySettings>();
+
 const readJsxA11ySettings = (
   settings: Readonly<Record<string, unknown>> | undefined,
 ): JsxA11ySettings => {
-  if (!settings) return {};
+  if (!settings) return EMPTY_JSX_A11Y_SETTINGS;
+  const cachedSettings = jsxA11ySettingsCache.get(settings);
+  if (cachedSettings) return cachedSettings;
   const block = (settings as { ["jsx-a11y"]?: JsxA11ySettings })["jsx-a11y"];
-  if (!block || typeof block !== "object") return {};
-  return block;
+  const a11ySettings = block && typeof block === "object" ? block : EMPTY_JSX_A11Y_SETTINGS;
+  jsxA11ySettingsCache.set(settings, a11ySettings);
+  return a11ySettings;
 };
 
 const flattenJsxName = (name: EsTreeNode): string => {
@@ -30,20 +42,10 @@ const flattenJsxName = (name: EsTreeNode): string => {
   return "";
 };
 
-// Resolves a JSX opening element to the (possibly-aliased) HTML tag
-// name. Mirrors oxc_linter::utils::react::get_element_type.
-//
-// - Honors `settings["jsx-a11y"].polymorphicPropName` (defaults to
-//   none): when the element has that prop with a string-literal
-//   value, the value overrides the element's tag.
-// - Honors `settings["jsx-a11y"].components`: a mapping from
-//   component name → resolved tag (e.g. `{ Button: "button" }`).
-// - Falls back to the JSX identifier / member-expression name.
-export const getElementType = (
+const computeElementType = (
   openingElement: EsTreeNodeOfType<"JSXOpeningElement">,
-  settings: Readonly<Record<string, unknown>> | undefined,
+  a11ySettings: JsxA11ySettings,
 ): string => {
-  const a11ySettings = readJsxA11ySettings(settings);
   const baseName = flattenJsxName(openingElement.name as EsTreeNode);
 
   if (a11ySettings.polymorphicPropName) {
@@ -62,3 +64,37 @@ export const getElementType = (
   }
   return baseName;
 };
+
+// Per-node memo shared by the ~30 a11y rules that resolve the same opening
+// element once per rule. Entries die with the AST via the WeakMap. The result
+// also depends on settings, so each entry carries a settings-identity guard:
+// both hosts hand every rule the same per-file settings object (oxlint parses
+// the settings JSON once per file and exposes it through the shared
+// FILE_CONTEXT prototype getter; ESLint 9 puts config.settings on the one
+// FileContext all rule contexts inherit from), so within a file the guard
+// always matches after the first rule computes it, and a different settings
+// object (next file, tests) recomputes instead of serving a stale entry.
+const elementTypeCache = new WeakMap<
+  EsTreeNodeOfType<"JSXOpeningElement">,
+  ElementTypeCacheEntry
+>();
+
+// Resolves a JSX opening element to the (possibly-aliased) HTML tag
+// name. Mirrors oxc_linter::utils::react::get_element_type.
+//
+// - Honors `settings["jsx-a11y"].polymorphicPropName` (defaults to
+//   none): when the element has that prop with a string-literal
+//   value, the value overrides the element's tag.
+// - Honors `settings["jsx-a11y"].components`: a mapping from
+//   component name → resolved tag (e.g. `{ Button: "button" }`).
+// - Falls back to the JSX identifier / member-expression name.
+export const getElementType = (
+  openingElement: EsTreeNodeOfType<"JSXOpeningElement">,
+  settings: Readonly<Record<string, unknown>> | undefined,
+): string => {
+  const cachedEntry = elementTypeCache.get(openingElement);
+  if (cachedEntry && cachedEntry.settings === settings) return cachedEntry.elementType;
+  const elementType = computeElementType(openingElement, readJsxA11ySettings(settings));
+  elementTypeCache.set(openingElement, { settings, elementType });
+  return elementType;
+};

From 05f639910abf2b3bfc0802e9ad568ecd2b7ce13d Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:31 -0500
Subject: [PATCH 04/33] perf(plugin): memoize functionContainsReactRenderOutput
 per function node (#1042)

Five rules query the same function nodes; the full-subtree walk now runs
once per (function node, scope analysis) and repeat queries hit a WeakMap.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-render-output-walk-cache.md   |  5 ++
 ...ction-contains-react-render-output.test.ts | 84 +++++++++++++++++++
 .../function-contains-react-render-output.ts  | 22 ++++-
 3 files changed, 110 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/perf-render-output-walk-cache.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.test.ts

diff --git a/.changeset/perf-render-output-walk-cache.md b/.changeset/perf-render-output-walk-cache.md
new file mode 100644
index 0000000000..ab0dead7ce
--- /dev/null
+++ b/.changeset/perf-render-output-walk-cache.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: memoize `functionContainsReactRenderOutput` per function node so the ~5 rules sharing it walk each function subtree once per file instead of once per query
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.test.ts
new file mode 100644
index 0000000000..e895d97769
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vite-plus/test";
+import { analyzeScopes } from "../semantic/scope-analysis.js";
+import type { ScopeAnalysis } from "../semantic/scope-analysis.js";
+import { attachParentReferences } from "./attach-parent-references.js";
+import type { EsTreeNode } from "./es-tree-node.js";
+import { functionContainsReactRenderOutput } from "./function-contains-react-render-output.js";
+import { isNodeOfType } from "./is-node-of-type.js";
+import { parseFixture } from "../../test-utils/parse-fixture.js";
+import { walkAst } from "./walk-ast.js";
+
+interface FunctionFixture {
+  functionNode: EsTreeNode;
+  scopes: ScopeAnalysis;
+  program: EsTreeNode;
+}
+
+const parseFunctionFixture = (code: string, functionName: string): FunctionFixture => {
+  const { program, errors } = parseFixture(code);
+  expect(errors).toEqual([]);
+  attachParentReferences(program);
+  let functionNode: EsTreeNode | null = null;
+  walkAst(program, (child) => {
+    if (functionNode) return false;
+    if (!isNodeOfType(child, "FunctionDeclaration")) return;
+    if (child.id?.name === functionName) functionNode = child;
+  });
+  if (!functionNode) throw new Error(`fixture has no function named ${functionName}`);
+  return { functionNode, scopes: analyzeScopes(program), program };
+};
+
+describe("functionContainsReactRenderOutput", () => {
+  it("detects JSX render output, stable across repeated calls", () => {
+    const { functionNode, scopes } = parseFunctionFixture(
+      `function Card() { return <div>hi</div>; }`,
+      "Card",
+    );
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(true);
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(true);
+  });
+
+  it("returns false for an uppercase factory without render output, stable across repeated calls", () => {
+    const { functionNode, scopes } = parseFunctionFixture(
+      `function CreateValidator(options: { strict?: boolean }) { return { isStrict: Boolean(options.strict) }; }`,
+      "CreateValidator",
+    );
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(false);
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(false);
+  });
+
+  it("memoizes per (functionNode, scopes): a repeat query with the same inputs skips the re-walk", () => {
+    const { functionNode, scopes, program } = parseFunctionFixture(
+      `function Card() { return <div>hi</div>; }`,
+      "Card",
+    );
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(true);
+    if (!isNodeOfType(functionNode, "FunctionDeclaration")) {
+      throw new Error("fixture function is not a FunctionDeclaration");
+    }
+    // Emptying the body makes the cache hit observable: a re-walk would now
+    // find no JSX and return false, so `true` proves the memoized answer.
+    functionNode.body.body = [];
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(true);
+    expect(functionContainsReactRenderOutput(functionNode, analyzeScopes(program))).toBe(false);
+  });
+
+  it("does not contaminate results across different scope analyses on the same node", () => {
+    const { functionNode, scopes } = parseFunctionFixture(
+      `import React from "react";
+       function Banner() { return React.createElement("div"); }`,
+      "Banner",
+    );
+    const scopesWithoutSymbols: ScopeAnalysis = {
+      rootScope: scopes.rootScope,
+      scopeFor: scopes.scopeFor,
+      ownScopeFor: scopes.ownScopeFor,
+      symbolFor: () => null,
+      referenceFor: () => null,
+      isGlobalReference: () => false,
+    };
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(true);
+    expect(functionContainsReactRenderOutput(functionNode, scopesWithoutSymbols)).toBe(false);
+    expect(functionContainsReactRenderOutput(functionNode, scopes)).toBe(true);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.ts
index 1e0a3fa5f6..e1082fa842 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/function-contains-react-render-output.ts
@@ -108,7 +108,27 @@ const containsRenderOutput = (
   return false;
 };
 
+interface RenderOutputCacheEntry {
+  scopes: ScopeAnalysis;
+  hasRenderOutput: boolean;
+}
+
+// The walk result is a pure function of (functionNode, scopes), and the host
+// shares one ScopeAnalysis per Program across every rule (see
+// wrap-with-semantic-context.ts), so the ~5 rules re-querying the same
+// function node collapse to one subtree walk per file. The scopes-identity
+// guard recomputes if a different analysis ever shows up for the same node
+// (the pre-capture fallback scopes, or tests building their own analysis).
+// Entries die with the AST via the WeakMap.
+const renderOutputCache = new WeakMap<EsTreeNode, RenderOutputCacheEntry>();
+
 export const functionContainsReactRenderOutput = (
   functionNode: EsTreeNode,
   scopes: ScopeAnalysis,
-): boolean => containsRenderOutput(functionNode, functionNode, scopes);
+): boolean => {
+  const cachedEntry = renderOutputCache.get(functionNode);
+  if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
+  const hasRenderOutput = containsRenderOutput(functionNode, functionNode, scopes);
+  renderOutputCache.set(functionNode, { scopes, hasRenderOutput });
+  return hasRenderOutput;
+};

From 6a9a73b14908272535aabab6742258b61bc2ee5c Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:33 -0500
Subject: [PATCH 05/33] perf(plugin): gate route-scoped rules at create()
 instead of per node (#1043)

Five rules re-classified the constant filename on every matching AST node
(isInProjectDirectory or the __root-route pattern). Compute the gate once
in create() and register no visitors when the file can never match, so
the host skips these rules entirely on non-matching files.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .../perf-tanstack-in-project-dir-hoist.md     |  5 ++
 ...-fetch-for-server-data.regressions.test.ts | 15 ++++
 .../nextjs-no-client-fetch-for-server-data.ts | 24 +++---
 .../tanstack-start-missing-head-content.ts    | 26 ++-----
 ...tart-no-anchor-element.regressions.test.ts |  9 +++
 .../tanstack-start-no-anchor-element.ts       | 76 ++++++++++---------
 .../tanstack-start-no-navigate-in-render.ts   | 17 +----
 ...rt-no-use-effect-fetch.regressions.test.ts |  9 +++
 .../tanstack-start-no-use-effect-fetch.ts     | 70 ++++++++---------
 9 files changed, 135 insertions(+), 116 deletions(-)
 create mode 100644 .changeset/perf-tanstack-in-project-dir-hoist.md

diff --git a/.changeset/perf-tanstack-in-project-dir-hoist.md b/.changeset/perf-tanstack-in-project-dir-hoist.md
new file mode 100644
index 0000000000..dd83c1ab12
--- /dev/null
+++ b/.changeset/perf-tanstack-in-project-dir-hoist.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf(rules): hoist per-file directory classification out of per-node visitors — the TanStack Start and Next.js rules that called `isInProjectDirectory` (or tested the root-route filename pattern) on every JSX element / call expression now compute it once in `create()` and skip non-matching files entirely
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.regressions.test.ts
index f0206c4e41..f13ba07ba6 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.regressions.test.ts
@@ -132,4 +132,19 @@ export default function Page() {
     expect(result.parseErrors).toEqual([]);
     expect(result.diagnostics).toEqual([]);
   });
+
+  it("stays silent outside page, layout, and pages files", () => {
+    const result = runRule(
+      nextjsNoClientFetchForServerData,
+      `"use client";
+import { useEffect } from "react";
+export function Widget() {
+  useEffect(() => { fetch("/api/data"); }, []);
+  return null;
+}`,
+      { filename: "components/widget.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.ts
index 5736d74c24..a322076129 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-client-fetch-for-server-data.ts
@@ -8,6 +8,7 @@ import { hasDirective } from "../../utils/has-directive.js";
 import { isHookCall } from "../../utils/is-hook-call.js";
 import { isInProjectDirectory } from "../../utils/is-in-project-directory.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import type { RuleVisitors } from "../../utils/rule-visitors.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 
 export const nextjsNoClientFetchForServerData = defineRule({
@@ -18,7 +19,12 @@ export const nextjsNoClientFetchForServerData = defineRule({
   severity: "warn",
   recommendation:
     "Remove 'use client' and fetch directly in the Server Component. No API round-trip, and secrets stay on the server.",
-  create: (context: RuleContext) => {
+  create: (context: RuleContext): RuleVisitors => {
+    const filename = normalizeFilename(context.filename ?? "");
+    const isPageOrLayoutFile =
+      PAGE_OR_LAYOUT_FILE_PATTERN.test(filename) || isInProjectDirectory(context, "pages");
+    if (!isPageOrLayoutFile) return {};
+
     let fileHasUseClient = false;
 
     return {
@@ -31,17 +37,11 @@ export const nextjsNoClientFetchForServerData = defineRule({
         const callback = getEffectCallback(node);
         if (!callback || !containsFetchCall(callback, { stopAtFunctionBoundary: true })) return;
 
-        const filename = normalizeFilename(context.filename ?? "");
-        const isPageOrLayoutFile =
-          PAGE_OR_LAYOUT_FILE_PATTERN.test(filename) || isInProjectDirectory(context, "pages");
-
-        if (isPageOrLayoutFile) {
-          context.report({
-            node,
-            message:
-              "useEffect + fetch in a page/layout makes your users wait through an extra round trip & loading spinner.",
-          });
-        }
+        context.report({
+          node,
+          message:
+            "useEffect + fetch in a page/layout makes your users wait through an extra round trip & loading spinner.",
+        });
       },
     };
   },
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-missing-head-content.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-missing-head-content.ts
index b77b53a2f0..c85fcf6976 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-missing-head-content.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-missing-head-content.ts
@@ -1,8 +1,8 @@
 import { TANSTACK_ROOT_ROUTE_FILE_PATTERN } from "../../constants/tanstack.js";
 import { defineRule } from "../../utils/define-rule.js";
-import { normalizeFilename } from "../../utils/normalize-filename.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import type { RuleVisitors } from "../../utils/rule-visitors.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 
@@ -72,7 +72,11 @@ export const tanstackStartMissingHeadContent = defineRule({
   severity: "warn",
   recommendation:
     "Add `<HeadContent />` inside `<head>` in your __root route. Without it, route `head()` meta tags are dropped.",
-  create: (context: RuleContext) => {
+  create: (context: RuleContext): RuleVisitors => {
+    // The pattern anchors on the separator-free `__root.<ext>` basename, so
+    // testing the raw filename equals testing the backslash-normalized one.
+    if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(context.filename ?? "")) return {};
+
     let hasHeadContentElement = false;
     let hasDocumentHeadElement = false;
     let hasCustomHeadChildElement = false;
@@ -140,10 +144,6 @@ export const tanstackStartMissingHeadContent = defineRule({
 
     return {
       Program(node: EsTreeNodeOfType<"Program">) {
-        const filename = context.filename ?? "";
-        const isRootRouteFile = TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename);
-        if (!isRootRouteFile) return;
-
         const statements = node.body ?? [];
         // Pre-scan top-level imports before JSX visits so late import
         // declarations do not make alias detection source-order dependent.
@@ -160,22 +160,12 @@ export const tanstackStartMissingHeadContent = defineRule({
         }
       },
       ImportDeclaration(node: EsTreeNodeOfType<"ImportDeclaration">) {
-        const filename = context.filename ?? "";
-        const isRootRouteFile = TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename);
-        if (!isRootRouteFile) return;
         collectImportBindings(node);
       },
       VariableDeclarator(node: EsTreeNodeOfType<"VariableDeclarator">) {
-        const filename = context.filename ?? "";
-        const isRootRouteFile = TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename);
-        if (!isRootRouteFile) return;
         collectVariableAlias(node);
       },
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-        const filename = normalizeFilename(context.filename ?? "");
-        const isRootRouteFile = TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename);
-        if (!isRootRouteFile) return;
-
         if (isNodeOfType(node.name, "JSXIdentifier")) {
           if (node.name.name === DOCUMENT_HEAD_ELEMENT_NAME) {
             hasDocumentHeadElement = true;
@@ -208,10 +198,6 @@ export const tanstackStartMissingHeadContent = defineRule({
         }
       },
       "Program:exit"(programNode: EsTreeNode) {
-        const filename = normalizeFilename(context.filename ?? "");
-        const isRootRouteFile = TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename);
-        if (!isRootRouteFile) return;
-
         if (hasDocumentHeadElement && !hasHeadContentElement && !hasCustomHeadChildElement) {
           context.report({
             node: programNode,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.regressions.test.ts
index b08e102ee8..2674537007 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.regressions.test.ts
@@ -51,4 +51,13 @@ describe("tanstack-start/tanstack-start-no-anchor-element — regressions", () =
     );
     expect(diagnostics.length).toBeGreaterThan(0);
   });
+
+  it("stays silent outside the routes directory", () => {
+    const { diagnostics } = runRule(
+      tanstackStartNoAnchorElement,
+      `const C = () => <a href="/dashboard">Go</a>;`,
+      { filename: "src/components/nav.tsx" },
+    );
+    expect(diagnostics).toHaveLength(0);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.ts
index b577f5bdd9..a75f8d1c4e 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-anchor-element.ts
@@ -2,6 +2,7 @@ import { defineRule } from "../../utils/define-rule.js";
 import { isInProjectDirectory } from "../../utils/is-in-project-directory.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import type { RuleVisitors } from "../../utils/rule-visitors.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { findJsxAttribute } from "../../utils/find-jsx-attribute.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
@@ -29,48 +30,49 @@ export const tanstackStartNoAnchorElement = defineRule({
   severity: "warn",
   recommendation:
     "Use `Link` from `@tanstack/react-router` so internal navigation keeps client state, preloading, and typed routes.",
-  create: (context: RuleContext) => ({
-    JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-      if (!isInProjectDirectory(context, "routes")) return;
+  create: (context: RuleContext): RuleVisitors => {
+    if (!isInProjectDirectory(context, "routes")) return {};
+    return {
+      JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
+        if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
 
-      if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+        const attributes = node.attributes ?? [];
+        const hrefAttribute = findJsxAttribute(attributes, "href");
+        if (!hrefAttribute?.value) return;
 
-      const attributes = node.attributes ?? [];
-      const hrefAttribute = findJsxAttribute(attributes, "href");
-      if (!hrefAttribute?.value) return;
+        let hrefValue: string | number | bigint | boolean | RegExp | null = null;
+        if (isNodeOfType(hrefAttribute.value, "Literal")) {
+          hrefValue = hrefAttribute.value.value;
+        } else if (
+          isNodeOfType(hrefAttribute.value, "JSXExpressionContainer") &&
+          isNodeOfType(hrefAttribute.value.expression, "Literal")
+        ) {
+          hrefValue = hrefAttribute.value.expression.value;
+        }
 
-      let hrefValue: string | number | bigint | boolean | RegExp | null = null;
-      if (isNodeOfType(hrefAttribute.value, "Literal")) {
-        hrefValue = hrefAttribute.value.value;
-      } else if (
-        isNodeOfType(hrefAttribute.value, "JSXExpressionContainer") &&
-        isNodeOfType(hrefAttribute.value.expression, "Literal")
-      ) {
-        hrefValue = hrefAttribute.value.expression.value;
-      }
+        if (typeof hrefValue !== "string" || !hrefValue.startsWith("/")) return;
 
-      if (typeof hrefValue !== "string" || !hrefValue.startsWith("/")) return;
+        // A protocol-relative URL (`//cdn.example.com/...`) is an EXTERNAL link
+        // that merely starts with "/".
+        if (hrefValue.startsWith("//")) return;
 
-      // A protocol-relative URL (`//cdn.example.com/...`) is an EXTERNAL link
-      // that merely starts with "/".
-      if (hrefValue.startsWith("//")) return;
+        // Non-route paths can't be a router Link: API endpoints/exports and
+        // static assets with a file extension (`/resume.pdf`, `/sitemap.xml`).
+        const pathname = hrefValue.split(/[?#]/)[0] ?? hrefValue;
+        if (pathname.startsWith("/api/")) return;
+        if (/\.[a-z0-9]{1,8}$/i.test(pathname)) return;
 
-      // Non-route paths can't be a router Link: API endpoints/exports and
-      // static assets with a file extension (`/resume.pdf`, `/sitemap.xml`).
-      const pathname = hrefValue.split(/[?#]/)[0] ?? hrefValue;
-      if (pathname.startsWith("/api/")) return;
-      if (/\.[a-z0-9]{1,8}$/i.test(pathname)) return;
+        // A `download` link or a new-tab link must stay a real <a>; a Link
+        // can't trigger a browser download or open in a new tab the same way.
+        if (findJsxAttribute(attributes, "download")) return;
+        if (getAttributeStringValue(findJsxAttribute(attributes, "target")) === "_blank") return;
 
-      // A `download` link or a new-tab link must stay a real <a>; a Link
-      // can't trigger a browser download or open in a new tab the same way.
-      if (findJsxAttribute(attributes, "download")) return;
-      if (getAttributeStringValue(findJsxAttribute(attributes, "target")) === "_blank") return;
-
-      context.report({
-        node,
-        message:
-          "Plain <a> reloads the whole page for internal navigation, so TanStack Router loses client state and preloading.",
-      });
-    },
-  }),
+        context.report({
+          node,
+          message:
+            "Plain <a> reloads the whole page for internal navigation, so TanStack Router loses client state and preloading.",
+        });
+      },
+    };
+  },
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-navigate-in-render.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-navigate-in-render.ts
index e2aa8c5547..1366c24a2f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-navigate-in-render.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-navigate-in-render.ts
@@ -14,6 +14,7 @@ import { isHookCall } from "../../utils/is-hook-call.js";
 import { isInProjectDirectory } from "../../utils/is-in-project-directory.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import type { RuleVisitors } from "../../utils/rule-visitors.js";
 import { isFunctionLike } from "../../utils/is-function-like.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
@@ -33,7 +34,9 @@ export const tanstackStartNoNavigateInRender = defineRule({
   severity: "warn",
   recommendation:
     "Use `throw redirect({ to: '/path' })` in `beforeLoad` or `loader`. navigate() during render causes hydration issues.",
-  create: (context: RuleContext) => {
+  create: (context: RuleContext): RuleVisitors => {
+    if (!isInProjectDirectory(context, "routes")) return {};
+
     // HACK: only callbacks that React calls LATER are safe scopes for
     // navigate() — useEffect / useLayoutEffect (post-commit), useCallback
     // / useMemo (cached, fired by event handlers later), JSX `onXxx`
@@ -45,7 +48,6 @@ export const tanstackStartNoNavigateInRender = defineRule({
     // they must NOT be treated as deferred — they're still render-time
     // side effects. A pure function-depth counter would skip them and
     // miss real bugs; the explicit allow-list is the correct boundary.
-    const isRouteFile = isInProjectDirectory(context, "routes");
     let deferredCallbackDepth = 0;
     let eventHandlerDepth = 0;
 
@@ -191,8 +193,6 @@ export const tanstackStartNoNavigateInRender = defineRule({
 
     return {
       CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
-        if (!isRouteFile) return;
-
         if (isDeferredHookCall(node)) deferredCallbackDepth++;
 
         if (deferredCallbackDepth > 0 || eventHandlerDepth > 0) return;
@@ -211,47 +211,38 @@ export const tanstackStartNoNavigateInRender = defineRule({
         }
       },
       "CallExpression:exit"(node: EsTreeNode) {
-        if (!isRouteFile) return;
         if (isDeferredHookCall(node)) {
           deferredCallbackDepth = Math.max(0, deferredCallbackDepth - 1);
         }
       },
       JSXAttribute(node: EsTreeNodeOfType<"JSXAttribute">) {
-        if (!isRouteFile) return;
         if (isEventHandlerAttribute(node)) eventHandlerDepth++;
       },
       "JSXAttribute:exit"(node: EsTreeNode) {
-        if (!isRouteFile) return;
         if (isEventHandlerAttribute(node)) {
           eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
         }
       },
       Property(node: EsTreeNodeOfType<"Property">) {
-        if (!isRouteFile) return;
         if (isEventHandlerProperty(node)) eventHandlerDepth++;
       },
       "Property:exit"(node: EsTreeNode) {
-        if (!isRouteFile) return;
         if (isEventHandlerProperty(node)) {
           eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
         }
       },
       VariableDeclarator(node: EsTreeNodeOfType<"VariableDeclarator">) {
-        if (!isRouteFile) return;
         if (isHandlerNamedVariableDeclarator(node)) eventHandlerDepth++;
       },
       "VariableDeclarator:exit"(node: EsTreeNode) {
-        if (!isRouteFile) return;
         if (isHandlerNamedVariableDeclarator(node)) {
           eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
         }
       },
       FunctionDeclaration(node: EsTreeNodeOfType<"FunctionDeclaration">) {
-        if (!isRouteFile) return;
         if (isHandlerNamedFunctionDeclaration(node)) eventHandlerDepth++;
       },
       "FunctionDeclaration:exit"(node: EsTreeNode) {
-        if (!isRouteFile) return;
         if (isHandlerNamedFunctionDeclaration(node)) {
           eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
         }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.regressions.test.ts
index 183cb3c10b..daf3f330c9 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.regressions.test.ts
@@ -49,4 +49,13 @@ describe("tanstack-start/tanstack-start-no-useeffect-fetch — regressions", ()
     );
     expect(diagnostics).toHaveLength(0);
   });
+
+  it("stays silent outside the routes directory", () => {
+    const { diagnostics } = runRule(
+      tanstackStartNoUseEffectFetch,
+      `function Nav() { useEffect(() => { fetch(url).then(setData); }, []); return null; }`,
+      { filename: "src/components/nav.tsx" },
+    );
+    expect(diagnostics).toHaveLength(0);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.ts
index f30defd6e9..8cc4beac2c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-no-use-effect-fetch.ts
@@ -7,6 +7,7 @@ import { isInProjectDirectory } from "../../utils/is-in-project-directory.js";
 import { walkAst } from "../../utils/walk-ast.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import type { RuleVisitors } from "../../utils/rule-visitors.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 
@@ -18,42 +19,43 @@ export const tanstackStartNoUseEffectFetch = defineRule({
   severity: "warn",
   recommendation:
     "Fetch data in the route `loader` instead. The router loads it before rendering and avoids waterfalls.",
-  create: (context: RuleContext) => ({
-    CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
-      if (!isInProjectDirectory(context, "routes")) return;
+  create: (context: RuleContext): RuleVisitors => {
+    if (!isInProjectDirectory(context, "routes")) return {};
+    return {
+      CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
+        if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
 
-      if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
+        const callback = node.arguments?.[0];
+        if (!callback) return;
 
-      const callback = node.arguments?.[0];
-      if (!callback) return;
+        let hasFetchCall = false;
+        const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
+        walkAst(callback, (child: EsTreeNode) => {
+          if (hasFetchCall) return false;
+          // Skip nested handlers (addEventListener / setInterval) — a fetch
+          // there fires on an external event, not as a render-time data fetch
+          // the route loader could replace — but keep walking into functions
+          // the effect body itself invokes (IIFEs, called local functions,
+          // promise-chain callbacks): those ARE the render-time fetch.
+          if (child !== callback && isFunctionLike(child) && !effectInvokedFunctions.has(child))
+            return false;
+          if (
+            isNodeOfType(child, "CallExpression") &&
+            isNodeOfType(child.callee, "Identifier") &&
+            child.callee.name === "fetch"
+          ) {
+            hasFetchCall = true;
+          }
+        });
 
-      let hasFetchCall = false;
-      const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
-      walkAst(callback, (child: EsTreeNode) => {
-        if (hasFetchCall) return false;
-        // Skip nested handlers (addEventListener / setInterval) — a fetch
-        // there fires on an external event, not as a render-time data fetch
-        // the route loader could replace — but keep walking into functions
-        // the effect body itself invokes (IIFEs, called local functions,
-        // promise-chain callbacks): those ARE the render-time fetch.
-        if (child !== callback && isFunctionLike(child) && !effectInvokedFunctions.has(child))
-          return false;
-        if (
-          isNodeOfType(child, "CallExpression") &&
-          isNodeOfType(child.callee, "Identifier") &&
-          child.callee.name === "fetch"
-        ) {
-          hasFetchCall = true;
+        if (hasFetchCall) {
+          context.report({
+            node,
+            message:
+              "fetch() inside useEffect makes your users wait through a loading spinner after render.",
+          });
         }
-      });
-
-      if (hasFetchCall) {
-        context.report({
-          node,
-          message:
-            "fetch() inside useEffect makes your users wait through a loading spinner after render.",
-        });
-      }
-    },
-  }),
+      },
+    };
+  },
 });

From 2980d0f4ed6abfee061ac02f3a0820806f942b95 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:36 -0500
Subject: [PATCH 06/33] perf(plugin): cache compiled glob patterns in
 compileGlob (#1044)

Rules matching user-configured globs per node recompiled the same RegExp
on every call; patterns only ever come from config, so a module-level
Map is bounded and flagless RegExps are safe to share.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-compile-glob-cache.md         |  5 ++
 .../src/plugin/utils/compile-glob.test.ts     | 54 +++++++++++++++++++
 .../src/plugin/utils/compile-glob.ts          | 12 ++++-
 3 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/perf-compile-glob-cache.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.test.ts

diff --git a/.changeset/perf-compile-glob-cache.md b/.changeset/perf-compile-glob-cache.md
new file mode 100644
index 0000000000..c4c412024b
--- /dev/null
+++ b/.changeset/perf-compile-glob-cache.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: cache compiled glob RegExps in `compileGlob` so rules matching user-configured patterns per node stop recompiling the same pattern on every call
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.test.ts
new file mode 100644
index 0000000000..74df99f505
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vite-plus/test";
+import { compileGlob } from "./compile-glob.js";
+
+describe("compileGlob", () => {
+  it("anchors exact patterns", () => {
+    const regex = compileGlob("onClick");
+    expect(regex.test("onClick")).toBe(true);
+    expect(regex.test("onClickCapture")).toBe(false);
+    expect(regex.test("myOnClick")).toBe(false);
+  });
+
+  it("expands * into a wildcard at any position", () => {
+    expect(compileGlob("on*").test("onChange")).toBe(true);
+    expect(compileGlob("on*").test("change")).toBe(false);
+    expect(compileGlob("*Handler").test("clickHandler")).toBe(true);
+    expect(compileGlob("*Handler").test("handlerClick")).toBe(false);
+    expect(compileGlob("Foo*Bar").test("FooMiddleBar")).toBe(true);
+  });
+
+  it("escapes regex metacharacters in the pattern", () => {
+    expect(compileGlob("a.b").test("a.b")).toBe(true);
+    expect(compileGlob("a.b").test("axb")).toBe(false);
+    expect(compileGlob("a+b").test("a+b")).toBe(true);
+    expect(compileGlob("a+b").test("aab")).toBe(false);
+  });
+
+  it("returns the same cached instance with consistent matching across repeat calls", () => {
+    const firstCall = compileGlob("render*");
+    const secondCall = compileGlob("render*");
+    expect(secondCall).toBe(firstCall);
+    expect(firstCall.test("renderItem")).toBe(true);
+    expect(secondCall.test("renderItem")).toBe(true);
+    expect(secondCall.test("item")).toBe(false);
+    expect(compileGlob("render*").test("renderRow")).toBe(true);
+  });
+
+  it("does not cross-contaminate different patterns", () => {
+    const onPrefix = compileGlob("on*");
+    const handlerSuffix = compileGlob("*Handler");
+    expect(onPrefix).not.toBe(handlerSuffix);
+    expect(onPrefix.test("onClick")).toBe(true);
+    expect(onPrefix.test("clickHandler")).toBe(false);
+    expect(handlerSuffix.test("clickHandler")).toBe(true);
+    expect(handlerSuffix.test("onClick")).toBe(false);
+  });
+
+  it("compiles without stateful flags so cached instances are shareable", () => {
+    const regex = compileGlob("on*Capture");
+    expect(regex.flags).toBe("");
+    expect(regex.test("onClickCapture")).toBe(true);
+    expect(regex.test("onClickCapture")).toBe(true);
+    expect(regex.lastIndex).toBe(0);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.ts
index cbe0762e09..e2de4a67aa 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/compile-glob.ts
@@ -12,7 +12,17 @@
  * `*Handler`), so the cheap escape-then-replace shape is enough
  * and avoids pulling picomatch into the per-file rule path.
  */
+// Unbounded by design: every call site passes user-config strings
+// (settings/forbid entries), never file-derived data, so the distinct
+// pattern set is tiny and fixed per scan. Flagless RegExps carry no
+// lastIndex state, so sharing one instance across callers is safe.
+const compiledGlobs = new Map<string, RegExp>();
+
 export const compileGlob = (pattern: string): RegExp => {
+  const cached = compiledGlobs.get(pattern);
+  if (cached) return cached;
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
-  return new RegExp(`^${escaped}$`);
+  const compiled = new RegExp(`^${escaped}$`);
+  compiledGlobs.set(pattern, compiled);
+  return compiled;
 };

From fc75a3e361251885c7325324f2ab6812255b0c18 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 17:59:38 -0500
Subject: [PATCH 07/33] perf(core): balance lint batches by file size (LPT) to
 kill straggler batches (#1045)

Greedy 100-file chunking in discovery order let adjacent large files pile
into one batch that set the whole scan's wall clock (2.2x on a size-skewed
corpus) and could trip the per-batch timeout. The planner keeps the same
batch count but assigns files largest-first to the least-loaded batch;
REACT_DOCTOR_LINT_BATCH_ORDERING=arrival rolls back to greedy chunking.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/balanced-lpt-lint-batches.md       |   5 +
 packages/core/src/batch-include-paths.ts      |   4 +-
 packages/core/src/refs.ts                     |  24 ++--
 packages/core/src/run-oxlint.ts               |  49 ++++---
 .../core/src/utils/estimate-args-length.ts    |   5 +
 packages/core/src/utils/plan-lint-batches.ts  | 107 +++++++++++++++
 .../src/utils/resolve-lint-batch-ordering.ts  |  24 ++--
 .../src/utils/sort-source-files-by-cost.ts    |  13 --
 packages/core/tests/plan-lint-batches.test.ts | 127 ++++++++++++++++++
 .../tests/resolve-lint-batch-ordering.test.ts |  24 ++--
 .../tests/sort-source-files-by-cost.test.ts   |  37 -----
 .../tests/build-run-context.test.ts           |   8 +-
 .../tests/scan-result-cache.test.ts           |   4 +-
 13 files changed, 314 insertions(+), 117 deletions(-)
 create mode 100644 .changeset/balanced-lpt-lint-batches.md
 create mode 100644 packages/core/src/utils/estimate-args-length.ts
 create mode 100644 packages/core/src/utils/plan-lint-batches.ts
 delete mode 100644 packages/core/src/utils/sort-source-files-by-cost.ts
 create mode 100644 packages/core/tests/plan-lint-batches.test.ts
 delete mode 100644 packages/core/tests/sort-source-files-by-cost.test.ts

diff --git a/.changeset/balanced-lpt-lint-batches.md b/.changeset/balanced-lpt-lint-batches.md
new file mode 100644
index 0000000000..00bbe399fe
--- /dev/null
+++ b/.changeset/balanced-lpt-lint-batches.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": patch
+---
+
+Balance lint batches by file size (LPT) so one oversized batch no longer sets the whole scan's wall clock. The full-scan batcher greedily filled 100-file chunks in discovery order, so a directory of large files (generated modules, vendored bundles, big test fixtures — adjacent in `git ls-files` order) all landed in ONE batch: on a 619-file corpus with six ~240 KB files that straggler batch ran ~7.5 s while the other six workers finished in ~1 s and idled — and a big enough cluster can trip the 60 s per-batch timeout and drop files. The planner now keeps the same batch count (and therefore the same subprocess count and CPU) but assigns files largest-first to the least-loaded batch, so every batch carries an even share of files and bytes: 2.2× faster wall clock on the skewed corpus (9.7 s → 4.3 s), no measurable change on uniform repos, and diagnostics verified byte-identical on both. Splitting into MORE batches to feed idle workers was measured to regress (each extra concurrent subprocess pays a contended cold start that outweighs its smaller file share) and is deliberately not done. `REACT_DOCTOR_LINT_BATCH_ORDERING=arrival` rolls back to the old greedy chunking; the previous opt-in `cost` mode (sort-descending-then-chunk, which concentrated the heavy files instead of spreading them) is superseded by the balanced plan.
diff --git a/packages/core/src/batch-include-paths.ts b/packages/core/src/batch-include-paths.ts
index bc0f905d50..a583a33454 100644
--- a/packages/core/src/batch-include-paths.ts
+++ b/packages/core/src/batch-include-paths.ts
@@ -1,7 +1,5 @@
 import { OXLINT_MAX_FILES_PER_BATCH, SPAWN_ARGS_MAX_LENGTH_CHARS } from "./constants.js";
-
-const estimateArgsLength = (args: string[]): number =>
-  args.reduce((total, argument) => total + argument.length + 1, 0);
+import { estimateArgsLength } from "./utils/estimate-args-length.js";
 
 // Splits a (possibly huge) include-path list into batches that each
 // fit under BOTH the spawn-args byte budget (Windows CreateProcessW caps
diff --git a/packages/core/src/refs.ts b/packages/core/src/refs.ts
index c6b7ded61a..9c535c88b0 100644
--- a/packages/core/src/refs.ts
+++ b/packages/core/src/refs.ts
@@ -158,17 +158,19 @@ export class DeadCodeOverlap extends Context.Reference<"auto" | "on" | "off">(
 ) {}
 
 /**
- * How the full-scan lint pass orders its file batches. `"arrival"` (the
- * default) keeps `git ls-files` discovery order. `"cost"` opts into LPT (feed
- * the largest files first); set `REACT_DOCTOR_LINT_BATCH_ORDERING=cost`. NOTE:
- * `cost` is OFF by default because the current sort-desc-then-chunk-100 packs
- * the heaviest files into one wave-1 batch — on size-skewed repos that mega-
- * batch is a straggler (and can trip the per-batch timeout + split), measurably
- * regressing the common full-scan case. LPT needs the heavy files SPREAD across
- * batches before `cost` earns the default. Tests override via
- * `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans never reach this
- * — they pass user-scoped `includePaths` that skip discovery and stay in
- * arrival order; only the full-scan branch reads it.
+ * How the full-scan lint pass plans its file batches. `"cost"` (the default)
+ * builds size-balanced LPT batches (`planLintBatches`): the same mandatory
+ * batch count as greedy chunking (`ceil(files / 100)`), but every batch gets
+ * an even share of files AND bytes, so no 100-file chunk is a straggler while
+ * the remainder-batch worker idles — and the heavy files are SPREAD across
+ * batches, the precondition the old sort-desc-then-chunk-100 `cost` mode
+ * lacked (it packed the heaviest files into one wave-1 straggler batch,
+ * measurably regressing size-skewed repos, which is why it never earned the
+ * default). `"arrival"` (`REACT_DOCTOR_LINT_BATCH_ORDERING=arrival`) is the
+ * rollback hatch to plain greedy 100-file chunking in discovery order. Tests
+ * override via `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans
+ * never reach this — they pass user-scoped `includePaths` that skip discovery
+ * and stay in arrival order; only the full-scan branch reads it.
  */
 export class LintBatchOrdering extends Context.Reference<"cost" | "arrival">(
   "react-doctor/LintBatchOrdering",
diff --git a/packages/core/src/run-oxlint.ts b/packages/core/src/run-oxlint.ts
index 35805e04c8..c3e8616192 100644
--- a/packages/core/src/run-oxlint.ts
+++ b/packages/core/src/run-oxlint.ts
@@ -24,9 +24,9 @@ import { spawnLintBatches } from "./runners/oxlint/spawn-batches.js";
 import { validateRuleRegistration } from "./runners/oxlint/validate-rule-registration.js";
 import { dedupeDiagnostics } from "./utils/dedupe-diagnostics.js";
 import { hashFileContents } from "./utils/hash-file-contents.js";
-import { listSourceFiles, listSourceFilesWithSize } from "./utils/list-source-files.js";
+import { listSourceFilesWithSize } from "./utils/list-source-files.js";
+import { planLintBatches } from "./utils/plan-lint-batches.js";
 import { resolveReactDoctorCacheDir } from "./utils/resolve-react-doctor-cache-dir.js";
-import { sortSourceFilesByCost } from "./utils/sort-source-files-by-cost.js";
 
 interface RunOxlintOptions {
   rootDirectory: string;
@@ -105,9 +105,10 @@ interface RunOxlintOptions {
   /** See `SpawnLintBatchesInput.deadlineEpochMs`. */
   deadlineEpochMs?: number;
   /**
-   * Full-scan batch ordering, resolved from the `LintBatchOrdering`
-   * Reference. `"arrival"` (the default) keeps discovery order; `"cost"`
-   * opts into LPT (largest files first). Only affects the full-scan branch
+   * Full-scan batch planning, resolved from the `LintBatchOrdering`
+   * Reference. `"cost"` (the default) plans size-balanced LPT batches via
+   * `planLintBatches`; `"arrival"` is the rollback hatch to the plain greedy
+   * 100-file chunking in discovery order. Only affects the full-scan branch
    * (`includePaths` undefined) — diff / staged scans pass explicit paths and
    * are untouched.
    */
@@ -206,7 +207,7 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
     onCacheStats,
     spawnTimeoutMs,
     outputMaxBytes,
-    lintBatchOrdering = "arrival",
+    lintBatchOrdering = "cost",
   } = options;
 
   const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames)
@@ -330,21 +331,27 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
     // that JS-plugin rules hit the 5-min `OXLINT_SPAWN_TIMEOUT_MS`
     // in a single batch, leaving `skippedChecks: ["lint"]` and zero
     // diagnostics. Materializing the file list ahead of time and
-    // feeding it through `batchIncludePaths` keeps each spawn under
+    // feeding it through the batch planner keeps each spawn under
     // the timeout and recovers the diagnostics we were dropping.
-    //
-    // `"cost"` orders discovered files largest-first (LPT) so the
-    // heaviest batch starts in wave 1 of the parallel pool instead of
-    // stranding in the tail — the size is the minified gate's existing
-    // stat, captured rather than re-paid. `"arrival"` (the default) keeps
-    // discovery order; `cost` is the env opt-in (`LintBatchOrdering`). Only
-    // invoked for a full scan, so diff / staged scans never pay the walk.
-    const discoverScanFiles = (): string[] =>
-      lintBatchOrdering === "cost"
-        ? sortSourceFilesByCost(listSourceFilesWithSize(rootDirectory))
-        : listSourceFiles(rootDirectory);
+    // Only a full scan pays the walk — diff / staged scans pass
+    // explicit paths.
+    const sizedScanFiles =
+      includePaths === undefined ? listSourceFilesWithSize(rootDirectory) : null;
+    const candidateFiles =
+      includePaths !== undefined ? includePaths : (sizedScanFiles ?? []).map((entry) => entry.path);
 
-    const candidateFiles = includePaths !== undefined ? includePaths : discoverScanFiles();
+    // `"cost"` (the default) plans size-balanced LPT batches — the size is
+    // the discovery walk's existing stat, captured rather than re-paid.
+    // `"arrival"` (the `REACT_DOCTOR_LINT_BATCH_ORDERING` rollback hatch) and
+    // every explicit-`includePaths` scan keep the plain greedy chunking.
+    const sizeByFile =
+      sizedScanFiles !== null && lintBatchOrdering === "cost"
+        ? new Map(sizedScanFiles.map((entry) => [entry.path, entry.sizeBytes]))
+        : null;
+    const buildFileBatches = (passBaseArgs: string[], passFiles: string[]): string[][] =>
+      sizeByFile !== null
+        ? planLintBatches({ baseArgs: passBaseArgs, files: passFiles, sizeByFile })
+        : batchIncludePaths(passBaseArgs, passFiles);
 
     // Runs one oxlintrc over a file list, retrying once with the optional
     // react-hooks-js plugin stripped if it fails to import (issue #833).
@@ -375,7 +382,7 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       };
       const passConfigPath = path.join(configDirectory, configFileName);
       const passBaseArgs = makeBaseArgs(passConfigPath);
-      const passFileBatches = batchIncludePaths(passBaseArgs, files);
+      const passFileBatches = buildFileBatches(passBaseArgs, files);
       const spawnPass = () =>
         spawnLintBatches({
           baseArgs: passBaseArgs,
@@ -545,7 +552,7 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
     }
 
     const baseArgs = makeBaseArgs(configPath);
-    const fileBatches = batchIncludePaths(baseArgs, candidateFiles);
+    const fileBatches = buildFileBatches(baseArgs, candidateFiles);
 
     const runBatches = () =>
       spawnLintBatches({
diff --git a/packages/core/src/utils/estimate-args-length.ts b/packages/core/src/utils/estimate-args-length.ts
new file mode 100644
index 0000000000..06dabab412
--- /dev/null
+++ b/packages/core/src/utils/estimate-args-length.ts
@@ -0,0 +1,5 @@
+// Estimated total command-line length of an argv (each argument plus one
+// separator char), compared against `SPAWN_ARGS_MAX_LENGTH_CHARS` by both
+// lint batchers so a batch never exceeds the spawn-args budget.
+export const estimateArgsLength = (args: ReadonlyArray<string>): number =>
+  args.reduce((total, argument) => total + argument.length + 1, 0);
diff --git a/packages/core/src/utils/plan-lint-batches.ts b/packages/core/src/utils/plan-lint-batches.ts
new file mode 100644
index 0000000000..274387519e
--- /dev/null
+++ b/packages/core/src/utils/plan-lint-batches.ts
@@ -0,0 +1,107 @@
+import { OXLINT_MAX_FILES_PER_BATCH, SPAWN_ARGS_MAX_LENGTH_CHARS } from "../constants.js";
+import { estimateArgsLength } from "./estimate-args-length.js";
+
+export interface PlanLintBatchesInput {
+  readonly baseArgs: ReadonlyArray<string>;
+  readonly files: ReadonlyArray<string>;
+  /**
+   * Byte size per file (the discovery walk's existing stat). Drives the LPT
+   * assignment; a file missing from the map weighs zero, matching
+   * `listSourceFilesWithSize`'s stat-failure fallback.
+   */
+  readonly sizeByFile: ReadonlyMap<string, number>;
+}
+
+interface MutableLintBatch {
+  fileIndexes: number[];
+  totalSizeBytes: number;
+  argsLengthChars: number;
+}
+
+/**
+ * Balanced LPT (longest-processing-time-first) lint batch planner. Where
+ * `batchIncludePaths` greedily fills 100-file batches and leaves a small
+ * remainder batch (617 files → 6×100 + 17, so the parallel pool's wall clock
+ * is set by whichever 100-file chunk happened to collect the most work while
+ * the remainder's worker idles), this planner keeps the SAME mandatory batch
+ * count — `ceil(files / OXLINT_MAX_FILES_PER_BATCH)`, the JS-plugin
+ * perf-cliff / native-binding SIGABRT guard — and assigns files largest-first,
+ * each to the least-loaded batch by cumulative byte size. Every batch ends up
+ * with an even share of files AND bytes, so no batch is a straggler; heavy
+ * files are SPREAD across batches (the documented precondition for `cost`
+ * ordering to beat `arrival`) instead of concentrated in one.
+ *
+ * Deliberately NOT worker-count-aware: splitting into extra batches to feed
+ * idle workers was measured (619-file corpus, 10 cores) to REGRESS the lint
+ * wall — each additional concurrent subprocess pays a contended cold start
+ * (node boot + plugin import + native dlopen, ~180 ms uncontended and 2-3×
+ * that in a full wave) that outweighs the smaller per-batch file share.
+ *
+ * Every batch also respects the spawn-args char budget; a file that fits no
+ * existing batch opens a new one, mirroring `batchIncludePaths`. Within a
+ * batch, files return in arrival order, and the assignment is fully
+ * deterministic (ties broken by lowest batch index), so a plan is
+ * reproducible for a fixed (files, sizes) input. Batch composition cannot
+ * change diagnostics — rules that look beyond one file (`CROSS_FILE_RULE_IDS`)
+ * read the OTHER files via the filesystem, never via batch-mates — so the
+ * plan only moves wall-clock time.
+ *
+ * O(files × batches); the linear least-loaded scan is fine at real-world
+ * scale (a 3,500-file monorepo is 36 batches ≈ 126k comparisons).
+ */
+export const planLintBatches = ({
+  baseArgs,
+  files,
+  sizeByFile,
+}: PlanLintBatchesInput): string[][] => {
+  if (files.length === 0) return [];
+  const batchCount = Math.ceil(files.length / OXLINT_MAX_FILES_PER_BATCH);
+  const maxFilesPerBatch = Math.ceil(files.length / batchCount);
+  const baseArgsLengthChars = estimateArgsLength(baseArgs);
+
+  const descendingSizeIndexes = [...files.keys()].sort(
+    (leftIndex, rightIndex) =>
+      (sizeByFile.get(files[rightIndex]) ?? 0) - (sizeByFile.get(files[leftIndex]) ?? 0),
+  );
+
+  const batches: MutableLintBatch[] = Array.from({ length: batchCount }, () => ({
+    fileIndexes: [],
+    totalSizeBytes: 0,
+    argsLengthChars: baseArgsLengthChars,
+  }));
+
+  for (const fileIndex of descendingSizeIndexes) {
+    const entryLengthChars = files[fileIndex].length + 1;
+    let targetBatch: MutableLintBatch | null = null;
+    for (const batch of batches) {
+      if (batch.fileIndexes.length >= maxFilesPerBatch) continue;
+      if (
+        batch.fileIndexes.length > 0 &&
+        batch.argsLengthChars + entryLengthChars > SPAWN_ARGS_MAX_LENGTH_CHARS
+      ) {
+        continue;
+      }
+      const isLighterBatch =
+        targetBatch === null ||
+        batch.totalSizeBytes < targetBatch.totalSizeBytes ||
+        (batch.totalSizeBytes === targetBatch.totalSizeBytes &&
+          batch.fileIndexes.length < targetBatch.fileIndexes.length);
+      if (isLighterBatch) targetBatch = batch;
+    }
+    if (targetBatch === null) {
+      targetBatch = { fileIndexes: [], totalSizeBytes: 0, argsLengthChars: baseArgsLengthChars };
+      batches.push(targetBatch);
+    }
+    targetBatch.fileIndexes.push(fileIndex);
+    targetBatch.totalSizeBytes += sizeByFile.get(files[fileIndex]) ?? 0;
+    targetBatch.argsLengthChars += entryLengthChars;
+  }
+
+  return batches
+    .filter((batch) => batch.fileIndexes.length > 0)
+    .map((batch) =>
+      batch.fileIndexes
+        .sort((leftIndex, rightIndex) => leftIndex - rightIndex)
+        .map((fileIndex) => files[fileIndex]),
+    );
+};
diff --git a/packages/core/src/utils/resolve-lint-batch-ordering.ts b/packages/core/src/utils/resolve-lint-batch-ordering.ts
index 4c718077ce..b0bce6d69e 100644
--- a/packages/core/src/utils/resolve-lint-batch-ordering.ts
+++ b/packages/core/src/utils/resolve-lint-batch-ordering.ts
@@ -1,17 +1,13 @@
-// How the full-scan lint pass orders its file batches. `"arrival"` (the
-// default) keeps `git ls-files` discovery order; `"cost"` opts into LPT
-// (largest files first). NOTE: `cost` defaults OFF because the current
-// sort-desc-then-chunk-100 builds a single wave-1 batch out of the heaviest
-// files — on size-skewed repos (e.g. a few large `*.test` files among many
-// tiny modules) that mega-batch becomes a straggler (and can trip the
-// per-batch timeout + binary-split), measurably REGRESSING the common
-// full-scan case rather than helping it. LPT needs the heavy files SPREAD
-// across batches (interleave/deal), not concentrated, before `cost` should be
-// the default. Until then `cost` is an env opt-in for repos it demonstrably
-// helps. The env var is read in one place so the `LintBatchOrdering` Reference
-// (runtime behavior) and the CLI's `lintBatchOrdering` telemetry tag (cohort
-// label) can never disagree.
+// How the full-scan lint pass plans its file batches. `"cost"` (the default)
+// builds worker-count-aware, size-balanced LPT batches via `planLintBatches`
+// — the heavy files are SPREAD across batches (the precondition that kept the
+// old sort-desc-then-chunk-100 `cost` mode from earning the default; that
+// mode packed the heaviest files into one wave-1 straggler batch). Set
+// `REACT_DOCTOR_LINT_BATCH_ORDERING=arrival` to roll back to plain greedy
+// 100-file chunking in discovery order. The env var is read in one place so
+// the `LintBatchOrdering` Reference (runtime behavior) and the CLI's
+// `lintBatchOrdering` telemetry tag (cohort label) can never disagree.
 export const resolveLintBatchOrdering = (): "cost" | "arrival" => {
   const raw = process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase();
-  return raw === "cost" ? "cost" : "arrival";
+  return raw === "arrival" ? "arrival" : "cost";
 };
diff --git a/packages/core/src/utils/sort-source-files-by-cost.ts b/packages/core/src/utils/sort-source-files-by-cost.ts
deleted file mode 100644
index 70c252392e..0000000000
--- a/packages/core/src/utils/sort-source-files-by-cost.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import type { SourceFileEntry } from "../types/index.js";
-
-// LPT (longest-processing-time-first) batch ordering: feed the largest files
-// first so the greedy work-stealing pool in `mapWithConcurrency` starts the
-// heaviest batch in wave 1 instead of stranding it after the cheap batches
-// drain. File size is a WEAK AST-cost proxy (persisted per-batch durations are
-// the v2 signal); it is free here because the size was already stat'd by the
-// minified gate. Stable on ties (V8 `Array.prototype.sort` is stable) so
-// equal-size files keep their `git ls-files` order — and the deterministic
-// diagnostic sort downstream means batch order no longer affects any output
-// regardless.
-export const sortSourceFilesByCost = (entries: ReadonlyArray<SourceFileEntry>): string[] =>
-  [...entries].sort((left, right) => right.sizeBytes - left.sizeBytes).map((entry) => entry.path);
diff --git a/packages/core/tests/plan-lint-batches.test.ts b/packages/core/tests/plan-lint-batches.test.ts
new file mode 100644
index 0000000000..f644693e24
--- /dev/null
+++ b/packages/core/tests/plan-lint-batches.test.ts
@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vite-plus/test";
+import { OXLINT_MAX_FILES_PER_BATCH, SPAWN_ARGS_MAX_LENGTH_CHARS } from "../src/constants.js";
+import { planLintBatches } from "../src/utils/plan-lint-batches.js";
+
+const BASE_ARGS = ["/usr/bin/node", "oxlint", "-c", "oxlintrc.json", "--format", "json"];
+
+const makeFiles = (count: number): string[] =>
+  Array.from({ length: count }, (_, index) => `src/file-${String(index).padStart(4, "0")}.ts`);
+
+const uniformSizes = (files: ReadonlyArray<string>, sizeBytes: number): Map<string, number> =>
+  new Map(files.map((file) => [file, sizeBytes]));
+
+describe("planLintBatches", () => {
+  it("returns no batches for an empty file list", () => {
+    expect(planLintBatches({ baseArgs: BASE_ARGS, files: [], sizeByFile: new Map() })).toEqual([]);
+  });
+
+  it("keeps a scan under the batch cap in a single batch", () => {
+    const files = makeFiles(OXLINT_MAX_FILES_PER_BATCH);
+    const batches = planLintBatches({
+      baseArgs: BASE_ARGS,
+      files,
+      sizeByFile: uniformSizes(files, 1_000),
+    });
+    expect(batches).toHaveLength(1);
+    expect(batches[0]).toEqual(files);
+  });
+
+  it("balances file counts across the mandatory batch count instead of 100-file chunks plus a remainder", () => {
+    const files = makeFiles(617);
+    const batches = planLintBatches({
+      baseArgs: BASE_ARGS,
+      files,
+      sizeByFile: uniformSizes(files, 1_000),
+    });
+    expect(batches).toHaveLength(Math.ceil(files.length / OXLINT_MAX_FILES_PER_BATCH));
+    const batchLengths = batches.map((batch) => batch.length);
+    expect(Math.max(...batchLengths)).toBeLessThanOrEqual(89);
+    expect(Math.min(...batchLengths)).toBeGreaterThanOrEqual(87);
+  });
+
+  it("never exceeds the per-batch file-count cliff cap", () => {
+    const files = makeFiles(1_234);
+    const batches = planLintBatches({
+      baseArgs: BASE_ARGS,
+      files,
+      sizeByFile: uniformSizes(files, 1_000),
+    });
+    for (const batch of batches) {
+      expect(batch.length).toBeLessThanOrEqual(OXLINT_MAX_FILES_PER_BATCH);
+    }
+    expect(batches.flat()).toHaveLength(files.length);
+  });
+
+  it("spreads the heavy files across batches (LPT) instead of concentrating them", () => {
+    const files = makeFiles(400);
+    const sizeByFile = new Map(
+      files.map((file, index) => [file, index < 4 ? 1_000_000 : 1_000] as const),
+    );
+    const batches = planLintBatches({ baseArgs: BASE_ARGS, files, sizeByFile });
+    expect(batches).toHaveLength(4);
+    for (const batch of batches) {
+      const heavyCount = batch.filter((file) => (sizeByFile.get(file) ?? 0) === 1_000_000).length;
+      expect(heavyCount).toBe(1);
+    }
+  });
+
+  it("balances cumulative byte cost, not just file counts", () => {
+    const files = makeFiles(200);
+    const sizeByFile = new Map(
+      files.map((file, index) => [file, index % 2 === 0 ? 50_000 : 100] as const),
+    );
+    const batches = planLintBatches({ baseArgs: BASE_ARGS, files, sizeByFile });
+    expect(batches).toHaveLength(2);
+    const batchByteTotals = batches.map((batch) =>
+      batch.reduce((total, file) => total + (sizeByFile.get(file) ?? 0), 0),
+    );
+    const [firstTotal, secondTotal] = batchByteTotals;
+    expect(Math.abs(firstTotal - secondTotal)).toBeLessThanOrEqual(50_000);
+  });
+
+  it("preserves every input path exactly once, in arrival order within each batch", () => {
+    const files = makeFiles(250);
+    const sizeByFile = new Map(files.map((file, index) => [file, (index * 37) % 5_000] as const));
+    const batches = planLintBatches({ baseArgs: BASE_ARGS, files, sizeByFile });
+    const flattened = batches.flat();
+    expect(flattened).toHaveLength(files.length);
+    expect(new Set(flattened).size).toBe(files.length);
+    const indexOfFile = new Map(files.map((file, index) => [file, index] as const));
+    for (const batch of batches) {
+      const indexes = batch.map((file) => indexOfFile.get(file) ?? -1);
+      expect([...indexes].sort((left, right) => left - right)).toEqual(indexes);
+    }
+  });
+
+  it("is deterministic for a fixed input", () => {
+    const files = makeFiles(300);
+    const sizeByFile = new Map(files.map((file, index) => [file, (index * 101) % 9_000] as const));
+    const first = planLintBatches({ baseArgs: BASE_ARGS, files, sizeByFile });
+    const second = planLintBatches({ baseArgs: BASE_ARGS, files, sizeByFile });
+    expect(second).toEqual(first);
+  });
+
+  it("spills to extra batches rather than exceed the spawn-args char budget", () => {
+    const longSegment = "a".repeat(400);
+    const files = Array.from({ length: 200 }, (_, index) => `src/${longSegment}/file-${index}.ts`);
+    const batches = planLintBatches({
+      baseArgs: BASE_ARGS,
+      files,
+      sizeByFile: uniformSizes(files, 1_000),
+    });
+    expect(batches.length).toBeGreaterThan(2);
+    const baseArgsLength = BASE_ARGS.reduce((total, argument) => total + argument.length + 1, 0);
+    for (const batch of batches) {
+      const batchLength = batch.reduce((total, file) => total + file.length + 1, baseArgsLength);
+      expect(batchLength).toBeLessThanOrEqual(SPAWN_ARGS_MAX_LENGTH_CHARS);
+    }
+    expect(batches.flat()).toHaveLength(files.length);
+  });
+
+  it("treats files missing from the size map as zero-cost instead of throwing", () => {
+    const files = makeFiles(160);
+    const batches = planLintBatches({ baseArgs: BASE_ARGS, files, sizeByFile: new Map() });
+    expect(batches).toHaveLength(2);
+    expect(batches.flat().sort()).toEqual([...files].sort());
+  });
+});
diff --git a/packages/core/tests/resolve-lint-batch-ordering.test.ts b/packages/core/tests/resolve-lint-batch-ordering.test.ts
index 7122eab912..d578d20f89 100644
--- a/packages/core/tests/resolve-lint-batch-ordering.test.ts
+++ b/packages/core/tests/resolve-lint-batch-ordering.test.ts
@@ -19,8 +19,8 @@ describe("resolveLintBatchOrdering", () => {
     }
   });
 
-  it("defaults to 'arrival' when the env var is unset", () => {
-    expect(resolveLintBatchOrdering()).toBe("arrival");
+  it("defaults to 'cost' when the env var is unset", () => {
+    expect(resolveLintBatchOrdering()).toBe("cost");
   });
 
   it("returns 'cost' for an exact lowercase match", () => {
@@ -28,14 +28,14 @@ describe("resolveLintBatchOrdering", () => {
     expect(resolveLintBatchOrdering()).toBe("cost");
   });
 
-  it("returns 'cost' for an uppercase value (case-insensitive)", () => {
-    process.env[ORDERING_ENV_VAR] = "COST";
-    expect(resolveLintBatchOrdering()).toBe("cost");
+  it("returns 'arrival' for an uppercase value (case-insensitive)", () => {
+    process.env[ORDERING_ENV_VAR] = "ARRIVAL";
+    expect(resolveLintBatchOrdering()).toBe("arrival");
   });
 
-  it("returns 'cost' for a value with surrounding whitespace and mixed case", () => {
-    process.env[ORDERING_ENV_VAR] = "  Cost  ";
-    expect(resolveLintBatchOrdering()).toBe("cost");
+  it("returns 'arrival' for a value with surrounding whitespace and mixed case", () => {
+    process.env[ORDERING_ENV_VAR] = "  Arrival  ";
+    expect(resolveLintBatchOrdering()).toBe("arrival");
   });
 
   it("returns 'arrival' for the explicit 'arrival' value", () => {
@@ -43,13 +43,13 @@ describe("resolveLintBatchOrdering", () => {
     expect(resolveLintBatchOrdering()).toBe("arrival");
   });
 
-  it("returns 'arrival' for an unrecognized value", () => {
+  it("returns 'cost' for an unrecognized value", () => {
     process.env[ORDERING_ENV_VAR] = "nonsense";
-    expect(resolveLintBatchOrdering()).toBe("arrival");
+    expect(resolveLintBatchOrdering()).toBe("cost");
   });
 
-  it("returns 'arrival' for an empty string", () => {
+  it("returns 'cost' for an empty string", () => {
     process.env[ORDERING_ENV_VAR] = "";
-    expect(resolveLintBatchOrdering()).toBe("arrival");
+    expect(resolveLintBatchOrdering()).toBe("cost");
   });
 });
diff --git a/packages/core/tests/sort-source-files-by-cost.test.ts b/packages/core/tests/sort-source-files-by-cost.test.ts
deleted file mode 100644
index 7200621e3c..0000000000
--- a/packages/core/tests/sort-source-files-by-cost.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vite-plus/test";
-import { sortSourceFilesByCost } from "../src/utils/sort-source-files-by-cost.js";
-import type { SourceFileEntry } from "@react-doctor/core";
-
-describe("sortSourceFilesByCost", () => {
-  it("orders entries descending by sizeBytes", () => {
-    const entries: ReadonlyArray<SourceFileEntry> = [
-      { path: "a", sizeBytes: 10 },
-      { path: "b", sizeBytes: 100 },
-      { path: "c", sizeBytes: 50 },
-    ];
-    expect(sortSourceFilesByCost(entries)).toEqual(["b", "c", "a"]);
-  });
-
-  it("preserves input order for entries of equal size (stable sort)", () => {
-    const entries: ReadonlyArray<SourceFileEntry> = [
-      { path: "a", sizeBytes: 10 },
-      { path: "b", sizeBytes: 10 },
-    ];
-    expect(sortSourceFilesByCost(entries)).toEqual(["a", "b"]);
-  });
-
-  it("returns an empty array for an empty input", () => {
-    expect(sortSourceFilesByCost([])).toEqual([]);
-  });
-
-  it("does not mutate the input array", () => {
-    const entries: ReadonlyArray<SourceFileEntry> = [
-      { path: "a", sizeBytes: 10 },
-      { path: "b", sizeBytes: 100 },
-      { path: "c", sizeBytes: 50 },
-    ];
-    const inputSnapshot = [...entries];
-    sortSourceFilesByCost(entries);
-    expect(entries).toEqual(inputSnapshot);
-  });
-});
diff --git a/packages/react-doctor/tests/build-run-context.test.ts b/packages/react-doctor/tests/build-run-context.test.ts
index 8c704801b0..3c866759da 100644
--- a/packages/react-doctor/tests/build-run-context.test.ts
+++ b/packages/react-doctor/tests/build-run-context.test.ts
@@ -96,10 +96,10 @@ describe("buildRunContext", () => {
     expect(context.viaAction).toBe(false);
   });
 
-  it("defaults lintBatchOrdering to 'arrival' and honors the cost override", () => {
-    expect(buildRunContext().lintBatchOrdering).toBe("arrival");
-
-    process.env.REACT_DOCTOR_LINT_BATCH_ORDERING = "cost";
+  it("defaults lintBatchOrdering to 'cost' and honors the arrival rollback", () => {
     expect(buildRunContext().lintBatchOrdering).toBe("cost");
+
+    process.env.REACT_DOCTOR_LINT_BATCH_ORDERING = "arrival";
+    expect(buildRunContext().lintBatchOrdering).toBe("arrival");
   });
 });
diff --git a/packages/react-doctor/tests/scan-result-cache.test.ts b/packages/react-doctor/tests/scan-result-cache.test.ts
index 5e927838df..8877a72a8c 100644
--- a/packages/react-doctor/tests/scan-result-cache.test.ts
+++ b/packages/react-doctor/tests/scan-result-cache.test.ts
@@ -215,8 +215,8 @@ describe("scan result cache", () => {
       delete process.env.REACT_DOCTOR_LINT_BATCH_ORDERING;
       const defaultOrderingKey = cacheKey(projectDirectory, options);
       expect(defaultOrderingKey).not.toBeNull();
-      // The default ordering is `arrival`; opting into `cost` must change the key.
-      process.env.REACT_DOCTOR_LINT_BATCH_ORDERING = "cost";
+      // The default ordering is `cost`; rolling back to `arrival` must change the key.
+      process.env.REACT_DOCTOR_LINT_BATCH_ORDERING = "arrival";
       expect(cacheKey(projectDirectory, options)).not.toBe(defaultOrderingKey);
     } finally {
       if (previousOrdering === undefined) {

From fa61c2056951df2429e79d888e5f7334aaf61cfd Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 18:02:42 -0500
Subject: [PATCH 08/33] =?UTF-8?q?perf(plugin):=20early-exit=20sweep=20?=
 =?UTF-8?q?=E2=80=94=20cheap=20discriminators=20before=20expensive=20walks?=
 =?UTF-8?q?=20(#1047)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reorders ~23 rules/utils so trivial name/type/substring checks run before
subtree walks, scope traces, parent climbs, and settings parses; adds
whole-file no-op gates (zod import gate, recycler-package import gate,
JSX-presence gate for rn-no-raw-text, crypto-token gate for
insecure-crypto-risk) and prunes containsFetchCall after the first match.
Findings #6 #11 #18 #19 #42 #56 #100 #121 #129 #193 #205 #206 #217 #236-#238
#259 #299 #308 #327 #385-#387 #428 from the perf audit catalog; behavior
verified identical via the 291-diagnostic equivalence corpus.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-sweep-early-exit.md           |  5 +
 .../src/plugin/constants/react-native.ts      |  6 ++
 .../src/plugin/rules/a11y/alt-text.ts         | 17 ++++
 .../src/plugin/rules/a11y/anchor-is-valid.ts  |  8 ++
 .../plugin/rules/a11y/img-redundant-alt.ts    |  2 +-
 .../rules/a11y/interactive-supports-focus.ts  | 14 +--
 .../rules/a11y/role-supports-aria-props.ts    | 30 +++---
 .../rules/architecture/no-render-in-render.ts | 12 ++-
 .../rules/js-performance/js-hoist-intl.ts     |  2 +-
 .../nextjs-no-side-effect-in-get-handler.ts   | 20 ++--
 .../prefer-stable-empty-fallback.ts           |  4 +-
 .../no-unstable-nested-components.ts          | 26 +++---
 .../rn-list-missing-estimated-item-size.ts    | 91 +++++++++++--------
 .../rn-list-recyclable-without-types.ts       | 87 ++++++++++--------
 .../rules/react-native/rn-no-raw-text.ts      |  4 +
 .../react-ui/no-redundant-padding-axes.ts     |  3 +
 .../rules/react-ui/no-redundant-size-axes.ts  |  3 +
 .../react-ui/no-space-on-flex-children.ts     |  2 +
 .../security-scan/insecure-crypto-risk.ts     | 10 ++
 .../server-cache-with-object-literal.ts       |  1 +
 .../no-create-context-in-render.ts            | 25 +++--
 .../src/plugin/rules/zod/utils/zod-ast.ts     |  5 +
 .../zod/zod-v4-no-deprecated-error-apis.ts    | 64 +++++++------
 .../zod/zod-v4-no-deprecated-schema-apis.ts   | 68 ++++++++------
 .../zod-v4-prefer-top-level-string-formats.ts | 32 ++++---
 .../src/plugin/utils/contains-fetch-call.ts   |  6 +-
 .../src/plugin/utils/has-jsx-a11y-settings.ts |  8 ++
 .../plugin/utils/is-create-element-call.ts    | 10 +-
 28 files changed, 353 insertions(+), 212 deletions(-)
 create mode 100644 .changeset/perf-sweep-early-exit.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/utils/has-jsx-a11y-settings.ts

diff --git a/.changeset/perf-sweep-early-exit.md b/.changeset/perf-sweep-early-exit.md
new file mode 100644
index 0000000000..c2cbc5c016
--- /dev/null
+++ b/.changeset/perf-sweep-early-exit.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: early-exit sweep — cheap discriminators now run before walks, scope lookups, and parent climbs across ~23 rules (raw-name bails before getElementType, whole-file import gates for the zod and recycler-list rules, substring gates before regex-heavy className analysis, filename gates hoisted to Program, and first-match pruning in containsFetchCall)
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/react-native.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/react-native.ts
index 2bb203503d..58d53af04f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/react-native.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/react-native.ts
@@ -129,6 +129,12 @@ export const RECYCLABLE_LIST_PACKAGES: Record<string, ReadonlyArray<string>> = {
   LegendList: ["@legendapp/list"],
 };
 
+// Flat list of every recycler-owning package source, for whole-file
+// import-presence gates: a file importing none of these can never resolve a
+// recycler, so per-element resolution is skipped entirely.
+export const RECYCLABLE_LIST_PACKAGE_SOURCES: ReadonlyArray<string> =
+  Object.values(RECYCLABLE_LIST_PACKAGES).flat();
+
 // Every list-like element name: built-in RN lists plus the recycler exports.
 // A name-only set for the cheap first filter — provenance lives in the rules.
 export const REACT_NATIVE_LIST_COMPONENTS = new Set([
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/alt-text.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/alt-text.ts
index 88d5139c23..22c16f3da8 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/alt-text.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/alt-text.ts
@@ -3,6 +3,7 @@ import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { getElementType } from "../../utils/get-element-type.js";
 import { getJsxPropStringValue } from "../../utils/get-jsx-prop-string-value.js";
+import { hasJsxA11ySettings } from "../../utils/has-jsx-a11y-settings.js";
 import { hasJsxPropIgnoreCase } from "../../utils/has-jsx-prop-ignore-case.js";
 import { isGeneratedImageRenderContext } from "../../utils/is-generated-image-render-context.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
@@ -200,9 +201,25 @@ export const altText = defineRule({
     const objectAliases = new Set(settings.object ?? []);
     const areaAliases = new Set(settings.area ?? []);
     const inputImageAliases = new Set(settings['input[type="image"]'] ?? []);
+    const fileHasJsxA11ySettings = hasJsxA11ySettings(context.settings);
 
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
+        if (!fileHasJsxA11ySettings && isNodeOfType(node.name, "JSXIdentifier")) {
+          const rawName = node.name.name;
+          if (
+            rawName !== "img" &&
+            rawName !== "object" &&
+            rawName !== "area" &&
+            rawName.toLowerCase() !== "input" &&
+            !imgAliases.has(rawName) &&
+            !objectAliases.has(rawName) &&
+            !areaAliases.has(rawName) &&
+            !inputImageAliases.has(rawName)
+          ) {
+            return;
+          }
+        }
         if (isGeneratedImageRenderContext(context, node)) return;
         const tag = getElementType(node, context.settings);
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/anchor-is-valid.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/anchor-is-valid.ts
index 738fa94621..b2903efd89 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/anchor-is-valid.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/anchor-is-valid.ts
@@ -3,6 +3,7 @@ import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { getElementType } from "../../utils/get-element-type.js";
 import { getStaticTemplateLiteralValue } from "../../utils/get-static-template-literal-value.js";
+import { hasJsxA11ySettings } from "../../utils/has-jsx-a11y-settings.js";
 import { hasJsxPropIgnoreCase } from "../../utils/has-jsx-prop-ignore-case.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 
@@ -76,8 +77,15 @@ export const anchorIsValid = defineRule({
   category: "Accessibility",
   create: (context) => {
     const settings = resolveSettings(context.settings);
+    const fileHasJsxA11ySettings = hasJsxA11ySettings(context.settings);
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
+        if (
+          !fileHasJsxA11ySettings &&
+          (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a")
+        ) {
+          return;
+        }
         const tag = getElementType(node, context.settings);
         if (tag !== "a") return;
         // First-found custom href alternative, falling back to "href".
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts
index 6f84b3c4d8..4434ca313a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts
@@ -94,10 +94,10 @@ export const imgRedundantAlt = defineRule({
     const settings = resolveSettings(context.settings);
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-        if (isGeneratedImageRenderContext(context, node)) return;
         const tag = getElementType(node, context.settings);
         if (!settings.components.includes(tag)) return;
         if (isHiddenFromScreenReader(node, context.settings)) return;
+        if (isGeneratedImageRenderContext(context, node)) return;
         const altAttribute = hasJsxPropIgnoreCase(node.attributes, "alt");
         if (!altAttribute) return;
         if (altValueRedundant(altAttribute, settings.words)) {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts
index 7f3befebab..3a05cd2f12 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts
@@ -59,10 +59,16 @@ export const interactiveSupportsFocus = defineRule({
     const tabbableSet = new Set(settings.tabbable);
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
+        if (node.attributes.length === 0) return;
         // A spread (`{...props}`) can carry `tabIndex`, so focus support is indeterminate.
         if (hasJsxSpreadAttribute(node.attributes)) return;
         const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
         const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
+        if (!role) return;
+        const hasInteractiveHandler = ALL_EVENT_HANDLERS.some((handler) =>
+          Boolean(hasJsxPropIgnoreCase(node.attributes, handler)),
+        );
+        if (!hasInteractiveHandler) return;
         const elementType = getElementType(node, context.settings);
         // Custom components (PascalCase, not in HTML_TAGS) encapsulate
         // their own focus behaviour — `<SegmentButton role="option" />`
@@ -71,20 +77,14 @@ export const interactiveSupportsFocus = defineRule({
         // unactionable: the user can't add tabIndex to a wrapper that
         // already handles focus correctly.
         if (!HTML_TAGS.has(elementType)) return;
-        const hasInteractiveHandler = ALL_EVENT_HANDLERS.some((handler) =>
-          Boolean(hasJsxPropIgnoreCase(node.attributes, handler)),
-        );
-        const hasTabIndex = Boolean(hasJsxPropIgnoreCase(node.attributes, "tabIndex"));
-
         if (
-          !hasInteractiveHandler ||
           isDisabledElement(node) ||
           isHiddenFromScreenReader(node, context.settings) ||
           isPresentationRole(node)
         ) {
           return;
         }
-        if (!role) return;
+        const hasTabIndex = Boolean(hasJsxPropIgnoreCase(node.attributes, "tabIndex"));
         if (
           !isInteractiveRole(role) ||
           isInteractiveElement(elementType, node) ||
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/role-supports-aria-props.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/role-supports-aria-props.ts
index d74219bddd..eee3843c33 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/role-supports-aria-props.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/role-supports-aria-props.ts
@@ -29,17 +29,7 @@ export const roleSupportsAriaProps = defineRule({
   category: "Accessibility",
   create: (context) => ({
     JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-      const elementType = getElementType(node, context.settings);
-      const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-      const role = roleAttribute
-        ? getJsxPropStringValue(roleAttribute)
-        : getImplicitRole(node, elementType);
-      if (!role) return;
-      if (!VALID_ARIA_ROLES.has(role)) return;
-      const isImplicit = !roleAttribute;
-      const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
-      if (!supported) return;
-
+      let ariaAttributes: Array<{ attribute: EsTreeNode; propName: string }> | null = null;
       for (const attribute of node.attributes) {
         if (!isNodeOfType(attribute as EsTreeNode, "JSXAttribute")) continue;
         const attributeNode = attribute as EsTreeNodeOfType<"JSXAttribute">;
@@ -51,9 +41,25 @@ export const roleSupportsAriaProps = defineRule({
         const propName = propRawName.toLowerCase();
         if (!propName.startsWith("aria-")) continue;
         if (!ARIA_PROPERTIES.has(propName)) continue;
+        (ariaAttributes ??= []).push({ attribute: attribute as EsTreeNode, propName });
+      }
+      if (!ariaAttributes) return;
+
+      const elementType = getElementType(node, context.settings);
+      const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
+      const role = roleAttribute
+        ? getJsxPropStringValue(roleAttribute)
+        : getImplicitRole(node, elementType);
+      if (!role) return;
+      if (!VALID_ARIA_ROLES.has(role)) return;
+      const isImplicit = !roleAttribute;
+      const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
+      if (!supported) return;
+
+      for (const { attribute, propName } of ariaAttributes) {
         if (supported.has(propName)) continue;
         context.report({
-          node: attribute as EsTreeNode,
+          node: attribute,
           message: isImplicit
             ? buildMessageImplicit(role, propName, elementType)
             : buildMessageDefault(role, propName),
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts
index 92ec1856aa..77a12df0b8 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts
@@ -99,20 +99,24 @@ export const noRenderInRender = defineRule({
 
       let calleeName: string | null = null;
       if (isNodeOfType(expression.callee, "Identifier")) {
-        if (tracesToPropOrParameter(context.scopes.symbolFor(expression.callee), context.scopes)) {
-          return;
-        }
         calleeName = expression.callee.name;
       } else if (
         isNodeOfType(expression.callee, "MemberExpression") &&
         isNodeOfType(expression.callee.property, "Identifier")
       ) {
-        if (rootsInProps(expression.callee.object, context.scopes)) return;
         calleeName = expression.callee.property.name;
       }
 
       if (!calleeName || !RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 
+      if (isNodeOfType(expression.callee, "Identifier")) {
+        if (tracesToPropOrParameter(context.scopes.symbolFor(expression.callee), context.scopes)) {
+          return;
+        }
+      } else if (isNodeOfType(expression.callee, "MemberExpression")) {
+        if (rootsInProps(expression.callee.object, context.scopes)) return;
+      }
+
       context.report({
         node: expression,
         message: `Your users lose state because "${calleeName}()" builds UI from an inline call that React remounts, so pull it into its own component instead.`,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-hoist-intl.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-hoist-intl.ts
index d3fbf5b6dc..efb53c0c60 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-hoist-intl.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-hoist-intl.ts
@@ -213,7 +213,6 @@ export const jsHoistIntl = defineRule({
   create: (context: RuleContext) => ({
     NewExpression(node: EsTreeNodeOfType<"NewExpression">) {
       if (!isIntlNewExpression(node)) return;
-      if (isInsideCacheMemo(node)) return;
       // Walk up: if any enclosing function is a function/arrow, this is in
       // a function body. Module-scope `new Intl.X()` is fine; we only flag
       // when wrapped in a function (likely called per render or per item).
@@ -259,6 +258,7 @@ export const jsHoistIntl = defineRule({
         cursor = cursor.parent ?? null;
       }
       if (!inFunctionBody) return;
+      if (isInsideCacheMemo(node)) return;
 
       const className =
         isNodeOfType(node.callee, "MemberExpression") &&
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-side-effect-in-get-handler.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-side-effect-in-get-handler.ts
index 9caef2546f..e316231742 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-side-effect-in-get-handler.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-no-side-effect-in-get-handler.ts
@@ -226,23 +226,25 @@ export const nextjsNoSideEffectInGetHandler = defineRule({
     "GET requests can be prefetched and are open to CSRF. Move the side effect to a POST handler.",
   create: (context: RuleContext) => {
     let resolveBinding: (identifierName: string) => EsTreeNode | null = () => null;
+    let isRouteHandlerFile = false;
+    // A "mutating-sounding" route segment (cancel, delete, logout, …) is a
+    // hint, NOT proof: a read-only GET that returns a cancellation policy
+    // is safe. Require an actual side effect before reporting, and only
+    // use the segment to flavor the message.
+    let mutatingSegment: string | null = null;
 
     return {
       Program(node: EsTreeNodeOfType<"Program">) {
         resolveBinding = buildProgramBindingLookup(node);
+        const filename = normalizeFilename(context.filename ?? "");
+        isRouteHandlerFile =
+          ROUTE_HANDLER_FILE_PATTERN.test(filename) && !CRON_ROUTE_PATTERN.test(filename);
+        mutatingSegment = isRouteHandlerFile ? extractMutatingRouteSegment(filename) : null;
       },
       ExportNamedDeclaration(node: EsTreeNodeOfType<"ExportNamedDeclaration">) {
-        const filename = normalizeFilename(context.filename ?? "");
-        if (!ROUTE_HANDLER_FILE_PATTERN.test(filename)) return;
-        if (CRON_ROUTE_PATTERN.test(filename)) return;
+        if (!isRouteHandlerFile) return;
         if (!isExportedGetHandler(node)) return;
 
-        // A "mutating-sounding" route segment (cancel, delete, logout, …) is a
-        // hint, NOT proof: a read-only GET that returns a cancellation policy
-        // is safe. Require an actual side effect before reporting, and only
-        // use the segment to flavor the message.
-        const mutatingSegment = extractMutatingRouteSegment(filename);
-
         const handlerBodies = resolveGetHandlerBodies(node, resolveBinding);
         for (const handlerBody of handlerBodies) {
           const bodiesToScan = [
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/prefer-stable-empty-fallback.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/prefer-stable-empty-fallback.ts
index f9b5c2cd40..104f4aa4c2 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/prefer-stable-empty-fallback.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/prefer-stable-empty-fallback.ts
@@ -108,13 +108,13 @@ export const preferStableEmptyFallback = defineRule({
         memoRegistry = buildSameFileMemoRegistry(node as EsTreeNode);
       },
       JSXAttribute(node: EsTreeNodeOfType<"JSXAttribute">) {
-        if (!isInsideFunctionScope(node)) return;
-        if (isJsxAttributeOnIntrinsicHtmlElement(node)) return;
         if (!node.value) return;
         if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
         const innerExpression = node.value.expression;
         if (!innerExpression) return;
         if (innerExpression.type === "JSXEmptyExpression") return;
+        if (!isInsideFunctionScope(node)) return;
+        if (isJsxAttributeOnIntrinsicHtmlElement(node)) return;
 
         const parentJsxOpening = node.parent;
         const openingName =
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unstable-nested-components.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unstable-nested-components.ts
index bdcc7f9e6a..498c3ae146 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unstable-nested-components.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unstable-nested-components.ts
@@ -8,7 +8,6 @@ import { isEs6Component } from "../../utils/is-es6-component.js";
 import { isFunctionLike } from "../../utils/is-function-like.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { isReactComponentName } from "../../utils/is-react-component-name.js";
-import { isUppercaseName } from "../../utils/is-uppercase-name.js";
 
 const buildMessage = (parentName: string | null): string => {
   let message =
@@ -277,15 +276,22 @@ const isFirstArgumentOfHocCall = (node: EsTreeNode): boolean => {
   return parent.arguments[0] === node;
 };
 
+const MAP_LIKE_METHOD_NAMES: ReadonlySet<string> = new Set([
+  "map",
+  "forEach",
+  "filter",
+  "flatMap",
+  "reduce",
+  "reduceRight",
+]);
+
 const isReturnOfMapCallback = (node: EsTreeNode): boolean => {
   const parent = node.parent;
   if (!parent) return false;
   if (isNodeOfType(parent, "CallExpression")) {
     const callee = parent.callee;
     if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-      return ["map", "forEach", "filter", "flatMap", "reduce", "reduceRight"].includes(
-        callee.property.name,
-      );
+      return MAP_LIKE_METHOD_NAMES.has(callee.property.name);
     }
   }
   if (
@@ -296,9 +302,7 @@ const isReturnOfMapCallback = (node: EsTreeNode): boolean => {
     if (callbackParent && isNodeOfType(callbackParent, "CallExpression")) {
       const callee = callbackParent.callee;
       if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-        return ["map", "forEach", "filter", "flatMap", "reduce", "reduceRight"].includes(
-          callee.property.name,
-        );
+        return MAP_LIKE_METHOD_NAMES.has(callee.property.name);
       }
     }
   }
@@ -360,14 +364,14 @@ const isRenderFlowingReadReference = (identifier: EsTreeNode): boolean => {
         return (
           parent.init === valueNode &&
           isNodeOfType(parent.id, "Identifier") &&
-          isUppercaseName(parent.id.name)
+          isReactComponentName(parent.id.name)
         );
       case "AssignmentExpression": {
         const assignmentTarget = parent.left as EsTreeNode;
         return (
           parent.right === valueNode &&
           isNodeOfType(assignmentTarget, "Identifier") &&
-          isUppercaseName(assignmentTarget.name)
+          isReactComponentName(assignmentTarget.name)
         );
       }
       case "Property": {
@@ -541,7 +545,7 @@ export const noUnstableNestedComponents = defineRule({
 
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-        if (isNodeOfType(node.name, "JSXIdentifier") && isUppercaseName(node.name.name)) {
+        if (isNodeOfType(node.name, "JSXIdentifier") && isReactComponentName(node.name.name)) {
           recordInstantiation(node.name as EsTreeNode, node.name.name);
           return;
         }
@@ -550,7 +554,7 @@ export const noUnstableNestedComponents = defineRule({
         }
       },
       Identifier(node: EsTreeNodeOfType<"Identifier">) {
-        if (!isUppercaseName(node.name)) return;
+        if (!isReactComponentName(node.name)) return;
         if (!isRenderFlowingReadReference(node as EsTreeNode)) return;
         recordInstantiation(node as EsTreeNode, node.name);
       },
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts
index 4ac6d82673..c2d1758ee0 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts
@@ -1,6 +1,10 @@
 import { defineRule } from "../../utils/define-rule.js";
 import { getReactDoctorNumberSetting } from "../../utils/get-react-doctor-setting.js";
-import { FLASH_LIST_V2_MAJOR } from "../../constants/react-native.js";
+import {
+  FLASH_LIST_V2_MAJOR,
+  RECYCLABLE_LIST_PACKAGE_SOURCES,
+} from "../../constants/react-native.js";
+import { hasImportFromModules } from "../../utils/find-import-source-for-name.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import { resolveJsxElementName } from "./utils/resolve-jsx-element-name.js";
 import { resolveImportedRecyclerName } from "./utils/resolve-imported-recycler-name.js";
@@ -42,48 +46,55 @@ export const rnListMissingEstimatedItemSize = defineRule({
   severity: "warn",
   recommendation:
     "Without `estimatedItemSize` the list guesses row height and can flash blank cells on fast scroll. Add `estimatedItemSize={<avg-row-height-in-px>}` so it matches your rows.",
-  create: (context: RuleContext) => ({
-    JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-      const localElementName = resolveJsxElementName(node);
-      if (!localElementName) return;
-      // Resolve the LOCAL JSX name back to its originally-exported
-      // symbol from one of the recycler-owning packages. This handles
-      // both plain (`import { FlashList }`) and aliased
-      // (`import { FlashList as List }; <List />`) imports — we never
-      // key off the local JSX name directly.
-      const canonicalRecyclerName = resolveImportedRecyclerName(node, localElementName);
-      if (canonicalRecyclerName === null) return;
-      if (canonicalRecyclerName === "FlashList" && isFlashListV2OrNewer(context)) return;
+  create: (context: RuleContext) => {
+    let fileImportsRecycler = false;
+    return {
+      Program(node: EsTreeNodeOfType<"Program">) {
+        fileImportsRecycler = hasImportFromModules(node, RECYCLABLE_LIST_PACKAGE_SOURCES);
+      },
+      JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
+        if (!fileImportsRecycler) return;
+        const localElementName = resolveJsxElementName(node);
+        if (!localElementName) return;
+        // Resolve the LOCAL JSX name back to its originally-exported
+        // symbol from one of the recycler-owning packages. This handles
+        // both plain (`import { FlashList }`) and aliased
+        // (`import { FlashList as List }; <List />`) imports — we never
+        // key off the local JSX name directly.
+        const canonicalRecyclerName = resolveImportedRecyclerName(node, localElementName);
+        if (canonicalRecyclerName === null) return;
+        if (canonicalRecyclerName === "FlashList" && isFlashListV2OrNewer(context)) return;
 
-      let hasSizingHint = false;
-      let dataIsEmptyLiteral = false;
-      let hasDataProp = false;
+        let hasSizingHint = false;
+        let dataIsEmptyLiteral = false;
+        let hasDataProp = false;
 
-      for (const attribute of node.attributes ?? []) {
-        if (!isNodeOfType(attribute, "JSXAttribute")) continue;
-        if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
-        const attributeName = attribute.name.name;
-        if (SIZING_HINT_ATTRIBUTE_NAMES.has(attributeName)) hasSizingHint = true;
-        if (attributeName === "data") {
-          hasDataProp = true;
-          if (isEmptyArrayLiteral(attribute)) dataIsEmptyLiteral = true;
+        for (const attribute of node.attributes ?? []) {
+          if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+          if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
+          const attributeName = attribute.name.name;
+          if (SIZING_HINT_ATTRIBUTE_NAMES.has(attributeName)) hasSizingHint = true;
+          if (attributeName === "data") {
+            hasDataProp = true;
+            if (isEmptyArrayLiteral(attribute)) dataIsEmptyLiteral = true;
+          }
         }
-      }
 
-      if (hasSizingHint) return;
-      // Skip placeholder lists — `<FlashList data={[]} />` is almost
-      // always a render-with-empty-data branch, not a production code
-      // path, and adding `estimatedItemSize` there is busywork.
-      if (dataIsEmptyLiteral) return;
-      // Skip JSX that doesn't even pass `data` — likely an
-      // abstract wrapper component being defined, not an instantiation
-      // with real items.
-      if (!hasDataProp) return;
+        if (hasSizingHint) return;
+        // Skip placeholder lists — `<FlashList data={[]} />` is almost
+        // always a render-with-empty-data branch, not a production code
+        // path, and adding `estimatedItemSize` there is busywork.
+        if (dataIsEmptyLiteral) return;
+        // Skip JSX that doesn't even pass `data` — likely an
+        // abstract wrapper component being defined, not an instantiation
+        // with real items.
+        if (!hasDataProp) return;
 
-      context.report({
-        node,
-        message: `Your users see blank cells flash on fast scroll when <${localElementName}> has no \`estimatedItemSize\`.`,
-      });
-    },
-  }),
+        context.report({
+          node,
+          message: `Your users see blank cells flash on fast scroll when <${localElementName}> has no \`estimatedItemSize\`.`,
+        });
+      },
+    };
+  },
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-recyclable-without-types.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-recyclable-without-types.ts
index ea0b0ef850..1bc8ceb31c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-recyclable-without-types.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-list-recyclable-without-types.ts
@@ -1,4 +1,6 @@
+import { RECYCLABLE_LIST_PACKAGE_SOURCES } from "../../constants/react-native.js";
 import { defineRule } from "../../utils/define-rule.js";
+import { hasImportFromModules } from "../../utils/find-import-source-for-name.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import { resolveJsxElementName } from "./utils/resolve-jsx-element-name.js";
 import { resolveImportedRecyclerName } from "./utils/resolve-imported-recycler-name.js";
@@ -24,48 +26,55 @@ export const rnListRecyclableWithoutTypes = defineRule({
   severity: "warn",
   recommendation:
     "When rows have different shapes, reused cells can show the wrong layout. Add `getItemType={item => item.kind}` so FlashList keeps a separate pool per row type.",
-  create: (context: RuleContext) => ({
-    JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
-      const elementName = resolveJsxElementName(node);
-      if (!elementName) return;
-      // Resolve the LOCAL JSX name back to a recycler that was really imported
-      // from `@shopify/flash-list` / `@legendapp/list` — named, aliased, or
-      // namespace member access. A name-only match on a homegrown `FlashList`
-      // (`const FlashList = MyOwnList`) isn't a recycler.
-      if (
-        resolveImportedRecyclerName(node, elementName, {
-          allowNamespaceMemberAccess: true,
-        }) === null
-      )
-        return;
+  create: (context: RuleContext) => {
+    let fileImportsRecycler = false;
+    return {
+      Program(node: EsTreeNodeOfType<"Program">) {
+        fileImportsRecycler = hasImportFromModules(node, RECYCLABLE_LIST_PACKAGE_SOURCES);
+      },
+      JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
+        if (!fileImportsRecycler) return;
+        const elementName = resolveJsxElementName(node);
+        if (!elementName) return;
+        // Resolve the LOCAL JSX name back to a recycler that was really imported
+        // from `@shopify/flash-list` / `@legendapp/list` — named, aliased, or
+        // namespace member access. A name-only match on a homegrown `FlashList`
+        // (`const FlashList = MyOwnList`) isn't a recycler.
+        if (
+          resolveImportedRecyclerName(node, elementName, {
+            allowNamespaceMemberAccess: true,
+          }) === null
+        )
+          return;
 
-      let hasRecycleItemsEnabled = false;
-      let hasGetItemType = false;
+        let hasRecycleItemsEnabled = false;
+        let hasGetItemType = false;
 
-      for (const attr of node.attributes ?? []) {
-        if (!isNodeOfType(attr, "JSXAttribute")) continue;
-        if (!isNodeOfType(attr.name, "JSXIdentifier")) continue;
-        if (attr.name.name === "recycleItems") {
-          if (!attr.value) {
-            hasRecycleItemsEnabled = true;
-          } else if (
-            isNodeOfType(attr.value, "JSXExpressionContainer") &&
-            isNodeOfType(attr.value.expression, "Literal")
-          ) {
-            hasRecycleItemsEnabled = attr.value.expression.value === true;
-          } else {
-            hasRecycleItemsEnabled = true;
+        for (const attr of node.attributes ?? []) {
+          if (!isNodeOfType(attr, "JSXAttribute")) continue;
+          if (!isNodeOfType(attr.name, "JSXIdentifier")) continue;
+          if (attr.name.name === "recycleItems") {
+            if (!attr.value) {
+              hasRecycleItemsEnabled = true;
+            } else if (
+              isNodeOfType(attr.value, "JSXExpressionContainer") &&
+              isNodeOfType(attr.value.expression, "Literal")
+            ) {
+              hasRecycleItemsEnabled = attr.value.expression.value === true;
+            } else {
+              hasRecycleItemsEnabled = true;
+            }
           }
+          if (attr.name.name === "getItemType") hasGetItemType = true;
         }
-        if (attr.name.name === "getItemType") hasGetItemType = true;
-      }
 
-      if (hasRecycleItemsEnabled && !hasGetItemType) {
-        context.report({
-          node,
-          message: `Your users see rows of different shapes reuse the wrong cells when <${elementName} recycleItems> has no \`getItemType\`.`,
-        });
-      }
-    },
-  }),
+        if (hasRecycleItemsEnabled && !hasGetItemType) {
+          context.report({
+            node,
+            message: `Your users see rows of different shapes reuse the wrong cells when <${elementName} recycleItems> has no \`getItemType\`.`,
+          });
+        }
+      },
+    };
+  },
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
index 0fe7cf37ba..d306be5df8 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
@@ -5,6 +5,7 @@ import {
   REACT_NATIVE_TEXT_COMPONENT_KEYWORDS,
   REACT_NATIVE_TEXT_TRANSPARENT_COMPONENTS,
 } from "../../constants/react-native.js";
+import { containsJsxElement } from "../../utils/contains-jsx-element.js";
 import { defineRule } from "../../utils/define-rule.js";
 import { hasDirective } from "../../utils/has-directive.js";
 import { isInsidePlatformOsWebBranch } from "../../utils/is-inside-platform-os-web-branch.js";
@@ -163,6 +164,9 @@ export const rnNoRawText = defineRule({
     return {
       Program(programNode: EsTreeNodeOfType<"Program">) {
         isDomComponentFile = hasDirective(programNode, "use dom");
+        // A file with no JSX never fires the JSXElement visitor, so the
+        // wrapper classification would go unread — skip the fixpoint walk.
+        if (!containsJsxElement(programNode)) return;
         const childrenForwarding = collectTextWrapperComponents(
           programNode,
           isTextHandlingComponent,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-padding-axes.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-padding-axes.ts
index c7054323c3..5894270cbd 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-padding-axes.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-padding-axes.ts
@@ -31,6 +31,9 @@ export const noRedundantPaddingAxes = defineRule({
       }
       const classNameLiteral = getClassNameLiteral(jsxAttribute);
       if (!classNameLiteral) return;
+      // A collapsible pair needs BOTH axes present, so a class list missing
+      // either substring can never match — bail before any regex work.
+      if (!classNameLiteral.includes("px-") || !classNameLiteral.includes("py-")) return;
       // Per-breakpoint variation is a legit reason to keep the axes split.
       if (
         hasResponsivePrefix(classNameLiteral, "px") ||
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-size-axes.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-size-axes.ts
index 0b089a0902..f449cc3d85 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-size-axes.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-redundant-size-axes.ts
@@ -29,6 +29,9 @@ export const noRedundantSizeAxes = defineRule({
       }
       const classNameLiteral = getClassNameLiteral(jsxAttribute);
       if (!classNameLiteral) return;
+      // A redundant pair needs BOTH axes present, so a class list missing
+      // either substring can never match — bail before any regex work.
+      if (!classNameLiteral.includes("w-") || !classNameLiteral.includes("h-")) return;
       if (
         hasResponsivePrefix(classNameLiteral, "w") ||
         hasResponsivePrefix(classNameLiteral, "h")
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-space-on-flex-children.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-space-on-flex-children.ts
index 02f5225b47..30f338f00b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-space-on-flex-children.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-ui/no-space-on-flex-children.ts
@@ -29,6 +29,8 @@ export const noSpaceOnFlexChildren = defineRule({
       }
       const classNameLiteral = getClassNameLiteral(jsxAttribute);
       if (!classNameLiteral) return;
+      // No `space-*` utility means nothing to report — bail before tokenizing.
+      if (!classNameLiteral.includes("space-")) return;
       const tokens = tokenizeClassName(classNameLiteral);
       let hasFlexOrGridLayout = false;
       for (const token of tokens) {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/insecure-crypto-risk.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/insecure-crypto-risk.ts
index 9ee4203aab..a159687a36 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/insecure-crypto-risk.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/insecure-crypto-risk.ts
@@ -71,6 +71,14 @@ const MATH_RANDOM_CALL_PATTERN = /Math\.random\s*\(/g;
 
 const SECURITY_CONTEXT_WINDOW_CHARS = 250;
 
+// Every detection pass below requires one of these substrings, so a file
+// without any of them can never report — bail before stripping comments and
+// running the multi-pass scan. Comment stripping only blanks characters
+// (positions preserved), so a token present in stripped content is always
+// present in the raw content too.
+const CRYPTO_SURFACE_TRIGGER_PATTERN =
+  /createHash|md5|cipher|encrypt|decrypt|crypto|signature|Math\.random/i;
+
 // File-level co-occurrence is a trap: any OAuth service mentions `token`
 // somewhere, so the context word must sit near the flagged call itself.
 const findMatchIndexNearContext = (
@@ -125,6 +133,8 @@ export const insecureCryptoRisk = defineRule({
     // not within the 250-char window around the hash call.
     if (PROTOCOL_MANDATED_HASH_CONTEXT_PATTERN.test(file.relativePath)) return [];
 
+    if (!CRYPTO_SURFACE_TRIGGER_PATTERN.test(file.content)) return [];
+
     // Match against comment-stripped content (positions preserved) — migration
     // notes and doc comments are exactly where `md5` / `DES` prose concentrates,
     // and a `// TODO: stop hashing the password with md5(value)` must not fire.
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-cache-with-object-literal.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-cache-with-object-literal.ts
index ba85a1be2f..da9579c922 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-cache-with-object-literal.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-cache-with-object-literal.ts
@@ -36,6 +36,7 @@ export const serverCacheWithObjectLiteral = defineRule({
         cachedFunctionNames.add(node.id.name);
       },
       CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
+        if (cachedFunctionNames.size === 0) return;
         if (!isNodeOfType(node.callee, "Identifier")) return;
         if (!cachedFunctionNames.has(node.callee.name)) return;
         const firstArg = node.arguments?.[0];
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-create-context-in-render.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-create-context-in-render.ts
index c28312b4d1..529bd85d47 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-create-context-in-render.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-create-context-in-render.ts
@@ -3,8 +3,8 @@ import { enclosingComponentOrHookName } from "../../utils/enclosing-component-or
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import {
-  getImportedNameFromModule,
-  isImportedFromModule,
+  getImportBindingForName,
+  getImportSourceForName,
 } from "../../utils/find-import-source-for-name.js";
 import { isCanonicalReactNamespaceName } from "../../utils/is-canonical-react-namespace-name.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
@@ -21,16 +21,17 @@ const CONTEXT_MODULES: ReadonlyArray<string> = ["react", "use-context-selector",
 
 const isCreateContextCallee = (callee: EsTreeNode): boolean => {
   if (isNodeOfType(callee, "Identifier")) {
-    // Resolve through any renamed import — `getImportedNameFromModule`
-    // returns the originally-exported symbol name, so we catch both
+    // Resolve through any renamed import — the binding carries the
+    // originally-exported symbol name, so we catch both
     // `import { createContext } from "react"` and
     // `import { createContext as makeCtx } from "react"`. We accept
     // any module in `CONTEXT_MODULES`.
-    for (const moduleName of CONTEXT_MODULES) {
-      const canonicalName = getImportedNameFromModule(callee, callee.name, moduleName);
-      if (canonicalName === "createContext") return true;
-    }
-    return false;
+    const binding = getImportBindingForName(callee, callee.name);
+    return (
+      binding !== null &&
+      binding.exportedName === "createContext" &&
+      CONTEXT_MODULES.includes(binding.source)
+    );
   }
 
   if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
@@ -41,10 +42,8 @@ const isCreateContextCallee = (callee: EsTreeNode): boolean => {
     if (propertyIdentifier.name !== "createContext") return false;
     const namespaceName = namespaceIdentifier.name;
     if (isCanonicalReactNamespaceName(namespaceName)) return true;
-    for (const moduleName of CONTEXT_MODULES) {
-      if (isImportedFromModule(namespaceIdentifier, namespaceName, moduleName)) return true;
-    }
-    return false;
+    const importSource = getImportSourceForName(namespaceIdentifier, namespaceName);
+    return importSource !== null && CONTEXT_MODULES.includes(importSource);
   }
 
   return false;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts
index d5bde8b5a9..833fa1f05d 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts
@@ -6,6 +6,11 @@ import { stripParenExpression } from "../../../utils/strip-paren-expression.js";
 
 const ZOD_MODULE = "zod";
 
+// Every zod detection below bottoms out in `getImportInfoForIdentifier`,
+// which requires an import whose source is exactly `ZOD_MODULE` — so a file
+// with no such import can never report, and rules gate their visitors on it.
+export const ZOD_MODULE_SOURCES: ReadonlyArray<string> = [ZOD_MODULE];
+
 interface ZodImportInfo {
   imported: string | null;
   isDefault: boolean;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-error-apis.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-error-apis.ts
index 851d32d001..69d0197486 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-error-apis.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-error-apis.ts
@@ -1,10 +1,12 @@
 import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
+import { hasImportFromModules } from "../../utils/find-import-source-for-name.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { stripParenExpression } from "../../utils/strip-paren-expression.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import {
+  ZOD_MODULE_SOURCES,
   getMethodCall,
   getStaticPropertyName,
   getZodNamedImport,
@@ -70,31 +72,39 @@ export const zodV4NoDeprecatedErrorApis = defineRule({
   severity: "warn",
   recommendation:
     "Use the Zod 4 helpers instead: `z.treeifyError()`, `z.flattenError()`, `z.prettifyError()`, or read `error.issues` directly.",
-  create: (context: RuleContext) => ({
-    CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
-      if (isZodErrorCreateCall(node) && isReceiverOfDeprecatedZodErrorMember(node)) return;
-      if (!isZodErrorCreateCall(node) && !isDeprecatedZodErrorMemberAccess(node.callee)) {
-        return;
-      }
-      context.report({
-        node,
-        message: ZOD_ERROR_API_MESSAGE,
-      });
-    },
-    MemberExpression(node: EsTreeNodeOfType<"MemberExpression">) {
-      const parent = node.parent;
-      if (
-        parent &&
-        isNodeOfType(parent, "CallExpression") &&
-        stripParenExpression(parent.callee as EsTreeNode) === node
-      ) {
-        return;
-      }
-      if (!isDeprecatedZodErrorMemberAccess(node)) return;
-      context.report({
-        node,
-        message: ZOD_ERROR_API_MESSAGE,
-      });
-    },
-  }),
+  create: (context: RuleContext) => {
+    let fileImportsZod = false;
+    return {
+      Program(node: EsTreeNodeOfType<"Program">) {
+        fileImportsZod = hasImportFromModules(node, ZOD_MODULE_SOURCES);
+      },
+      CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
+        if (!fileImportsZod) return;
+        if (isZodErrorCreateCall(node) && isReceiverOfDeprecatedZodErrorMember(node)) return;
+        if (!isZodErrorCreateCall(node) && !isDeprecatedZodErrorMemberAccess(node.callee)) {
+          return;
+        }
+        context.report({
+          node,
+          message: ZOD_ERROR_API_MESSAGE,
+        });
+      },
+      MemberExpression(node: EsTreeNodeOfType<"MemberExpression">) {
+        if (!fileImportsZod) return;
+        const parent = node.parent;
+        if (
+          parent &&
+          isNodeOfType(parent, "CallExpression") &&
+          stripParenExpression(parent.callee as EsTreeNode) === node
+        ) {
+          return;
+        }
+        if (!isDeprecatedZodErrorMemberAccess(node)) return;
+        context.report({
+          node,
+          message: ZOD_ERROR_API_MESSAGE,
+        });
+      },
+    };
+  },
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-schema-apis.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-schema-apis.ts
index d9cf411f17..790393798a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-schema-apis.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-no-deprecated-schema-apis.ts
@@ -1,10 +1,12 @@
 import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
+import { hasImportFromModules } from "../../utils/find-import-source-for-name.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { stripParenExpression } from "../../utils/strip-paren-expression.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import {
+  ZOD_MODULE_SOURCES,
   getMethodCall,
   getStaticPropertyName,
   getZodNamedImport,
@@ -169,33 +171,41 @@ export const zodV4NoDeprecatedSchemaApis = defineRule({
   severity: "warn",
   recommendation:
     "Switch to the Zod 4 versions: top-level factories like `z.enum()`, object helpers like `z.strictObject()`, the new `z.function({ input, output })` form, and explicit key/value schemas for `z.record()`.",
-  create: (context: RuleContext) => ({
-    CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
-      if (
-        isCallToDeprecatedTopLevelFactory(node) ||
-        isCallToDroppedCreateFactory(node) ||
-        isSingleArgumentRecordCall(node) ||
-        isLiteralSymbolCall(node) ||
-        isDeprecatedFunctionChainCall(node) ||
-        isDirectMethodCallOnZodFactory(node, OBJECT_FACTORY, OBJECT_METHODS) ||
-        isDirectMethodCallOnZodFactory(node, NUMBER_FACTORY, NUMBER_METHODS) ||
-        isRefineSecondArgumentFunction(node)
-      ) {
-        reportSchemaMigration(context, node);
-      }
-    },
-    MemberExpression(node: EsTreeNodeOfType<"MemberExpression">) {
-      const parent = node.parent;
-      if (
-        parent &&
-        isNodeOfType(parent, "CallExpression") &&
-        stripParenExpression(parent.callee as EsTreeNode) === node
-      ) {
-        return;
-      }
-      if (isDroppedEnumAliasAccess(node) || isZodNamespaceImportMemberCreate(node)) {
-        reportSchemaMigration(context, node);
-      }
-    },
-  }),
+  create: (context: RuleContext) => {
+    let fileImportsZod = false;
+    return {
+      Program(node: EsTreeNodeOfType<"Program">) {
+        fileImportsZod = hasImportFromModules(node, ZOD_MODULE_SOURCES);
+      },
+      CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
+        if (!fileImportsZod) return;
+        if (
+          isCallToDeprecatedTopLevelFactory(node) ||
+          isCallToDroppedCreateFactory(node) ||
+          isSingleArgumentRecordCall(node) ||
+          isLiteralSymbolCall(node) ||
+          isDeprecatedFunctionChainCall(node) ||
+          isDirectMethodCallOnZodFactory(node, OBJECT_FACTORY, OBJECT_METHODS) ||
+          isDirectMethodCallOnZodFactory(node, NUMBER_FACTORY, NUMBER_METHODS) ||
+          isRefineSecondArgumentFunction(node)
+        ) {
+          reportSchemaMigration(context, node);
+        }
+      },
+      MemberExpression(node: EsTreeNodeOfType<"MemberExpression">) {
+        if (!fileImportsZod) return;
+        const parent = node.parent;
+        if (
+          parent &&
+          isNodeOfType(parent, "CallExpression") &&
+          stripParenExpression(parent.callee as EsTreeNode) === node
+        ) {
+          return;
+        }
+        if (isDroppedEnumAliasAccess(node) || isZodNamespaceImportMemberCreate(node)) {
+          reportSchemaMigration(context, node);
+        }
+      },
+    };
+  },
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts
index 0ff258ec72..00bc74edae 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts
@@ -1,7 +1,8 @@
 import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
+import { hasImportFromModules } from "../../utils/find-import-source-for-name.js";
 import type { RuleContext } from "../../utils/rule-context.js";
-import { isDirectMethodCallOnZodFactory } from "./utils/zod-ast.js";
+import { ZOD_MODULE_SOURCES, isDirectMethodCallOnZodFactory } from "./utils/zod-ast.js";
 
 const ZOD_STRING_FACTORY = new Set(["string"]);
 const STRING_FORMAT_METHODS = new Set([
@@ -36,14 +37,23 @@ export const zodV4PreferTopLevelStringFormats = defineRule({
   severity: "warn",
   recommendation:
     "Use the Zod 4 top-level format checks like `z.email()`, `z.uuid()`, or `z.ipv4()` instead of `z.string().<format>()`.",
-  create: (context: RuleContext) => ({
-    CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
-      if (!isDirectMethodCallOnZodFactory(node, ZOD_STRING_FACTORY, STRING_FORMAT_METHODS)) return;
-      context.report({
-        node,
-        message:
-          "This `z.string().<format>()` check is deprecated in Zod 4, so it can break during the upgrade.",
-      });
-    },
-  }),
+  create: (context: RuleContext) => {
+    let fileImportsZod = false;
+    return {
+      Program(node: EsTreeNodeOfType<"Program">) {
+        fileImportsZod = hasImportFromModules(node, ZOD_MODULE_SOURCES);
+      },
+      CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
+        if (!fileImportsZod) return;
+        if (!isDirectMethodCallOnZodFactory(node, ZOD_STRING_FACTORY, STRING_FORMAT_METHODS)) {
+          return;
+        }
+        context.report({
+          node,
+          message:
+            "This `z.string().<format>()` check is deprecated in Zod 4, so it can break during the upgrade.",
+        });
+      },
+    };
+  },
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-fetch-call.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-fetch-call.ts
index 223a712276..106b83901f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-fetch-call.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-fetch-call.ts
@@ -37,6 +37,7 @@ export const containsFetchCall = (
     : null;
   let didFindFetchCall = false;
   walkAst(node, (child) => {
+    if (didFindFetchCall) return false;
     if (
       effectInvokedFunctions &&
       child !== node &&
@@ -45,7 +46,10 @@ export const containsFetchCall = (
     ) {
       return false;
     }
-    if (isFetchCall(child)) didFindFetchCall = true;
+    if (isFetchCall(child)) {
+      didFindFetchCall = true;
+      return false;
+    }
   });
   return didFindFetchCall;
 };
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/has-jsx-a11y-settings.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/has-jsx-a11y-settings.ts
new file mode 100644
index 0000000000..a535e4b38f
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/has-jsx-a11y-settings.ts
@@ -0,0 +1,8 @@
+// When no `jsx-a11y` settings block exists, `getElementType` resolves to the
+// raw JSX name, so rules can bail on the raw name without the settings parse.
+export const hasJsxA11ySettings = (
+  settings: Readonly<Record<string, unknown>> | undefined,
+): boolean => {
+  const block = settings?.["jsx-a11y"];
+  return typeof block === "object" && block !== null;
+};
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-create-element-call.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-create-element-call.ts
index a5efa1cb83..da06554950 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-create-element-call.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-create-element-call.ts
@@ -38,14 +38,14 @@ export const isCreateElementCall = (node: EsTreeNode): boolean => {
   if (isNodeOfType(callee, "Identifier")) return callee.name === "createElement";
 
   if (isNodeOfType(callee, "MemberExpression")) {
+    const propertyIsCreateElement = callee.computed
+      ? isNodeOfType(callee.property, "Literal") && callee.property.value === "createElement"
+      : isNodeOfType(callee.property, "Identifier") && callee.property.name === "createElement";
+    if (!propertyIsCreateElement) return false;
     // Walk the chain — `dom.window.document.createElement(...)` has
     // `document` somewhere in the object chain (not just the immediate
     // object), and that's still the DOM API.
-    if (memberChainContainsDocument(callee.object as EsTreeNode)) return false;
-    if (callee.computed) {
-      return isNodeOfType(callee.property, "Literal") && callee.property.value === "createElement";
-    }
-    return isNodeOfType(callee.property, "Identifier") && callee.property.name === "createElement";
+    return !memberChainContainsDocument(callee.object as EsTreeNode);
   }
 
   return false;

From ebeee568abf9a7ed37ed9fe0bba695e4f2a11c9f Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 18:03:33 -0500
Subject: [PATCH 09/33] =?UTF-8?q?perf(plugin):=20regex-hoist=20sweep=20?=
 =?UTF-8?q?=E2=80=94=20stop=20rebuilding=20RegExps=20per=20call=20(#1049)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Hoists the public-env secret-name global pattern to module scope
(#248/#264/#270/#281), replaces supabase-table-missing-rls's per-table
RegExp compile + tail slice with one global enable-RLS collection pass
(#271/#295), makes dangerous-html-sink's inert-parse-target scans
conditional on cheap createElement/createHTMLDocument substring gates
(#518) and its serializer/sanitizer exemption regexes lazy (#519), fuses
the duration regexes and hoists time patterns in
no-long-transition-duration (#73), early-stops shadow-blur token
collection in no-dark-mode-glow (#74), and adds text-/bg-, first-char,
and rgb/hsl substring gates to no-gray-on-colored-background (#76) and
parse-color-to-rgb (#83). compile-glob and has-responsive-prefix were
already shipped elsewhere and are untouched. Behavior verified identical
via the 291-diagnostic equivalence corpus.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-sweep-regex-hoist.md          |  5 +
 .../plugin/rules/design/no-dark-mode-glow.ts  | 19 +++-
 .../design/no-gray-on-colored-background.ts   |  7 ++
 .../design/no-long-transition-duration.ts     | 29 +++---
 .../rules/design/utils/parse-color-to-rgb.ts  | 96 ++++++++++---------
 .../security-scan/dangerous-html-sink.ts      | 57 ++++++-----
 .../supabase-table-missing-rls.ts             | 26 +++--
 .../find-suspicious-public-env-secret-name.ts |  9 +-
 8 files changed, 150 insertions(+), 98 deletions(-)
 create mode 100644 .changeset/perf-sweep-regex-hoist.md

diff --git a/.changeset/perf-sweep-regex-hoist.md b/.changeset/perf-sweep-regex-hoist.md
new file mode 100644
index 0000000000..66e4e0c45b
--- /dev/null
+++ b/.changeset/perf-sweep-regex-hoist.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: regex-hoist sweep — ~8 per-call RegExp constructions move to module scope or behind cheap gates (public-env secret-name global pattern hoisted, supabase RLS enables collected in one pass instead of per-table compile+slice, dangerous-html-sink inert-target and serializer exemptions gated/lazy, design color/duration parsers get first-char and substring discriminators)
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-dark-mode-glow.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-dark-mode-glow.ts
index fdc529785a..66e78fedf4 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-dark-mode-glow.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-dark-mode-glow.ts
@@ -32,12 +32,21 @@ const extractColorFromShadowLayer = (layer: string): ParsedRgb | null => {
   return null;
 };
 
+const RGB_FUNCTION_PATTERN = /rgba?\([^)]*\)/g;
+const HEX_COLOR_PATTERN = /#[0-9a-f]{3,8}\b/gi;
+const NUMERIC_TOKEN_PATTERN = /(\d+(?:\.\d+)?)(px)?/g;
+
+// The blur radius is the third numeric token (`offset-x offset-y blur`).
+const SHADOW_BLUR_TOKEN_INDEX = 2;
+
 const parseShadowLayerBlur = (layer: string): number => {
-  const withoutColors = layer.replace(/rgba?\([^)]*\)/g, "").replace(/#[0-9a-f]{3,8}\b/gi, "");
-  const numericTokens = [...withoutColors.matchAll(/(\d+(?:\.\d+)?)(px)?/g)].map((match) =>
-    parseFloat(match[1]),
-  );
-  return numericTokens.length >= 3 ? numericTokens[2] : 0;
+  const withoutColors = layer.replace(RGB_FUNCTION_PATTERN, "").replace(HEX_COLOR_PATTERN, "");
+  let tokenIndex = 0;
+  for (const match of withoutColors.matchAll(NUMERIC_TOKEN_PATTERN)) {
+    if (tokenIndex === SHADOW_BLUR_TOKEN_INDEX) return parseFloat(match[1]);
+    tokenIndex += 1;
+  }
+  return 0;
 };
 
 const hasColoredGlowShadow = (shadowValue: string): boolean => {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-gray-on-colored-background.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-gray-on-colored-background.ts
index f25903aff6..f20d7c983b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-gray-on-colored-background.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-gray-on-colored-background.ts
@@ -17,6 +17,9 @@ const BG_COLOR_PATTERN =
 // reordered stacks (`md:hover` vs `hover:md`) share one key. A leading
 // `!` (the important modifier) is not part of the utility name.
 const splitVariantScope = (token: string): { scope: string; utility: string } => {
+  if (!token.includes(":")) {
+    return { scope: "", utility: token.startsWith("!") ? token.slice(1) : token };
+  }
   const segments = token.split(":");
   const rawUtility = segments[segments.length - 1];
   return {
@@ -44,6 +47,10 @@ export const noGrayOnColoredBackground = defineRule({
       const bgColorScopes = new Set<string>();
       for (const token of classStr.split(/\s+/)) {
         if (!token) continue;
+        // Every pattern below anchors on a `text-` / `bg-` utility, so a
+        // token containing neither substring can never match — skip the
+        // variant-scope split and the four regexes.
+        if (!token.includes("text-") && !token.includes("bg-")) continue;
         const { scope, utility } = splitVariantScope(token);
         if (TEXT_COLOR_PATTERN.test(utility)) textColorScopes.add(scope);
         if (BG_COLOR_PATTERN.test(utility)) bgColorScopes.add(scope);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-long-transition-duration.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-long-transition-duration.ts
index 2afad0c2f2..d042b973ac 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-long-transition-duration.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/no-long-transition-duration.ts
@@ -28,6 +28,13 @@ const hasInfiniteIterationCount = (properties: ReadonlyArray<EsTreeNode>): boole
 const isInfiniteAnimationSegment = (segment: string): boolean =>
   segment.trim().split(/\s+/).includes("infinite");
 
+// `100ms` / `1.5s` as the WHOLE segment (transitionDuration / animationDuration
+// values). One combined pattern replaces separate ms and s matches per segment.
+const DURATION_SEGMENT_PATTERN = /^([\d.]+)(m?s)$/;
+
+// First time token inside a `transition` / `animation` shorthand segment.
+const FIRST_TIME_TOKEN_PATTERN = /(?<![a-zA-Z\d])([\d.]+)(m?s)(?![a-zA-Z\d-])/;
+
 export const noLongTransitionDuration = defineRule({
   id: "no-long-transition-duration",
   title: "Transition duration too long",
@@ -67,19 +74,13 @@ export const noLongTransitionDuration = defineRule({
         if (key === "transitionDuration" || key === "animationDuration") {
           let longestDurationPropertyMs = 0;
           for (const segment of value.split(",")) {
-            const trimmedSegment = segment.trim();
-            const msMatch = trimmedSegment.match(/^([\d.]+)ms$/);
-            const secondsMatch = trimmedSegment.match(/^([\d.]+)s$/);
-            if (msMatch)
-              longestDurationPropertyMs = Math.max(
-                longestDurationPropertyMs,
-                parseFloat(msMatch[1]),
-              );
-            else if (secondsMatch)
-              longestDurationPropertyMs = Math.max(
-                longestDurationPropertyMs,
-                parseFloat(secondsMatch[1]) * 1000,
-              );
+            const durationMatch = segment.trim().match(DURATION_SEGMENT_PATTERN);
+            if (!durationMatch) continue;
+            const segmentDurationMs =
+              durationMatch[2] === "ms"
+                ? parseFloat(durationMatch[1])
+                : parseFloat(durationMatch[1]) * 1000;
+            longestDurationPropertyMs = Math.max(longestDurationPropertyMs, segmentDurationMs);
           }
           if (longestDurationPropertyMs > 0) durationMs = longestDurationPropertyMs;
         }
@@ -88,7 +89,7 @@ export const noLongTransitionDuration = defineRule({
           let longestDurationMs = 0;
           for (const segment of value.split(",")) {
             if (key === "animation" && isInfiniteAnimationSegment(segment)) continue;
-            const firstTimeMatch = segment.match(/(?<![a-zA-Z\d])([\d.]+)(m?s)(?![a-zA-Z\d-])/);
+            const firstTimeMatch = segment.match(FIRST_TIME_TOKEN_PATTERN);
             if (!firstTimeMatch) continue;
             const segmentDurationMs =
               firstTimeMatch[2] === "ms"
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/utils/parse-color-to-rgb.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/utils/parse-color-to-rgb.ts
index a0b4b3acb5..66d765a258 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/utils/parse-color-to-rgb.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/design/utils/parse-color-to-rgb.ts
@@ -38,58 +38,64 @@ export const parseColorToRgb = (value: string): ParsedRgb | null => {
   // (`border-[rgb(229_231_235)]`), so normalize before matching.
   const trimmed = value.trim().toLowerCase().replace(/_/g, " ");
 
-  const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
-  if (hex8Match) {
-    return {
-      red: parseInt(hex8Match[1], 16),
-      green: parseInt(hex8Match[2], 16),
-      blue: parseInt(hex8Match[3], 16),
-    };
-  }
+  if (trimmed.startsWith("#")) {
+    const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
+    if (hex8Match) {
+      return {
+        red: parseInt(hex8Match[1], 16),
+        green: parseInt(hex8Match[2], 16),
+        blue: parseInt(hex8Match[3], 16),
+      };
+    }
 
-  const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
-  if (hex6Match) {
-    return {
-      red: parseInt(hex6Match[1], 16),
-      green: parseInt(hex6Match[2], 16),
-      blue: parseInt(hex6Match[3], 16),
-    };
-  }
+    const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
+    if (hex6Match) {
+      return {
+        red: parseInt(hex6Match[1], 16),
+        green: parseInt(hex6Match[2], 16),
+        blue: parseInt(hex6Match[3], 16),
+      };
+    }
 
-  const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
-  if (hex4Match) {
-    return {
-      red: parseInt(hex4Match[1] + hex4Match[1], 16),
-      green: parseInt(hex4Match[2] + hex4Match[2], 16),
-      blue: parseInt(hex4Match[3] + hex4Match[3], 16),
-    };
-  }
+    const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
+    if (hex4Match) {
+      return {
+        red: parseInt(hex4Match[1] + hex4Match[1], 16),
+        green: parseInt(hex4Match[2] + hex4Match[2], 16),
+        blue: parseInt(hex4Match[3] + hex4Match[3], 16),
+      };
+    }
 
-  const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
-  if (hex3Match) {
-    return {
-      red: parseInt(hex3Match[1] + hex3Match[1], 16),
-      green: parseInt(hex3Match[2] + hex3Match[2], 16),
-      blue: parseInt(hex3Match[3] + hex3Match[3], 16),
-    };
+    const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
+    if (hex3Match) {
+      return {
+        red: parseInt(hex3Match[1] + hex3Match[1], 16),
+        green: parseInt(hex3Match[2] + hex3Match[2], 16),
+        blue: parseInt(hex3Match[3] + hex3Match[3], 16),
+      };
+    }
   }
 
-  const rgbMatch = trimmed.match(/rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/);
-  if (rgbMatch) {
-    return {
-      red: parseInt(rgbMatch[1], 10),
-      green: parseInt(rgbMatch[2], 10),
-      blue: parseInt(rgbMatch[3], 10),
-    };
+  if (trimmed.includes("rgb")) {
+    const rgbMatch = trimmed.match(/rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/);
+    if (rgbMatch) {
+      return {
+        red: parseInt(rgbMatch[1], 10),
+        green: parseInt(rgbMatch[2], 10),
+        blue: parseInt(rgbMatch[3], 10),
+      };
+    }
   }
 
-  const hslMatch = trimmed.match(/hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%/);
-  if (hslMatch) {
-    return convertHslToRgb(
-      parseFloat(hslMatch[1]),
-      parseFloat(hslMatch[2]),
-      parseFloat(hslMatch[3]),
-    );
+  if (trimmed.includes("hsl")) {
+    const hslMatch = trimmed.match(/hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%/);
+    if (hslMatch) {
+      return convertHslToRgb(
+        parseFloat(hslMatch[1]),
+        parseFloat(hslMatch[2]),
+        parseFloat(hslMatch[3]),
+      );
+    }
   }
 
   return null;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/dangerous-html-sink.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/dangerous-html-sink.ts
index 79c101b5dd..4bafeeb4ba 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/dangerous-html-sink.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/dangerous-html-sink.ts
@@ -153,6 +153,12 @@ const getTemplateInterpolations = (valueTail: string): string | null => {
 // catches scratch nodes parsed across a loop (the second write in a reuse loop
 // sits far from its `createElement`).
 const isInertParseTarget = (target: string, fileContent: string): boolean => {
+  // Every inert idiom below requires one of these call names somewhere in the
+  // file — without them no pattern can match, so skip all regex builds/scans.
+  const fileHasCreateElement = fileContent.includes("createElement");
+  const fileHasIsolatedDocument = fileContent.includes("createHTMLDocument");
+  if (!fileHasCreateElement && !fileHasIsolatedDocument) return false;
+
   const escapedTarget = escapeRegExp(target);
   const rootIdentifier = target.split(".")[0] ?? target;
   const escapedRoot = escapeRegExp(rootIdentifier);
@@ -165,26 +171,31 @@ const isInertParseTarget = (target: string, fileContent: string): boolean => {
   );
   if (liveDomSourcePattern.test(fileContent)) return false;
 
-  const templateElementPattern = new RegExp(
-    `${escapedTarget}\\s*=\\s*document\\.createElement\\(\\s*["'\`]template["'\`]`,
-  );
-  if (templateElementPattern.test(fileContent)) return true;
-
-  // A `<style>` element's innerHTML is CSS text (the critical-CSS idiom via the
-  // DOM API, counterpart of the `<style dangerouslySetInnerHTML>` JSX exemption);
-  // a `<textarea>`'s is RCDATA — scripts never execute — which is the HTML-entity
-  // decode idiom (`textarea.innerHTML = x; return textarea.value`). Neither is
-  // executable markup.
-  const inertElementPattern = new RegExp(
-    `${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\(\\s*["'\`](?:style|textarea)["'\`]`,
-  );
-  if (inertElementPattern.test(fileContent)) return true;
+  if (fileHasCreateElement) {
+    const templateElementPattern = new RegExp(
+      `${escapedTarget}\\s*=\\s*document\\.createElement\\(\\s*["'\`]template["'\`]`,
+    );
+    if (templateElementPattern.test(fileContent)) return true;
+
+    // A `<style>` element's innerHTML is CSS text (the critical-CSS idiom via the
+    // DOM API, counterpart of the `<style dangerouslySetInnerHTML>` JSX exemption);
+    // a `<textarea>`'s is RCDATA — scripts never execute — which is the HTML-entity
+    // decode idiom (`textarea.innerHTML = x; return textarea.value`). Neither is
+    // executable markup.
+    const inertElementPattern = new RegExp(
+      `${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\(\\s*["'\`](?:style|textarea)["'\`]`,
+    );
+    if (inertElementPattern.test(fileContent)) return true;
+  }
 
-  const isolatedDocumentPattern = new RegExp(
-    `${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateHTMLDocument\\s*\\(`,
-  );
-  if (isolatedDocumentPattern.test(fileContent)) return true;
+  if (fileHasIsolatedDocument) {
+    const isolatedDocumentPattern = new RegExp(
+      `${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateHTMLDocument\\s*\\(`,
+    );
+    if (isolatedDocumentPattern.test(fileContent)) return true;
+  }
 
+  if (!fileHasCreateElement) return false;
   const createElementPattern = new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\s*\\(`);
   if (!createElementPattern.test(fileContent)) return false;
 
@@ -341,20 +352,16 @@ export const dangerousHtmlSink = defineRule({
             `\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`,
             "i",
           );
+          if (fromSerializer.test(file.content)) continue;
           const fromSanitizer = new RegExp(
             `\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`,
             "i",
           );
+          if (fromSanitizer.test(file.content)) continue;
           const fromDomContent = new RegExp(
             `\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`,
           );
-          if (
-            fromSerializer.test(file.content) ||
-            fromSanitizer.test(file.content) ||
-            fromDomContent.test(file.content)
-          ) {
-            continue;
-          }
+          if (fromDomContent.test(file.content)) continue;
         }
       }
       const sinkTargetMatch = INNERHTML_TARGET_PATTERN.exec(line);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/supabase-table-missing-rls.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/supabase-table-missing-rls.ts
index 0fae019276..ebbe4ba548 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/supabase-table-missing-rls.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/supabase-table-missing-rls.ts
@@ -1,6 +1,5 @@
 import { defineRule } from "../../utils/define-rule.js";
 import type { ScanFinding } from "../../utils/file-scan.js";
-import { escapeRegExp } from "./utils/escape-reg-exp.js";
 import { getLocationAtIndex } from "./utils/get-location-at-index.js";
 import { isSupabaseMigrationPath } from "./utils/is-supabase-migration-path.js";
 import { sanitizeSqlForScan } from "./utils/sanitize-sql-for-scan.js";
@@ -19,11 +18,20 @@ const CREATE_PUBLIC_TABLE_PATTERN =
 // enabled — so RLS must be checked per table rather than file-wide (a sibling
 // table enabling RLS must not vouch for this one). The enable keyword must
 // follow the table name directly so a nearby unrelated `enable` cannot match.
-const enableRlsForTablePattern = (tableName: string): RegExp =>
-  new RegExp(
-    `alter\\s+table\\s+(?:if\\s+exists\\s+)?(?:only\\s+)?(?:public\\s*\\.\\s*)?["\`]?${escapeRegExp(tableName)}["\`]?\\s+(?:force\\s+)?enable\\s+row\\s+level\\s+security`,
-    "i",
-  );
+// One global pass collects every enable's (table, index) pair, replacing a
+// per-created-table RegExp compile + tail slice.
+const ENABLE_RLS_PATTERN =
+  /alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(?:public\s*\.\s*)?["`]?([A-Za-z_][\w$]*)["`]?\s+(?:force\s+)?enable\s+row\s+level\s+security/gi;
+
+const collectLastEnableRlsIndexByTable = (content: string): Map<string, number> => {
+  const lastEnableIndexByTable = new Map<string, number>();
+  for (const match of content.matchAll(ENABLE_RLS_PATTERN)) {
+    const tableName = match[1];
+    if (tableName === undefined) continue;
+    lastEnableIndexByTable.set(tableName.toLowerCase(), match.index);
+  }
+  return lastEnableIndexByTable;
+};
 
 export const supabaseTableMissingRls = defineRule({
   id: "supabase-table-missing-rls",
@@ -44,6 +52,7 @@ export const supabaseTableMissingRls = defineRule({
     if (!/create\s+(?:unlogged\s+)?table/i.test(content)) return [];
 
     const findings: ScanFinding[] = [];
+    const lastEnableIndexByTable = collectLastEnableRlsIndexByTable(content);
     CREATE_PUBLIC_TABLE_PATTERN.lastIndex = 0;
     for (
       let match = CREATE_PUBLIC_TABLE_PATTERN.exec(content);
@@ -54,8 +63,9 @@ export const supabaseTableMissingRls = defineRule({
       if (tableName === undefined) continue;
       // The enable must come AFTER this `create table` — an `alter table if
       // exists <name> enable …` before it is a no-op on a not-yet-created
-      // table, so only scan from the create position onward.
-      if (enableRlsForTablePattern(tableName).test(content.slice(match.index))) continue;
+      // table, so only the latest same-name enable position matters.
+      const lastEnableIndex = lastEnableIndexByTable.get(tableName.toLowerCase());
+      if (lastEnableIndex !== undefined && lastEnableIndex >= match.index) continue;
       const location = getLocationAtIndex(content, match.index);
       findings.push({
         message:
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/find-suspicious-public-env-secret-name.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/find-suspicious-public-env-secret-name.ts
index e3f55f1f51..a93497310b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/find-suspicious-public-env-secret-name.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/find-suspicious-public-env-secret-name.ts
@@ -4,11 +4,18 @@ import {
 } from "../../../constants/security.js";
 import { escapeRegExp } from "./escape-reg-exp.js";
 
+// Compiled once — `matchAll` clones the regex per call, so the shared
+// constant never carries `lastIndex` state between invocations.
+const PUBLIC_ENV_SECRET_NAME_GLOBAL_PATTERN = new RegExp(
+  PUBLIC_ENV_SECRET_NAME_PATTERN.source,
+  "gi",
+);
+
 // Returns a RegExp matching the first suspicious name so callers can
 // locate the finding in the file content; `undefined` when every
 // public-prefixed env name in the content is a trusted/publishable one.
 export const findSuspiciousPublicEnvSecretNamePattern = (content: string): RegExp | undefined => {
-  for (const match of content.matchAll(new RegExp(PUBLIC_ENV_SECRET_NAME_PATTERN.source, "gi"))) {
+  for (const match of content.matchAll(PUBLIC_ENV_SECRET_NAME_GLOBAL_PATTERN)) {
     const value = match[0] ?? "";
     if (!TRUSTED_PUBLIC_SECRET_NAME_PATTERN.test(value)) {
       return new RegExp(escapeRegExp(value));

From ac71a3b8cfc8bdd157f0f1bcd242b61ec69f9c17 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 18:04:20 -0500
Subject: [PATCH 10/33] =?UTF-8?q?perf(plugin):=20fused-walk=20sweep=20?=
 =?UTF-8?q?=E2=80=94=20one=20pass=20where=20several=20walked=20the=20same?=
 =?UTF-8?q?=20subtree=20(#1050)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fuses async-await-in-loop's three loop-body collectors and precomputes its
fixpoint declarator records (#92/#93), merges js-cache-property-access's
write+read walks (#94), memoizes js-index-maps' per-loop bound names
(#104), folds rendering-usetransition-loading's three async-work detectors
into one short-circuiting pass (#139), memoizes display-name's containsJsx
and replaces its per-candidate whole-program displayName scans with a
per-Program index (#147/#148), fuses no-derived-use-state's two exemption
walks (#311), indexes activity-wraps-effect-heavy-subtree's same-file
component bodies per Program (#312), and replaces per-binding component
walks with one-shot setter-call collection in no-event-trigger-state and
rerender-state-only-in-handlers (#318/#336) plus WeakMap memos in
is-controlled-prop-mirror (#357/#358). Skipped as non-mechanical or
behavior-changing: #140 #309 #310 #320 #349. Behavior verified identical
via the 291-diagnostic equivalence corpus.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-sweep-fused-walks.md          |   5 +
 .../js-performance/async-await-in-loop.ts     | 102 +++++++---------
 .../js-cache-property-access.ts               |   4 +-
 .../rules/js-performance/js-index-maps.ts     |  17 ++-
 .../rendering-usetransition-loading.ts        | 111 ++++++------------
 .../rules/react-builtins/display-name.ts      |  88 +++++++-------
 .../activity-wraps-effect-heavy-subtree.ts    |  68 +++++++----
 .../state-and-effects/no-derived-use-state.ts |  81 +++++--------
 .../no-event-trigger-state.ts                 |  34 ++++--
 .../rerender-state-only-in-handlers.ts        |  27 +++--
 .../utils/is-controlled-prop-mirror.ts        |  35 ++++--
 11 files changed, 277 insertions(+), 295 deletions(-)
 create mode 100644 .changeset/perf-sweep-fused-walks.md

diff --git a/.changeset/perf-sweep-fused-walks.md b/.changeset/perf-sweep-fused-walks.md
new file mode 100644
index 0000000000..6f6f15d742
--- /dev/null
+++ b/.changeset/perf-sweep-fused-walks.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: fused-walk sweep — ~13 repeated subtree traversals collapse into single passes or per-node memos (async-await-in-loop's triple walk and fixpoint pre-pass, js-cache/js-index-maps loop walks, rendering-usetransition's three detectors, display-name's per-candidate program scans, per-binding setter walks in the state/effect rules, and WeakMap memos for prop-name/bound-name/effect-count analyses)
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/async-await-in-loop.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/async-await-in-loop.ts
index 4a304ae769..36c5a3af4e 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/async-await-in-loop.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/async-await-in-loop.ts
@@ -77,76 +77,37 @@ const collectPatternIdentifiers = (pattern: EsTreeNode, target: Set<string>): vo
   }
 };
 
-const collectAssignedIdentifiers = (block: EsTreeNode): Set<string> => {
-  const assigned = new Set<string>();
-  walkAst(block, (child: EsTreeNode): boolean | void => {
-    if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration"))
-      return false;
-    if (isNodeOfType(child, "AssignmentExpression") && child.left) {
-      collectPatternIdentifiers(child.left, assigned);
-    }
-  });
-  return assigned;
-};
-
-const collectAwaitedArgIdentifiers = (block: EsTreeNode): Set<string> => {
-  const referenced = new Set<string>();
-  walkAst(block, (child: EsTreeNode): boolean | void => {
-    if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration"))
-      return false;
-    if (!isNodeOfType(child, "AwaitExpression") || !child.argument) return;
-    collectReferenceIdentifierNames(child.argument, referenced);
-  });
-  return referenced;
-};
-
 const ARRAY_MUTATION_METHOD_NAMES = new Set(["push", "unshift", "splice"]);
 
-// Arrays mutated in-place (`results.push(...)`, `acc.unshift(...)`) carry
-// state across iterations just like a reassigned variable. Collect the
-// mutated object's name so a later iteration reading from it counts as a
-// loop-carried dependency.
-const collectMutatedArrayNames = (block: EsTreeNode): Set<string> => {
-  const mutated = new Set<string>();
-  walkAst(block, (child: EsTreeNode): boolean | void => {
-    if (child !== block && isFunctionLike(child)) return false;
-    if (!isNodeOfType(child, "CallExpression")) return;
-    const callee = child.callee;
-    if (
-      isNodeOfType(callee, "MemberExpression") &&
-      !callee.computed &&
-      isNodeOfType(callee.property, "Identifier") &&
-      ARRAY_MUTATION_METHOD_NAMES.has(callee.property.name) &&
-      isNodeOfType(callee.object, "Identifier")
-    ) {
-      mutated.add(callee.object.name);
-    }
-  });
-  return mutated;
-};
-
 // Variables initialized by reading any of `names` (e.g.
 // `const prev = results[results.length - 1]`) carry the mutated array's
 // state forward, so awaiting on them is also order-dependent. Iterated to
-// a fixpoint to follow multi-step derivations.
+// a fixpoint to follow multi-step derivations. The declarators and their
+// referenced names never change between passes, so they are collected in
+// one walk and only the membership test repeats per round.
 const addDerivedBindings = (block: EsTreeNode, names: Set<string>): void => {
+  const declaratorBindings: Array<{ declaredName: string; referencedNames: Set<string> }> = [];
+  walkAst(block, (child: EsTreeNode): boolean | void => {
+    if (child !== block && isFunctionLike(child)) return false;
+    if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
+    if (!isNodeOfType(child.id, "Identifier")) return;
+    const referencedNames = new Set<string>();
+    collectReferenceIdentifierNames(child.init, referencedNames);
+    declaratorBindings.push({ declaredName: child.id.name, referencedNames });
+  });
   let didGrow = true;
   while (didGrow) {
     didGrow = false;
-    walkAst(block, (child: EsTreeNode): boolean | void => {
-      if (child !== block && isFunctionLike(child)) return false;
-      if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
-      if (!isNodeOfType(child.id, "Identifier") || names.has(child.id.name)) return;
-      const initReferences = new Set<string>();
-      collectReferenceIdentifierNames(child.init, initReferences);
-      for (const referenced of initReferences) {
+    for (const { declaredName, referencedNames } of declaratorBindings) {
+      if (names.has(declaredName)) continue;
+      for (const referenced of referencedNames) {
         if (names.has(referenced)) {
-          names.add(child.id.name);
+          names.add(declaredName);
           didGrow = true;
           break;
         }
       }
-    });
+    }
   }
 };
 
@@ -156,12 +117,35 @@ const addDerivedBindings = (block: EsTreeNode, names: Set<string>): void => {
 // covers carries that flow through an in-place array mutation
 // (`results.push(await fetchNext(id, prev))` with `prev` read from
 // `results`): the awaited argument reads a binding the loop mutates.
+// Assignments, in-place array mutations, and awaited-argument reads inspect
+// disjoint node types, so one walk collects all three signal sets.
 const hasLoopCarriedDependency = (block: EsTreeNode): boolean => {
-  const carried = collectAssignedIdentifiers(block);
-  for (const name of collectMutatedArrayNames(block)) carried.add(name);
+  const carried = new Set<string>();
+  const awaitedReferences = new Set<string>();
+  walkAst(block, (child: EsTreeNode): boolean | void => {
+    if (child !== block && isFunctionLike(child)) return false;
+    if (isNodeOfType(child, "AssignmentExpression") && child.left) {
+      collectPatternIdentifiers(child.left, carried);
+      return;
+    }
+    if (isNodeOfType(child, "AwaitExpression") && child.argument) {
+      collectReferenceIdentifierNames(child.argument, awaitedReferences);
+      return;
+    }
+    if (!isNodeOfType(child, "CallExpression")) return;
+    const callee = child.callee;
+    if (
+      isNodeOfType(callee, "MemberExpression") &&
+      !callee.computed &&
+      isNodeOfType(callee.property, "Identifier") &&
+      ARRAY_MUTATION_METHOD_NAMES.has(callee.property.name) &&
+      isNodeOfType(callee.object, "Identifier")
+    ) {
+      carried.add(callee.object.name);
+    }
+  });
   if (carried.size === 0) return false;
   addDerivedBindings(block, carried);
-  const awaitedReferences = collectAwaitedArgIdentifiers(block);
   for (const name of carried) {
     if (awaitedReferences.has(name)) return true;
   }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-cache-property-access.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-cache-property-access.ts
index 9dd05f3567..f7d63a923a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-cache-property-access.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-cache-property-access.ts
@@ -78,11 +78,11 @@ export const jsCachePropertyAccess = defineRule({
         if (isNameShadowedByEnclosingFunctionParameter(writeTarget, rootName, loopBody)) return;
         writtenAccessPrefixes.add(writtenKey);
       };
+      // Write targets and read counts inspect disjoint node types, and the
+      // write-prefix set is only consulted after the walk — one pass fills both.
       walkAst(loopBody, (child: EsTreeNode) => {
         if (isNodeOfType(child, "AssignmentExpression")) recordWriteTarget(child.left);
         if (isNodeOfType(child, "UpdateExpression")) recordWriteTarget(child.argument);
-      });
-      walkAst(loopBody, (child: EsTreeNode) => {
         if (!isNodeOfType(child, "MemberExpression")) return;
         if (child.computed) return;
         // Skip if this MemberExpression is itself nested inside another (only
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-index-maps.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-index-maps.ts
index 8bbfd3b4ba..73d6a2a517 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-index-maps.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/js-performance/js-index-maps.ts
@@ -64,8 +64,15 @@ const isSingleFieldEqualityPredicate = (node: EsTreeNodeOfType<"CallExpression">
 // inside the loop body. When the `.find()` receiver roots at one of
 // these, the receiver is a different array each pass, so a single
 // pre-loop Map can't replace it — flagging it would be a false
-// positive.
-const collectLoopBoundNames = (loop: EsTreeNode, names: Set<string>): void => {
+// positive. The set is a pure function of the (immutable) loop subtree, so
+// it is memoized per loop node — nested `.find()`s under the same loops
+// reuse one walk instead of re-collecting per call site.
+const loopBoundNamesCache = new WeakMap<EsTreeNode, ReadonlySet<string>>();
+
+const getLoopBoundNames = (loop: EsTreeNode): ReadonlySet<string> => {
+  const cached = loopBoundNamesCache.get(loop);
+  if (cached) return cached;
+  const names = new Set<string>();
   if ((isNodeOfType(loop, "ForOfStatement") || isNodeOfType(loop, "ForInStatement")) && loop.left) {
     walkAst(loop.left, (child: EsTreeNode) => {
       if (isNodeOfType(child, "Identifier")) names.add(child.name);
@@ -88,6 +95,8 @@ const collectLoopBoundNames = (loop: EsTreeNode, names: Set<string>): void => {
       if (targetRoot) names.add(targetRoot);
     }
   });
+  loopBoundNamesCache.set(loop, names);
+  return names;
 };
 
 // `groups[i].links.find(...)` — the chain roots at an invariant name,
@@ -126,7 +135,9 @@ const isLoopVariantReceiver = (node: EsTreeNodeOfType<"CallExpression">): boolea
   const loopBoundNames = new Set<string>();
   let ancestor: EsTreeNode | null | undefined = node.parent;
   while (ancestor) {
-    if (LOOP_TYPES.includes(ancestor.type)) collectLoopBoundNames(ancestor, loopBoundNames);
+    if (LOOP_TYPES.includes(ancestor.type)) {
+      for (const name of getLoopBoundNames(ancestor)) loopBoundNames.add(name);
+    }
     ancestor = ancestor.parent;
   }
   if (loopBoundNames.has(receiverRoot)) return true;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-usetransition-loading.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-usetransition-loading.ts
index b51dfe832d..8faf37d59d 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-usetransition-loading.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-usetransition-loading.ts
@@ -61,65 +61,8 @@ const callsIdentifier = (root: EsTreeNode | null, identifierName: string): boole
   return found;
 };
 
-// True when ANY async-context function inside `componentBody` calls
-// `setterName`. An "async-context function" is `async` or has an own-
-// scope `await`. Setter calls inside non-async helpers (e.g. a sync
-// `handleTabChange` that toggles `setIsTabPending`) don't count, so a
-// sync state transition in a component that ALSO has an unrelated
-// `handleSubmit = async () => …` no longer gets suppressed.
-const setterIsCalledInAsyncContext = (
-  componentBody: EsTreeNode | null,
-  setterName: string,
-): boolean => {
-  if (!componentBody) return false;
-  let found = false;
-  walkAst(componentBody, (child: EsTreeNode) => {
-    if (found) return;
-    if (!isFunctionLike(child)) return;
-    const functionBody = (child as { body: EsTreeNode | null }).body;
-    const isAsyncContext =
-      Boolean((child as { async?: boolean }).async) || hasOwnAwait(functionBody);
-    if (!isAsyncContext) return;
-    if (callsIdentifier(functionBody, setterName)) found = true;
-  });
-  return found;
-};
-
 const PROMISE_CHAIN_METHOD_NAMES: ReadonlySet<string> = new Set(["then", "catch", "finally"]);
 
-// True when `setterName` is called inside a Promise-chain callback
-// (`loadData().then(() => setIsLoading(false))`). That flag tracks real
-// async I/O the same way an `async`/`await` setter does, so `useTransition`
-// (which only deprioritizes sync state updates, it doesn't await a promise)
-// is not a substitute.
-const setterIsCalledInPromiseChain = (
-  componentBody: EsTreeNode | null,
-  setterName: string,
-): boolean => {
-  if (!componentBody) return false;
-  let found = false;
-  walkAst(componentBody, (child: EsTreeNode) => {
-    if (found) return;
-    if (!isNodeOfType(child, "CallExpression")) return;
-    const callee = child.callee;
-    if (
-      !isNodeOfType(callee, "MemberExpression") ||
-      !isNodeOfType(callee.property, "Identifier") ||
-      !PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)
-    ) {
-      return;
-    }
-    for (const argument of child.arguments ?? []) {
-      if (!isFunctionLike(argument)) continue;
-      if (callsIdentifier(argument.body, setterName)) {
-        found = true;
-        return;
-      }
-    }
-  });
-  return found;
-};
-
 // Identifiers that, when present alongside a loading useState, strongly
 // signal async data fetching (not a transition). The rule's
 // recommendation to use `useTransition` only applies to UI-state-only
@@ -138,24 +81,47 @@ const ASYNC_DATA_CALLEE_NAMES: ReadonlySet<string> = new Set([
   "axios",
 ]);
 
-const referencesAsyncDataApi = (body: EsTreeNode | null): boolean => {
-  if (!body) return false;
+// One pass over the component body computes every async-work signal the
+// caller ORs together, short-circuiting on the first hit:
+//   - `setterName` called inside an async-context function ("async" or an
+//     own-scope `await`) — a sync helper toggling the flag doesn't count.
+//   - `setterName` called inside a Promise-chain callback
+//     (`loadData().then(() => setIsLoading(false))`).
+//   - a call to a known async-data hook / global anywhere in the body.
+const hasAsyncLoadingWork = (fnBody: EsTreeNode, setterName: string | null): boolean => {
   let found = false;
-  walkAst(body, (child: EsTreeNode) => {
-    if (found) return;
+  walkAst(fnBody, (child: EsTreeNode) => {
+    if (found) return false;
     if (isNodeOfType(child, "CallExpression")) {
       const callee = child.callee;
       if (isNodeOfType(callee, "Identifier") && ASYNC_DATA_CALLEE_NAMES.has(callee.name)) {
         found = true;
-        return;
+        return false;
+      }
+      if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+        if (ASYNC_DATA_CALLEE_NAMES.has(callee.property.name)) {
+          found = true;
+          return false;
+        }
+        if (setterName !== null && PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)) {
+          for (const argument of child.arguments ?? []) {
+            if (!isFunctionLike(argument)) continue;
+            if (callsIdentifier(argument.body, setterName)) {
+              found = true;
+              return false;
+            }
+          }
+        }
       }
-      if (
-        isNodeOfType(callee, "MemberExpression") &&
-        isNodeOfType(callee.property, "Identifier") &&
-        ASYNC_DATA_CALLEE_NAMES.has(callee.property.name)
-      ) {
+      return;
+    }
+    if (setterName !== null && isFunctionLike(child)) {
+      const functionBody = (child as { body: EsTreeNode | null }).body;
+      const isAsyncContext =
+        Boolean((child as { async?: boolean }).async) || hasOwnAwait(functionBody);
+      if (isAsyncContext && callsIdentifier(functionBody, setterName)) {
         found = true;
-        return;
+        return false;
       }
     }
   });
@@ -192,14 +158,7 @@ export const renderingUsetransitionLoading = defineRule({
       // flag is wrapping that async work) OR a call to a known
       // async-data hook / global in the component body.
       const fnBody = enclosingFunctionBody(node as EsTreeNode);
-      if (
-        fnBody &&
-        ((setterName && setterIsCalledInAsyncContext(fnBody, setterName)) ||
-          (setterName && setterIsCalledInPromiseChain(fnBody, setterName)) ||
-          referencesAsyncDataApi(fnBody))
-      ) {
-        return;
-      }
+      if (fnBody && hasAsyncLoadingWork(fnBody, setterName)) return;
 
       context.report({
         node: node.init,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts
index a3030ac105..442ac3490b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts
@@ -58,7 +58,13 @@ const isReactVersionAtLeast = (version: string, major: number, minor: number): b
   return actualMajor > major || (actualMajor === major && actualMinor >= minor);
 };
 
+// Memoized per (immutable) subtree root — nested candidates re-query the
+// same regions from several visitors, so each subtree is walked once.
+const containsJsxCache = new WeakMap<EsTreeNode, boolean>();
+
 const containsJsx = (root: EsTreeNode): boolean => {
+  const cached = containsJsxCache.get(root);
+  if (cached !== undefined) return cached;
   let found = false;
   const visit = (node: EsTreeNode): void => {
     if (found) return;
@@ -83,6 +89,7 @@ const containsJsx = (root: EsTreeNode): boolean => {
     }
   };
   visit(root);
+  containsJsxCache.set(root, found);
   return found;
 };
 
@@ -269,39 +276,6 @@ const hasDisplayNameMember = (classNode: EsTreeNode): boolean => {
   return false;
 };
 
-// Looks for a `<ClassName>.displayName = ...` assignment ANYWHERE in
-// the program. Transpiler output and most React codebases attach
-// display names this way for non-anonymous classes/functions.
-const hasDisplayNameAssignment = (className: string, programRoot: EsTreeNode): boolean => {
-  let found = false;
-  const visit = (node: EsTreeNode): void => {
-    if (found) return;
-    if (
-      isNodeOfType(node, "AssignmentExpression") &&
-      isNodeOfType(node.left, "MemberExpression") &&
-      isNodeOfType(node.left.object, "Identifier") &&
-      node.left.object.name === className &&
-      getStaticMemberName(node.left) === "displayName"
-    ) {
-      found = true;
-      return;
-    }
-    const record = node as unknown as Record<string, unknown>;
-    for (const key of Object.keys(record)) {
-      if (key === "parent") continue;
-      const child = record[key];
-      if (Array.isArray(child)) {
-        for (const item of child) if (isAstNode(item)) visit(item);
-      } else if (isAstNode(child)) {
-        visit(child);
-      }
-      if (found) return;
-    }
-  };
-  visit(programRoot);
-  return found;
-};
-
 const memberExpressionPath = (node: EsTreeNode): ReadonlyArray<string> => {
   if (isNodeOfType(node, "Identifier")) return [node.name];
   if (!isNodeOfType(node, "MemberExpression")) return [];
@@ -310,22 +284,34 @@ const memberExpressionPath = (node: EsTreeNode): ReadonlyArray<string> => {
   return propertyName ? [...objectPath, propertyName] : objectPath;
 };
 
-const hasDisplayNameAssignmentForProperty = (
-  propertyName: string,
-  programRoot: EsTreeNode,
-): boolean => {
-  let found = false;
+interface DisplayNameAssignmentIndex {
+  // `X.displayName = …` targets where `X` is a plain identifier.
+  identifierTargets: ReadonlySet<string>;
+  // Every static path segment of every `….displayName = …` target object
+  // (`Foo.Bar.displayName = …` contributes both `Foo` and `Bar`).
+  memberPathSegments: ReadonlySet<string>;
+}
+
+// One program walk indexes every `<target>.displayName = …` assignment so
+// each candidate answers with a Set lookup instead of re-walking the file.
+const displayNameAssignmentIndexCache = new WeakMap<EsTreeNode, DisplayNameAssignmentIndex>();
+
+const getDisplayNameAssignmentIndex = (programRoot: EsTreeNode): DisplayNameAssignmentIndex => {
+  const cached = displayNameAssignmentIndexCache.get(programRoot);
+  if (cached) return cached;
+  const identifierTargets = new Set<string>();
+  const memberPathSegments = new Set<string>();
   const visit = (node: EsTreeNode): void => {
-    if (found) return;
     if (
       isNodeOfType(node, "AssignmentExpression") &&
       isNodeOfType(node.left, "MemberExpression") &&
       getStaticMemberName(node.left) === "displayName"
     ) {
-      const objectPath = memberExpressionPath(node.left.object);
-      if (objectPath.includes(propertyName)) {
-        found = true;
-        return;
+      if (isNodeOfType(node.left.object, "Identifier")) {
+        identifierTargets.add(node.left.object.name);
+      }
+      for (const segment of memberExpressionPath(node.left.object)) {
+        memberPathSegments.add(segment);
       }
     }
     const record = node as unknown as Record<string, unknown>;
@@ -337,13 +323,25 @@ const hasDisplayNameAssignmentForProperty = (
       } else if (isAstNode(child)) {
         visit(child);
       }
-      if (found) return;
     }
   };
   visit(programRoot);
-  return found;
+  const index: DisplayNameAssignmentIndex = { identifierTargets, memberPathSegments };
+  displayNameAssignmentIndexCache.set(programRoot, index);
+  return index;
 };
 
+// Looks for a `<ClassName>.displayName = ...` assignment ANYWHERE in
+// the program. Transpiler output and most React codebases attach
+// display names this way for non-anonymous classes/functions.
+const hasDisplayNameAssignment = (className: string, programRoot: EsTreeNode): boolean =>
+  getDisplayNameAssignmentIndex(programRoot).identifierTargets.has(className);
+
+const hasDisplayNameAssignmentForProperty = (
+  propertyName: string,
+  programRoot: EsTreeNode,
+): boolean => getDisplayNameAssignmentIndex(programRoot).memberPathSegments.has(propertyName);
+
 // Port of `oxc_linter::rules::react::display_name`. Reports React
 // components whose displayName is unknown to React DevTools — most
 // often anonymous function expressions assigned to `module.exports` /
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts
index 6db1fe9009..e42f20dd6f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts
@@ -56,42 +56,66 @@ const collectChildComponentNames = (
   });
 };
 
-const findSameFileComponentBody = (
-  programRoot: EsTreeNode,
-  componentName: string,
-): EsTreeNode | null => {
-  let foundBody: EsTreeNode | null = null;
+const countEffectHookCalls = (body: EsTreeNode | null): number => {
+  if (!body) return 0;
+  let count = 0;
+  walkAst(body, (child: EsTreeNode) => {
+    if (!isNodeOfType(child, "CallExpression")) return;
+    if (isHookCall(child, EFFECT_HOOK_NAMES)) count++;
+  });
+  return count;
+};
+
+interface ComponentEffectIndex {
+  // First (pre-order) same-file function body per name — the same body a
+  // fresh first-match program walk would resolve.
+  bodyByName: Map<string, EsTreeNode>;
+  // Effect-hook counts, filled lazily per queried component.
+  effectCountByName: Map<string, number>;
+}
+
+// One program walk indexes every named function body; each Activity child
+// then costs a Map lookup plus one lazily-cached body count, instead of a
+// full program walk per child name per Activity element.
+const componentEffectIndexCache = new WeakMap<EsTreeNode, ComponentEffectIndex>();
+
+const getComponentEffectIndex = (programRoot: EsTreeNode): ComponentEffectIndex => {
+  const cached = componentEffectIndexCache.get(programRoot);
+  if (cached) return cached;
+  const bodyByName = new Map<string, EsTreeNode>();
   walkAst(programRoot, (node: EsTreeNode) => {
-    if (foundBody) return false;
-    if (isNodeOfType(node, "FunctionDeclaration") && node.id && node.id.name === componentName) {
-      foundBody = node.body;
-      return false;
+    if (isNodeOfType(node, "FunctionDeclaration") && node.id && !bodyByName.has(node.id.name)) {
+      bodyByName.set(node.id.name, node.body);
+      return;
     }
     if (
       isNodeOfType(node, "VariableDeclarator") &&
       isNodeOfType(node.id, "Identifier") &&
-      node.id.name === componentName
+      !bodyByName.has(node.id.name)
     ) {
       const initializer = node.init;
       if (
         isNodeOfType(initializer, "ArrowFunctionExpression") ||
         isNodeOfType(initializer, "FunctionExpression")
       ) {
-        foundBody = initializer.body;
-        return false;
+        bodyByName.set(node.id.name, initializer.body);
       }
     }
   });
-  return foundBody;
+  const index: ComponentEffectIndex = { bodyByName, effectCountByName: new Map() };
+  componentEffectIndexCache.set(programRoot, index);
+  return index;
 };
 
-const countEffectHookCalls = (body: EsTreeNode | null): number => {
-  if (!body) return 0;
-  let count = 0;
-  walkAst(body, (child: EsTreeNode) => {
-    if (!isNodeOfType(child, "CallExpression")) return;
-    if (isHookCall(child, EFFECT_HOOK_NAMES)) count++;
-  });
+const getSameFileComponentEffectCount = (
+  programRoot: EsTreeNode,
+  componentName: string,
+): number => {
+  const index = getComponentEffectIndex(programRoot);
+  const cachedCount = index.effectCountByName.get(componentName);
+  if (cachedCount !== undefined) return cachedCount;
+  const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null);
+  index.effectCountByName.set(componentName, count);
   return count;
 };
 
@@ -192,9 +216,7 @@ export const activityWrapsEffectHeavySubtree = defineRule({
         let totalEffects = 0;
         const effectfulChildren: string[] = [];
         for (const componentName of childComponentNames) {
-          const body = findSameFileComponentBody(programRoot, componentName);
-          if (!body) continue;
-          const effectCount = countEffectHookCalls(body);
+          const effectCount = getSameFileComponentEffectCount(programRoot, componentName);
           if (effectCount === 0) continue;
           totalEffects += effectCount;
           effectfulChildren.push(`<${componentName}>`);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-use-state.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-use-state.ts
index 1adc898e0d..3d0a31d85b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-use-state.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-use-state.ts
@@ -63,48 +63,30 @@ const isHandlerShapedReseed = (setterCall: EsTreeNode, componentFunction: EsTree
   return hasNestedFunction;
 };
 
-// An editable draft buffer re-seeds itself from the prop inside an event
-// handler (e.g. `edit = () => setTitle(props.title)` on entering rename
-// mode) and commits via a callback — the prop stays the source of truth for
-// display, so `useState(prop)` holds intentional decoupled user-edit text,
-// not a stale mirror. The re-seed must live in a NESTED handler: a re-seed in
-// the render body is the adjust-state-during-render pattern, and a re-seed in
-// an effect (built-in or custom wrapper) or a memo is the genuine prop
-// mirror — neither is a draft.
-const isReseededDraftBuffer = (
-  useStateCall: EsTreeNodeOfType<"CallExpression">,
-  isPropName: IsPropNameFn,
-): boolean => {
-  const setterName = getStateSetterName(useStateCall);
-  if (!setterName) return false;
-  const componentFunction = findEnclosingFunction(useStateCall);
-  if (!componentFunction) return false;
-
-  let isReseeded = false;
-  walkAst(componentFunction, (child) => {
-    if (isReseeded) return false;
-    if (
-      isNodeOfType(child, "CallExpression") &&
-      isNodeOfType(child.callee, "Identifier") &&
-      child.callee.name === setterName &&
-      isPropDerivedArgument(child.arguments?.[0], isPropName) &&
-      isHandlerShapedReseed(child, componentFunction)
-    ) {
-      isReseeded = true;
-      return false;
-    }
-  });
-  return isReseeded;
+// True when no function boundary sits between `node` and the component —
+// i.e. the call runs during render, not inside a nested handler/callback.
+const isInRenderScope = (node: EsTreeNode, componentFunction: EsTreeNode): boolean => {
+  let cursor: EsTreeNode | null = node.parent ?? null;
+  while (cursor && cursor !== componentFunction) {
+    if (isFunctionLike(cursor)) return false;
+    cursor = cursor.parent ?? null;
+  }
+  return true;
 };
 
-// The "store information from previous renders" pattern seeds `useState`
-// from a prop and re-syncs it during render (`if (prop !== prev)
-// setPrev(prop)`), so the value is never stale — it tracks the prop every
-// render. React endorses this over a mirroring effect, so it must not be
-// reported as a stale copy. The render-phase call must pass a prop-derived
-// argument: a render-phase reset to an unrelated constant leaves the stale
-// prop copy in place and keeps the report.
-const isAdjustedDuringRender = (
+// Two exemptions, one walk (they look for the same prop-derived setter call
+// and differ only in where it sits):
+//   - Draft buffer: the re-seed lives in a NESTED handler (e.g.
+//     `edit = () => setTitle(props.title)` on entering rename mode) and
+//     commits via a callback — the prop stays the source of truth, so
+//     `useState(prop)` holds intentional decoupled user-edit text, not a
+//     stale mirror. A re-seed in an effect or memo is a genuine mirror.
+//   - Adjust-during-render: the "store information from previous renders"
+//     pattern re-syncs during render (`if (prop !== prev) setPrev(prop)`), so
+//     the value is never stale. React endorses this over a mirroring effect.
+//     The render-phase call must pass a prop-derived argument: a render-phase
+//     reset to an unrelated constant leaves the stale copy and keeps the report.
+const isDraftReseedOrRenderAdjusted = (
   useStateCall: EsTreeNodeOfType<"CallExpression">,
   isPropName: IsPropNameFn,
 ): boolean => {
@@ -112,21 +94,22 @@ const isAdjustedDuringRender = (
   if (!setterName) return false;
   const componentFunction = findEnclosingFunction(useStateCall);
   if (!componentFunction) return false;
-  let isAdjusted = false;
+
+  let isExempt = false;
   walkAst(componentFunction, (child) => {
-    if (isAdjusted) return false;
-    if (child !== componentFunction && isFunctionLike(child)) return false;
+    if (isExempt) return false;
     if (
       isNodeOfType(child, "CallExpression") &&
       isNodeOfType(child.callee, "Identifier") &&
       child.callee.name === setterName &&
-      isPropDerivedArgument(child.arguments?.[0], isPropName)
+      isPropDerivedArgument(child.arguments?.[0], isPropName) &&
+      (isHandlerShapedReseed(child, componentFunction) || isInRenderScope(child, componentFunction))
     ) {
-      isAdjusted = true;
+      isExempt = true;
       return false;
     }
   });
-  return isAdjusted;
+  return isExempt;
 };
 
 export const noDerivedUseState = defineRule({
@@ -150,8 +133,7 @@ export const noDerivedUseState = defineRule({
           propStackTracker.isPropName(initializer.name)
         ) {
           if (isInitialOnlyPropName(initializer.name)) return;
-          if (isReseededDraftBuffer(node, propStackTracker.isPropName)) return;
-          if (isAdjustedDuringRender(node, propStackTracker.isPropName)) return;
+          if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
           context.report({
             node,
             message: `Your users see a stale value when prop "${initializer.name}" changes because useState copies it once.`,
@@ -170,8 +152,7 @@ export const noDerivedUseState = defineRule({
             ) {
               return;
             }
-            if (isReseededDraftBuffer(node, propStackTracker.isPropName)) return;
-            if (isAdjustedDuringRender(node, propStackTracker.isPropName)) return;
+            if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
             context.report({
               node,
               message: `Your users see a stale value when prop "${rootIdentifierName}" changes because useState copies it once.`,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-event-trigger-state.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-event-trigger-state.ts
index 8ce85c7d78..2e5bb1fbf1 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-event-trigger-state.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-event-trigger-state.ts
@@ -92,21 +92,29 @@ const collectHandlerOnlyWriteStateNames = (
   useStateBindings: Array<{ valueName: string; setterName: string; declarator: EsTreeNode }>,
   handlerBindingNames: Set<string>,
 ): Set<string> => {
+  // One walk records, per setter name, whether any call exists and whether
+  // any of them sits outside an event handler — replacing a full body walk
+  // per useState binding.
+  const setterNames = new Set(useStateBindings.map((binding) => binding.setterName));
+  const settersWithAnyCall = new Set<string>();
+  const settersWithNonHandlerCall = new Set<string>();
+  walkAst(componentBody, (child: EsTreeNode) => {
+    if (!isNodeOfType(child, "CallExpression")) return;
+    if (!isNodeOfType(child.callee, "Identifier")) return;
+    const setterName = child.callee.name;
+    if (!setterNames.has(setterName)) return;
+    settersWithAnyCall.add(setterName);
+    if (settersWithNonHandlerCall.has(setterName)) return;
+    if (!isInsideEventHandler(child, handlerBindingNames)) {
+      settersWithNonHandlerCall.add(setterName);
+    }
+  });
   const handlerOnlyWriteStateNames = new Set<string>();
   for (const binding of useStateBindings) {
-    let didFindAnySetterCall = false;
-    let areAllSetterCallsInHandlers = true;
-    walkAst(componentBody, (child: EsTreeNode) => {
-      if (!areAllSetterCallsInHandlers) return false;
-      if (!isNodeOfType(child, "CallExpression")) return;
-      if (!isNodeOfType(child.callee, "Identifier")) return;
-      if (child.callee.name !== binding.setterName) return;
-      didFindAnySetterCall = true;
-      if (!isInsideEventHandler(child, handlerBindingNames)) {
-        areAllSetterCallsInHandlers = false;
-      }
-    });
-    if (didFindAnySetterCall && areAllSetterCallsInHandlers) {
+    if (
+      settersWithAnyCall.has(binding.setterName) &&
+      !settersWithNonHandlerCall.has(binding.setterName)
+    ) {
       handlerOnlyWriteStateNames.add(binding.valueName);
     }
   }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/rerender-state-only-in-handlers.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/rerender-state-only-in-handlers.ts
index a89942b7e0..4d430cf349 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/rerender-state-only-in-handlers.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/rerender-state-only-in-handlers.ts
@@ -169,6 +169,20 @@ export const rerenderStateOnlyInHandlers = defineRule({
         renderReachableNames.add(reachableName);
       }
 
+      // One walk records which setters are called at all, replacing a full
+      // component-body walk per binding.
+      const setterNames = new Set(bindings.map((binding) => binding.setterName));
+      const calledSetterNames = new Set<string>();
+      walkAst(componentBody, (child: EsTreeNode) => {
+        if (
+          isNodeOfType(child, "CallExpression") &&
+          isNodeOfType(child.callee, "Identifier") &&
+          setterNames.has(child.callee.name)
+        ) {
+          calledSetterNames.add(child.callee.name);
+        }
+      });
+
       for (const binding of bindings) {
         if (renderReachableNames.has(binding.valueName)) continue;
         // Underscore-only or underscore-prefixed value names signal
@@ -192,18 +206,7 @@ export const rerenderStateOnlyInHandlers = defineRule({
           continue;
         }
 
-        let setterCalled = false;
-        walkAst(componentBody, (child: EsTreeNode) => {
-          if (setterCalled) return;
-          if (
-            isNodeOfType(child, "CallExpression") &&
-            isNodeOfType(child.callee, "Identifier") &&
-            child.callee.name === binding.setterName
-          ) {
-            setterCalled = true;
-          }
-        });
-        if (!setterCalled) continue;
+        if (!calledSetterNames.has(binding.setterName)) continue;
 
         // The "store information from previous renders" pattern reads the
         // value in a render-phase guard (`if (value !== prevValue)`) and
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
index 39feac3a55..6952b6a864 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
@@ -7,7 +7,14 @@ import { isNodeOfType } from "../../../utils/is-node-of-type.js";
 import { walkAst } from "../../../utils/walk-ast.js";
 import { isEventHandlerName } from "./event-handler-reference.js";
 
-const collectComponentPropNames = (componentFunction: EsTreeNode): Set<string> => {
+// Memoized per component function node — the prop-name set is a pure
+// function of the (immutable) subtree, and every isControlledPropMirror
+// query for the same component recomputes it otherwise.
+const componentPropNamesCache = new WeakMap<EsTreeNode, ReadonlySet<string>>();
+
+const collectComponentPropNames = (componentFunction: EsTreeNode): ReadonlySet<string> => {
+  const cached = componentPropNamesCache.get(componentFunction);
+  if (cached) return cached;
   const propNames = new Set<string>();
   if (!isFunctionLike(componentFunction)) return propNames;
   const propsObjectParamNames = new Set<string>();
@@ -28,31 +35,35 @@ const collectComponentPropNames = (componentFunction: EsTreeNode): Set<string> =
       collectPatternNames(child.id, propNames);
     }
   });
+  componentPropNamesCache.set(componentFunction, propNames);
   return propNames;
 };
 
-const declaresBindingNamed = (functionNode: EsTreeNode, bindingName: string): boolean => {
+// Own-scope bound names (params + non-nested declarators) per function node,
+// memoized so the repeated "does this nested function declare X" checks are
+// a Set lookup instead of a fresh subtree walk each time.
+const ownScopeBoundNamesCache = new WeakMap<EsTreeNode, ReadonlySet<string>>();
+
+const getOwnScopeBoundNames = (functionNode: EsTreeNode): ReadonlySet<string> => {
+  const cached = ownScopeBoundNamesCache.get(functionNode);
+  if (cached) return cached;
   const boundNames = new Set<string>();
   if (isFunctionLike(functionNode)) {
     for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
   }
-  if (boundNames.has(bindingName)) return true;
-  let declaresName = false;
   walkAst(functionNode, (child: EsTreeNode): boolean | void => {
-    if (declaresName) return false;
     if (child !== functionNode && isFunctionLike(child)) return false;
     if (isNodeOfType(child, "VariableDeclarator")) {
-      const declaratorNames = new Set<string>();
-      collectPatternNames(child.id, declaratorNames);
-      if (declaratorNames.has(bindingName)) {
-        declaresName = true;
-        return false;
-      }
+      collectPatternNames(child.id, boundNames);
     }
   });
-  return declaresName;
+  ownScopeBoundNamesCache.set(functionNode, boundNames);
+  return boundNames;
 };
 
+const declaresBindingNamed = (functionNode: EsTreeNode, bindingName: string): boolean =>
+  getOwnScopeBoundNames(functionNode).has(bindingName);
+
 const isPropertyNamePosition = (identifier: EsTreeNode): boolean => {
   const parent = identifier.parent;
   if (!parent) return false;

From d8628d7f21e60b0e6dfd98d76c9f24e03f7afe24 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 18:05:11 -0500
Subject: [PATCH 11/33] =?UTF-8?q?perf(plugin):=20memoization=20sweep=20?=
 =?UTF-8?q?=E2=80=94=20cache=20pure=20per-file=20analyses=20(#1051)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Memoizes the ~22x-per-file security-scan path classification per
(pattern, relativePath) (#244/#257/#265/#280/#285/#510), caches
doesModuleExportName's read+strip+export scan per file with mtime/size
invalidation so sibling pages and both metadata names reuse one parse
(#117/#403), adds WeakMap memos for getScopeForNode (#324/#332/#345),
getRef (#323/#346), and getUpstreamRefs (#347) keyed on the per-Program
analysis, deletes react.ts's duplicate full-scope scan in favor of the
memoized getScopeForNode (#333), memoizes zod's getImportInfoForIdentifier
per identifier node (#389), and gives normalizeFilename an
already-normalized fast path (#430). Skipped: #341 (no change needed per
the catalog), #452/#454 (a directory/resolution memo contradicts the
documented uncached-walk freshness guarantee for long-lived processes).
Behavior verified identical via the 291-diagnostic equivalence corpus.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-sweep-memo.md                 |  5 +++
 .../utils/is-production-file-path.ts          | 28 ++++++++++---
 .../state-and-effects/utils/effect/ast.ts     | 37 ++++++++++++++--
 .../utils/effect/get-program-analysis.ts      | 12 ++++++
 .../state-and-effects/utils/effect/react.ts   | 31 ++------------
 .../src/plugin/rules/zod/utils/zod-ast.ts     | 14 +++++++
 .../plugin/utils/does-module-export-name.ts   | 42 ++++++++++++++-----
 .../src/plugin/utils/normalize-filename.ts    |  5 ++-
 8 files changed, 125 insertions(+), 49 deletions(-)
 create mode 100644 .changeset/perf-sweep-memo.md

diff --git a/.changeset/perf-sweep-memo.md b/.changeset/perf-sweep-memo.md
new file mode 100644
index 0000000000..3b54756355
--- /dev/null
+++ b/.changeset/perf-sweep-memo.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: memoization sweep — per-file/per-Program analyses stop recomputing per node and per rule (security-scan path classification cached per pattern+path, layout export scans cached per file with mtime invalidation, effect scope/reference/upstream-ref lookups memoized per analysis, the duplicated outer-scope scan converged onto getScopeForNode, zod import classification memoized per identifier, and normalizeFilename skips the no-op allocation)
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/is-production-file-path.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/is-production-file-path.ts
index 0327af0fea..6f48e399ae 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/is-production-file-path.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/security-scan/utils/is-production-file-path.ts
@@ -5,11 +5,27 @@ import {
   TEST_CONTEXT_PATTERN,
 } from "../../../constants/security-scan.js";
 
+// Every enabled scan rule re-classifies the same relativePath (once per rule
+// per file), so the pure result is memoized. Keyed by BOTH the source-file
+// pattern (by object identity — callers pass a small fixed set of module
+// constants) and the path, since a path-only key would conflate the source /
+// script / database extension variants.
+const classificationCacheByPattern = new Map<RegExp, Map<string, boolean>>();
+
 export const isProductionFilePath = (relativePath: string, sourceFilePattern: RegExp): boolean => {
-  if (!sourceFilePattern.test(relativePath)) return false;
-  if (TEST_CONTEXT_PATTERN.test(relativePath)) return false;
-  if (BUILD_SCRIPT_CONTEXT_PATTERN.test(relativePath)) return false;
-  if (DOCUMENTATION_CONTEXT_PATTERN.test(relativePath)) return false;
-  if (GENERATED_SOURCE_CONTEXT_PATTERN.test(relativePath)) return false;
-  return true;
+  let classificationByPath = classificationCacheByPattern.get(sourceFilePattern);
+  if (!classificationByPath) {
+    classificationByPath = new Map();
+    classificationCacheByPattern.set(sourceFilePattern, classificationByPath);
+  }
+  const cached = classificationByPath.get(relativePath);
+  if (cached !== undefined) return cached;
+  const isProduction =
+    sourceFilePattern.test(relativePath) &&
+    !TEST_CONTEXT_PATTERN.test(relativePath) &&
+    !BUILD_SCRIPT_CONTEXT_PATTERN.test(relativePath) &&
+    !DOCUMENTATION_CONTEXT_PATTERN.test(relativePath) &&
+    !GENERATED_SOURCE_CONTEXT_PATTERN.test(relativePath);
+  classificationByPath.set(relativePath, isProduction);
+  return isProduction;
 };
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts
index fa88dcbb55..68e7a9260d 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts
@@ -69,11 +69,23 @@ const descend = (
   }
 };
 
+// The upstream-reference chain for a given (analysis, ref) is deterministic
+// and read-only for every caller, so the def-chain ascent runs once per ref.
+const upstreamRefsCache = new WeakMap<ProgramAnalysis, WeakMap<Reference, Reference[]>>();
+
 export const getUpstreamRefs = (analysis: ProgramAnalysis, ref: Reference): Reference[] => {
+  let upstreamByRef = upstreamRefsCache.get(analysis);
+  if (!upstreamByRef) {
+    upstreamByRef = new WeakMap();
+    upstreamRefsCache.set(analysis, upstreamByRef);
+  }
+  const cached = upstreamByRef.get(ref);
+  if (cached) return cached;
   const refs: Reference[] = [];
   ascend(analysis, ref, (upRef) => {
     refs.push(upRef);
   });
+  upstreamByRef.set(ref, refs);
   return refs;
 };
 
@@ -85,13 +97,30 @@ export const findDownstreamNodes = (topNode: EsTreeNode, type: string): EsTreeNo
   return nodes;
 };
 
+// Reference identity is stable per analysis, so the scope + reference scan
+// runs once per identifier; `has()` distinguishes a cached null resolution
+// from a miss (same WeakMap shape as downstreamRefsCache below).
+const refByIdentifierCache = new WeakMap<ProgramAnalysis, WeakMap<EsTreeNode, Reference | null>>();
+
 export const getRef = (analysis: ProgramAnalysis, identifier: EsTreeNode): Reference | null => {
+  let refByIdentifier = refByIdentifierCache.get(analysis);
+  if (!refByIdentifier) {
+    refByIdentifier = new WeakMap();
+    refByIdentifierCache.set(analysis, refByIdentifier);
+  }
+  if (refByIdentifier.has(identifier)) return refByIdentifier.get(identifier) ?? null;
+  let resolvedReference: Reference | null = null;
   const scope = getScopeForNode(identifier, analysis.scopeManager);
-  if (!scope) return null;
-  for (const reference of scope.references) {
-    if (reference.identifier === identifier) return reference;
+  if (scope) {
+    for (const reference of scope.references) {
+      if (reference.identifier === identifier) {
+        resolvedReference = reference;
+        break;
+      }
+    }
   }
-  return null;
+  refByIdentifier.set(identifier, resolvedReference);
+  return resolvedReference;
 };
 
 // Memoize per (analysis, node). `analysis` is the per-Program singleton
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
index 112e726ec9..50e174fb1c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
@@ -90,12 +90,23 @@ export const getProgramAnalysis = (anyNode: EsTreeNode): ProgramAnalysis | null
   return analysis;
 };
 
+// Scope membership is fixed per file, so the linear scan over
+// `manager.scopes` runs once per queried node — every rule and pass that
+// asks about the same identifier afterwards gets a WeakMap hit.
+const scopeByNodeCache = new WeakMap<ScopeManager, WeakMap<EsTreeNode, Scope | null>>();
+
 // Replicates upstream's `context.sourceCode.getScope(node)`: returns the
 // innermost scope that *contains* `node`. We find the deepest scope
 // whose `block.range` strictly contains `node.range` (or whose `block`
 // IS the node).
 export const getScopeForNode = (node: EsTreeNode, manager: ScopeManager): Scope | null => {
   if (!node.range) return null;
+  let scopeByNode = scopeByNodeCache.get(manager);
+  if (!scopeByNode) {
+    scopeByNode = new WeakMap();
+    scopeByNodeCache.set(manager, scopeByNode);
+  }
+  if (scopeByNode.has(node)) return scopeByNode.get(node) ?? null;
   let bestScope: Scope | null = null;
   let bestSize = Infinity;
   for (const scope of manager.scopes) {
@@ -112,5 +123,6 @@ export const getScopeForNode = (node: EsTreeNode, manager: ScopeManager): Scope
       bestScope = scope;
     }
   }
+  scopeByNode.set(node, bestScope);
   return bestScope;
 };
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/react.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/react.ts
index 9aca02f992..e95bd5c246 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/react.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/react.ts
@@ -1,4 +1,4 @@
-import type { Reference, Scope } from "eslint-scope";
+import type { Reference } from "eslint-scope";
 import type { EsTreeNode } from "../../../../utils/es-tree-node.js";
 import { isAstNode } from "../../../../utils/is-ast-node.js";
 import { isFunctionLike } from "../../../../utils/is-function-like.js";
@@ -12,32 +12,7 @@ import {
   resolvesToAsyncFunction,
   resolveToFunction,
 } from "./ast.js";
-import type { ProgramAnalysis } from "./get-program-analysis.js";
-
-const getOuterScopeContaining = (analysis: ProgramAnalysis, node: EsTreeNode): Scope | null => {
-  if (!node.range) return null;
-  // Find the smallest scope whose block strictly *contains* `node`
-  // (block.range fully envelops node.range). For a top-level
-  // VariableDeclarator in the module scope, this returns the
-  // module scope.
-  let best: Scope | null = null;
-  let bestSize = Infinity;
-  for (const scope of analysis.scopeManager.scopes) {
-    const block = scope.block as unknown as EsTreeNode;
-    if (!block?.range) continue;
-    if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
-    const size = block.range[1] - block.range[0];
-    // `<=` so that when two scopes have identical ranges (the
-    // global + module pair always share the Program range), the
-    // later-created (i.e. inner) scope wins — module variables live
-    // there, not in the global scope.
-    if (size <= bestSize) {
-      bestSize = size;
-      best = scope;
-    }
-  }
-  return best;
-};
+import { getScopeForNode, type ProgramAnalysis } from "./get-program-analysis.js";
 
 // 1:1 port of upstream `src/util/react.js` from
 // `eslint-plugin-react-you-might-not-need-an-effect`. See `./ast.ts`
@@ -94,7 +69,7 @@ const isReactFunctionalHOC = (
   const isWrappedSeparately = (): boolean => {
     if (!isNodeOfType(node.id, "Identifier")) return false;
     const bindingName = node.id.name;
-    const containingScope = getOuterScopeContaining(analysis, node as unknown as EsTreeNode);
+    const containingScope = getScopeForNode(node as unknown as EsTreeNode, analysis.scopeManager);
     if (!containingScope) return false;
     const variable = containingScope.variables.find((v) => v.name === bindingName);
     if (!variable) return false;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts
index 833fa1f05d..4a3661a9a2 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/zod/utils/zod-ast.ts
@@ -33,8 +33,22 @@ export const getStaticPropertyName = (
   return null;
 };
 
+// The classification is a pure function of the identifier node within its
+// (immutable) file, and every zod rule re-queries the same identifiers —
+// memoize per node; `has()` distinguishes a cached null from a miss.
+const importInfoCache = new WeakMap<EsTreeNode, ZodImportInfo | null>();
+
 const getImportInfoForIdentifier = (
   identifier: EsTreeNodeOfType<"Identifier">,
+): ZodImportInfo | null => {
+  if (importInfoCache.has(identifier)) return importInfoCache.get(identifier) ?? null;
+  const importInfo = computeImportInfoForIdentifier(identifier);
+  importInfoCache.set(identifier, importInfo);
+  return importInfo;
+};
+
+const computeImportInfoForIdentifier = (
+  identifier: EsTreeNodeOfType<"Identifier">,
 ): ZodImportInfo | null => {
   const binding = findVariableInitializer(identifier, identifier.name);
   const specifier = binding?.initializer;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts
index 512cf02021..91f55f6dd9 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts
@@ -8,30 +8,52 @@ const NAMED_EXPORT_DECLARATION_PATTERN =
 const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN =
   /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
 
-const doesSourceTextExportName = (sourceText: string, exportedName: string): boolean => {
+const collectSourceTextExportNames = (sourceText: string): ReadonlySet<string> => {
   const strippedSource = stripJsComments(sourceText);
-  if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) {
-    return true;
+  const exportedNames = new Set<string>();
+  if (DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) {
+    exportedNames.add("default");
   }
 
   for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) {
-    if (match[1] === exportedName) return true;
+    if (match[1]) exportedNames.add(match[1]);
   }
 
   for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN)) {
     const specifiersText = match[1] ?? "";
-    const exportedNames = parseExportSpecifiers(specifiersText, false).map(
-      (specifier) => specifier.exportedName,
-    );
-    if (exportedNames.includes(exportedName)) return true;
+    for (const specifier of parseExportSpecifiers(specifiersText, false)) {
+      exportedNames.add(specifier.exportedName);
+    }
   }
 
-  return false;
+  return exportedNames;
 };
 
+interface ExportNamesCacheEntry {
+  mtimeMs: number;
+  size: number;
+  exportedNames: ReadonlySet<string>;
+}
+
+// The same layout / barrel file is probed once per export name per page, so
+// the read + comment-strip + export scan is cached per file, keyed by
+// mtime/size for invalidation (mirrors `parse-source-file.ts`).
+const exportNamesCache = new Map<string, ExportNamesCacheEntry>();
+
 export const doesModuleExportName = (filePath: string, exportedName: string): boolean => {
   try {
-    return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
+    const fileStat = fs.statSync(filePath);
+    const cached = exportNamesCache.get(filePath);
+    if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) {
+      return cached.exportedNames.has(exportedName);
+    }
+    const exportedNames = collectSourceTextExportNames(fs.readFileSync(filePath, "utf8"));
+    exportNamesCache.set(filePath, {
+      mtimeMs: fileStat.mtimeMs,
+      size: fileStat.size,
+      exportedNames,
+    });
+    return exportedNames.has(exportedName);
   } catch {
     return false;
   }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/normalize-filename.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/normalize-filename.ts
index 17340cae96..1056c52de6 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/normalize-filename.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/normalize-filename.ts
@@ -1 +1,4 @@
-export const normalizeFilename = (filename: string): string => filename.replaceAll("\\", "/");
+// Already-normalized paths (the common case — helpers re-normalize each
+// other's output) skip the replaceAll allocation.
+export const normalizeFilename = (filename: string): string =>
+  filename.includes("\\") ? filename.replaceAll("\\", "/") : filename;

From da3b19c79c27945d873eb24e34431cbefa8f9938 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 18:14:20 -0500
Subject: [PATCH 12/33] =?UTF-8?q?perf(plugin):=20set-membership=20sweep=20?=
 =?UTF-8?q?=E2=80=94=20replace=20linear=20scans=20with=20Sets/Maps=20(#104?=
 =?UTF-8?q?8)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Converts per-element Array.includes scans and repeated per-handler
attribute walks to Set/Map lookups: ARIA element-role tables (#36/#458)
become prebuilt lookup maps, DOM_PROPERTIES_IGNORE_CASE (#459) becomes a
lowercased-key Map, the interactive-handler probes (#17/#39/#40/#460)
collapse to one lowercased-Set pass over the attributes, a11y settings
lists (#10/#21/#23/#28) resolve to Sets, rn-no-raw-text's keyword spread
(#216) is hoisted, and the tanstack order tables (#372/#373/#461) gain
index Maps. Behavior verified identical via the 291-diagnostic
equivalence corpus.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-sweep-set-membership.md       |  5 +++
 .../plugin/constants/aria-element-roles.ts    | 39 ++++++++++++-------
 .../plugin/constants/dom-property-names.ts    | 20 ++++++----
 .../src/plugin/constants/event-handlers.ts    |  7 ++++
 .../src/plugin/constants/tanstack.ts          | 11 ++++++
 .../plugin/rules/a11y/autocomplete-valid.ts   |  6 +--
 .../plugin/rules/a11y/heading-has-content.ts  |  6 +--
 .../rules/a11y/interactive-supports-focus.ts  | 16 ++++++--
 .../a11y/label-has-associated-control.ts      | 30 ++++++++------
 .../plugin/rules/a11y/media-has-caption.ts    | 20 +++++-----
 .../no-noninteractive-element-interactions.ts | 29 ++++++++------
 .../a11y/no-static-element-interactions.ts    | 18 +++++++--
 .../react-builtins/no-unknown-property.ts     | 10 ++---
 .../rules/react-native/rn-no-raw-text.ts      |  4 +-
 .../tanstack-start-route-property-order.ts    |  9 +++--
 .../tanstack-start-server-fn-method-order.ts  |  8 ++--
 16 files changed, 155 insertions(+), 83 deletions(-)
 create mode 100644 .changeset/perf-sweep-set-membership.md

diff --git a/.changeset/perf-sweep-set-membership.md b/.changeset/perf-sweep-set-membership.md
new file mode 100644
index 0000000000..ac7a73aeb9
--- /dev/null
+++ b/.changeset/perf-sweep-set-membership.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+perf: set-membership sweep — ~13 linear array scans on per-element hot paths now use Sets/Maps (ARIA element-role tables become O(1) lookup maps, event-handler presence checks collapse to one lowercased-Set pass per element, a11y settings lists and tanstack order tables convert to Sets/index Maps)
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/aria-element-roles.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/aria-element-roles.ts
index dfb532c2b2..4265bc5cfe 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/aria-element-roles.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/aria-element-roles.ts
@@ -79,20 +79,33 @@ const ELEMENT_ROLE_PAIRS: ReadonlyArray<readonly [string, string]> = [
   ["ul", "list"],
 ];
 
-// Returns all implicit roles for `tag`. Empty array if tag has none.
-export const getElementImplicitRoles = (tag: string): ReadonlyArray<string> => {
-  const out: string[] = [];
-  for (const [element, role] of ELEMENT_ROLE_PAIRS) {
-    if (element === tag && !out.includes(role)) out.push(role);
+const EMPTY_ROLE_LIST: ReadonlyArray<string> = [];
+
+const buildLookup = (
+  pairs: ReadonlyArray<readonly [string, string]>,
+  keyIndex: 0 | 1,
+): ReadonlyMap<string, ReadonlyArray<string>> => {
+  const lookup = new Map<string, string[]>();
+  for (const pair of pairs) {
+    const key = pair[keyIndex];
+    const value = pair[keyIndex === 0 ? 1 : 0];
+    const values = lookup.get(key);
+    if (!values) {
+      lookup.set(key, [value]);
+    } else if (!values.includes(value)) {
+      values.push(value);
+    }
   }
-  return out;
+  return lookup;
 };
 
+const IMPLICIT_ROLES_BY_TAG = buildLookup(ELEMENT_ROLE_PAIRS, 0);
+const TAGS_BY_ROLE = buildLookup(ELEMENT_ROLE_PAIRS, 1);
+
+// Returns all implicit roles for `tag`. Empty array if tag has none.
+export const getElementImplicitRoles = (tag: string): ReadonlyArray<string> =>
+  IMPLICIT_ROLES_BY_TAG.get(tag) ?? EMPTY_ROLE_LIST;
+
 // Reverse lookup: HTML elements that map to `role`.
-export const getTagsForRole = (role: string): ReadonlyArray<string> => {
-  const out: string[] = [];
-  for (const [element, r] of ELEMENT_ROLE_PAIRS) {
-    if (r === role && !out.includes(element)) out.push(element);
-  }
-  return out;
-};
+export const getTagsForRole = (role: string): ReadonlyArray<string> =>
+  TAGS_BY_ROLE.get(role) ?? EMPTY_ROLE_LIST;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/dom-property-names.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/dom-property-names.ts
index e6b0351ddb..b777bfe67c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/dom-property-names.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/dom-property-names.ts
@@ -694,11 +694,15 @@ export const DOM_ATTRIBUTES_TO_CAMEL: ReadonlyMap<string, string> = new Map([
 ]);
 
 // Names for which casing isn't enforced — i.e. both `charset` and
-// `charSet` (and similar) are accepted spellings.
-export const DOM_PROPERTIES_IGNORE_CASE: ReadonlyArray<string> = [
-  "charset",
-  "allowFullScreen",
-  "webkitAllowFullScreen",
-  "mozAllowFullScreen",
-  "webkitDirectory",
-];
+// `charSet` (and similar) are accepted spellings. Keyed by lowercased form
+// so a lookup is one `toLowerCase` + one `Map.get` instead of a linear scan
+// that re-lowercases the constants per call.
+export const DOM_PROPERTIES_IGNORE_CASE_BY_LOWER: ReadonlyMap<string, string> = new Map(
+  [
+    "charset",
+    "allowFullScreen",
+    "webkitAllowFullScreen",
+    "mozAllowFullScreen",
+    "webkitDirectory",
+  ].map((name) => [name.toLowerCase(), name]),
+);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/event-handlers.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/event-handlers.ts
index 8b4a7fe984..af865b4e1e 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/event-handlers.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/event-handlers.ts
@@ -30,3 +30,10 @@ export const ALL_EVENT_HANDLERS: ReadonlyArray<string> = [
   ...MOUSE_EVENT_HANDLERS,
   ...KEYBOARD_EVENT_HANDLERS,
 ];
+
+// Lowercased Set for single-pass, case-insensitive presence checks over an
+// element's attributes — one lookup per attribute instead of one full
+// attribute scan per handler name.
+export const ALL_EVENT_HANDLERS_LOWER: ReadonlySet<string> = new Set(
+  ALL_EVENT_HANDLERS.map((handlerName) => handlerName.toLowerCase()),
+);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/tanstack.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/tanstack.ts
index 6b137f9ff7..e99fe0deeb 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/tanstack.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/tanstack.ts
@@ -18,6 +18,12 @@ export const TANSTACK_ROUTE_PROPERTY_ORDER = [
   "remountDeps",
 ];
 
+// Index of each order-sensitive route property, so membership and ordering
+// are one Map lookup instead of includes() + indexOf() linear scans.
+export const TANSTACK_ROUTE_PROPERTY_INDEX: ReadonlyMap<string, number> = new Map(
+  TANSTACK_ROUTE_PROPERTY_ORDER.map((propertyName, orderIndex) => [propertyName, orderIndex]),
+);
+
 export const TANSTACK_ROUTE_CREATION_FUNCTIONS = new Set([
   "createFileRoute",
   "createRoute",
@@ -39,6 +45,11 @@ export const TANSTACK_MIDDLEWARE_METHOD_ORDER = [
   "handler",
 ];
 
+// Same Map-index companion for the server-fn middleware chain order.
+export const TANSTACK_MIDDLEWARE_METHOD_INDEX: ReadonlyMap<string, number> = new Map(
+  TANSTACK_MIDDLEWARE_METHOD_ORDER.map((methodName, orderIndex) => [methodName, orderIndex]),
+);
+
 export const TANSTACK_REDIRECT_FUNCTIONS = new Set(["redirect", "notFound"]);
 
 export const TANSTACK_SERVER_FN_FILE_PATTERN = /\.functions(\.[jt]sx?)?$/;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/autocomplete-valid.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/autocomplete-valid.ts
index 9fa7706009..cc5c1b8b84 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/autocomplete-valid.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/autocomplete-valid.ts
@@ -131,13 +131,13 @@ interface AutocompleteValidSettings {
 
 const resolveSettings = (
   settings: Readonly<Record<string, unknown>> | undefined,
-): { inputComponents: ReadonlyArray<string> } => {
+): { inputComponents: ReadonlySet<string> } => {
   const reactDoctor = settings?.["react-doctor"];
   const ruleSettings =
     typeof reactDoctor === "object" && reactDoctor !== null
       ? ((reactDoctor as { autocompleteValid?: AutocompleteValidSettings }).autocompleteValid ?? {})
       : {};
-  return { inputComponents: ruleSettings.inputComponents ?? [] };
+  return { inputComponents: new Set(ruleSettings.inputComponents ?? []) };
 };
 
 // Port of `oxc_linter::rules::jsx_a11y::autocomplete_valid`. Validates
@@ -155,7 +155,7 @@ export const autocompleteValid = defineRule({
     return {
       JSXOpeningElement: (node: EsTreeNodeOfType<"JSXOpeningElement">) => {
         const tag = getElementType(node, context.settings);
-        if (!FORM_CONTROL_TAGS.has(tag) && !settings.inputComponents.includes(tag)) return;
+        if (!FORM_CONTROL_TAGS.has(tag) && !settings.inputComponents.has(tag)) return;
         const attribute = hasJsxPropIgnoreCase(node.attributes, "autoComplete");
         if (!attribute) return;
         const value = getJsxPropStringValue(attribute);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/heading-has-content.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/heading-has-content.ts
index 452e5965de..acbe913a34 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/heading-has-content.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/heading-has-content.ts
@@ -18,14 +18,14 @@ interface HeadingHasContentSettings {
 
 const resolveSettings = (
   settings: Readonly<Record<string, unknown>> | undefined,
-): { headingTags: ReadonlyArray<string> } => {
+): { headingTags: ReadonlySet<string> } => {
   const reactDoctor = settings?.["react-doctor"];
   const ruleSettings =
     typeof reactDoctor === "object" && reactDoctor !== null
       ? ((reactDoctor as { headingHasContent?: HeadingHasContentSettings }).headingHasContent ?? {})
       : {};
   return {
-    headingTags: [...DEFAULT_HEADING_TAGS, ...(ruleSettings.components ?? [])],
+    headingTags: new Set([...DEFAULT_HEADING_TAGS, ...(ruleSettings.components ?? [])]),
   };
 };
 
@@ -44,7 +44,7 @@ export const headingHasContent = defineRule({
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
         const elementType = getElementType(node, context.settings);
-        if (!settings.headingTags.includes(elementType)) return;
+        if (!settings.headingTags.has(elementType)) return;
         const parent = (node as EsTreeNode).parent;
         if (parent && isNodeOfType(parent, "JSXElement")) {
           if (objectHasAccessibleChild(parent, context.settings)) return;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts
index 3a05cd2f12..32d0668aab 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/interactive-supports-focus.ts
@@ -1,11 +1,13 @@
-import { ALL_EVENT_HANDLERS } from "../../constants/event-handlers.js";
+import { ALL_EVENT_HANDLERS_LOWER } from "../../constants/event-handlers.js";
 import { HTML_TAGS } from "../../constants/html-tags.js";
 import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { getElementType } from "../../utils/get-element-type.js";
+import { getJsxAttributeName } from "../../utils/get-jsx-attribute-name.js";
 import { getJsxPropStringValue } from "../../utils/get-jsx-prop-string-value.js";
 import { hasJsxPropIgnoreCase } from "../../utils/has-jsx-prop-ignore-case.js";
 import { hasJsxSpreadAttribute } from "../../utils/has-jsx-spread-attribute.js";
+import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { isDisabledElement } from "../../utils/is-disabled-element.js";
 import { isHiddenFromScreenReader } from "../../utils/is-hidden-from-screen-reader.js";
 import { isInteractiveElement } from "../../utils/is-interactive-element.js";
@@ -65,9 +67,15 @@ export const interactiveSupportsFocus = defineRule({
         const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
         const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
         if (!role) return;
-        const hasInteractiveHandler = ALL_EVENT_HANDLERS.some((handler) =>
-          Boolean(hasJsxPropIgnoreCase(node.attributes, handler)),
-        );
+        let hasInteractiveHandler = false;
+        for (const attribute of node.attributes) {
+          if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+          const attributeName = getJsxAttributeName(attribute.name);
+          if (attributeName && ALL_EVENT_HANDLERS_LOWER.has(attributeName.toLowerCase())) {
+            hasInteractiveHandler = true;
+            break;
+          }
+        }
         if (!hasInteractiveHandler) return;
         const elementType = getElementType(node, context.settings);
         // Custom components (PascalCase, not in HTML_TAGS) encapsulate
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/label-has-associated-control.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/label-has-associated-control.ts
index c55186adaa..10cdabcbcd 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/label-has-associated-control.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/label-has-associated-control.ts
@@ -26,20 +26,22 @@ interface JsxA11ySettings {
   attributes?: { for?: ReadonlyArray<string> };
 }
 
-const DEFAULT_CONTROL_COMPONENTS: ReadonlyArray<string> = [
+const DEFAULT_CONTROL_COMPONENTS: ReadonlySet<string> = new Set([
   "input",
   "meter",
   "output",
   "progress",
   "select",
   "textarea",
-];
+]);
 
 const DEFAULT_LABEL_ATTRIBUTES: ReadonlyArray<string> = ["alt", "aria-label", "aria-labelledby"];
 
 const resolveSettings = (
   settings: Readonly<Record<string, unknown>> | undefined,
-): Required<LabelHasAssociatedControlSettings> & {
+): Omit<Required<LabelHasAssociatedControlSettings>, "labelComponents" | "labelAttributes"> & {
+  labelComponents: ReadonlySet<string>;
+  labelAttributes: ReadonlySet<string>;
   forAttributes: ReadonlyArray<string>;
 } => {
   const reactDoctor = settings?.["react-doctor"];
@@ -52,10 +54,14 @@ const resolveSettings = (
   const a11ySettings =
     typeof jsxA11y === "object" && jsxA11y !== null ? (jsxA11y as JsxA11ySettings) : {};
   const forAttributes = a11ySettings.attributes?.for ?? ["htmlFor"];
-  const labelComponents = ["label", ...(ruleSettings.labelComponents ?? [])].sort();
-  const labelAttributes = [
-    ...new Set([...DEFAULT_LABEL_ATTRIBUTES, ...(ruleSettings.labelAttributes ?? [])]),
-  ].sort();
+  const labelComponents: ReadonlySet<string> = new Set([
+    "label",
+    ...(ruleSettings.labelComponents ?? []),
+  ]);
+  const labelAttributes: ReadonlySet<string> = new Set([
+    ...DEFAULT_LABEL_ATTRIBUTES,
+    ...(ruleSettings.labelAttributes ?? []),
+  ]);
   return {
     labelComponents,
     labelAttributes,
@@ -75,13 +81,13 @@ const resolveSettings = (
 
 // Glob match used by OXC for `controlComponents` entries (supports `*`).
 const isControlComponent = (tagName: string, controlComponents: ReadonlyArray<string>): boolean => {
-  if (DEFAULT_CONTROL_COMPONENTS.includes(tagName)) return true;
+  if (DEFAULT_CONTROL_COMPONENTS.has(tagName)) return true;
   return controlComponents.some((pattern) => compileGlob(pattern).test(tagName));
 };
 
 interface SearchContext {
   depth: number;
-  labelAttributes: ReadonlyArray<string>;
+  labelAttributes: ReadonlySet<string>;
   controlComponents: ReadonlyArray<string>;
   settings: Readonly<Record<string, unknown>> | undefined;
 }
@@ -131,7 +137,7 @@ const searchForAccessibleLabel = (
       const attributeName = (attribute as EsTreeNodeOfType<"JSXAttribute">).name;
       if (!isNodeOfType(attributeName as EsTreeNode, "JSXIdentifier")) continue;
       const propName = getJsxAttributeName(attributeName as EsTreeNodeOfType<"JSXIdentifier">);
-      if (!propName || !searchContext.labelAttributes.includes(propName)) continue;
+      if (!propName || !searchContext.labelAttributes.has(propName)) continue;
       const attributeValue = (attribute as EsTreeNodeOfType<"JSXAttribute">).value;
       if (!attributeValue) continue;
       if (
@@ -173,7 +179,7 @@ const hasAccessibleLabel = (
     const attributeName = (attribute as EsTreeNodeOfType<"JSXAttribute">).name;
     if (!isNodeOfType(attributeName as EsTreeNode, "JSXIdentifier")) continue;
     const propName = getJsxAttributeName(attributeName as EsTreeNodeOfType<"JSXIdentifier">);
-    if (propName && searchContext.labelAttributes.includes(propName)) return true;
+    if (propName && searchContext.labelAttributes.has(propName)) return true;
   }
   for (const child of element.children) {
     if (searchForAccessibleLabel(child as EsTreeNode, 1, searchContext)) return true;
@@ -207,7 +213,7 @@ export const labelHasAssociatedControl = defineRule({
         if (isTestlikeFile) return;
         const opening = node.openingElement;
         const tagName = getElementType(opening, context.settings);
-        if (!settings.labelComponents.includes(tagName)) return;
+        if (!settings.labelComponents.has(tagName)) return;
         const hasHtmlFor = settings.forAttributes.some((attributeName) =>
           Boolean(hasJsxPropIgnoreCase(opening.attributes, attributeName)),
         );
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/media-has-caption.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/media-has-caption.ts
index 6f1c94ac77..0cf7609eae 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/media-has-caption.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/media-has-caption.ts
@@ -22,9 +22,9 @@ interface MediaHasCaptionSettings {
 const resolveSettings = (
   settings: Readonly<Record<string, unknown>> | undefined,
 ): {
-  audio: ReadonlyArray<string>;
-  video: ReadonlyArray<string>;
-  track: ReadonlyArray<string>;
+  audio: ReadonlySet<string>;
+  video: ReadonlySet<string>;
+  track: ReadonlySet<string>;
 } => {
   const reactDoctor = settings?.["react-doctor"];
   const ruleSettings =
@@ -32,9 +32,9 @@ const resolveSettings = (
       ? ((reactDoctor as { mediaHasCaption?: MediaHasCaptionSettings }).mediaHasCaption ?? {})
       : {};
   return {
-    audio: [...DEFAULT_AUDIO, ...(ruleSettings.audio ?? [])],
-    video: [...DEFAULT_VIDEO, ...(ruleSettings.video ?? [])],
-    track: [...DEFAULT_TRACK, ...(ruleSettings.track ?? [])],
+    audio: new Set([...DEFAULT_AUDIO, ...(ruleSettings.audio ?? [])]),
+    video: new Set([...DEFAULT_VIDEO, ...(ruleSettings.video ?? [])]),
+    track: new Set([...DEFAULT_TRACK, ...(ruleSettings.track ?? [])]),
   };
 };
 
@@ -83,7 +83,7 @@ const trackKindMightBeCaptions = (
 // tracks (e.g. a static `kind="subtitles"`) does not satisfy the requirement.
 const childMayRenderTrack = (
   child: EsTreeNode,
-  trackTags: ReadonlyArray<string>,
+  trackTags: ReadonlySet<string>,
   settings: Readonly<Record<string, unknown>> | undefined,
 ): boolean => {
   if (!isNodeOfType(child, "JSXExpressionContainer")) return false;
@@ -104,7 +104,7 @@ const childMayRenderTrack = (
     if (rendersCaptionTrack) return false;
     if (
       isNodeOfType(inner, "JSXElement") &&
-      trackTags.includes(getElementType(inner.openingElement, settings)) &&
+      trackTags.has(getElementType(inner.openingElement, settings)) &&
       trackKindMightBeCaptions(inner.openingElement)
     ) {
       rendersCaptionTrack = true;
@@ -127,7 +127,7 @@ export const mediaHasCaption = defineRule({
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
         const tag = getElementType(node, context.settings);
-        const isAudioOrVideo = settings.audio.includes(tag) || settings.video.includes(tag);
+        const isAudioOrVideo = settings.audio.has(tag) || settings.video.has(tag);
         if (!isAudioOrVideo) return;
         const mutedAttribute = hasJsxPropIgnoreCase(node.attributes, "muted");
         if (evaluateMuted(mutedAttribute) === true) return;
@@ -145,7 +145,7 @@ export const mediaHasCaption = defineRule({
           if (!isNodeOfType(child as EsTreeNode, "JSXElement")) return false;
           const opening = (child as EsTreeNodeOfType<"JSXElement">).openingElement;
           const childTag = getElementType(opening, context.settings);
-          if (!settings.track.includes(childTag)) return false;
+          if (!settings.track.has(childTag)) return false;
           const kindAttribute = hasJsxPropIgnoreCase(opening.attributes, "kind");
           if (!kindAttribute) return false;
           let kindValue = kindAttribute.value as EsTreeNode | null;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-element-interactions.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-element-interactions.ts
index 71f475f301..05e205739e 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-element-interactions.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-element-interactions.ts
@@ -2,6 +2,7 @@ import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { getElementType } from "../../utils/get-element-type.js";
+import { getJsxAttributeName } from "../../utils/get-jsx-attribute-name.js";
 import { getJsxPropStringValue } from "../../utils/get-jsx-prop-string-value.js";
 import { hasJsxPropIgnoreCase } from "../../utils/has-jsx-prop-ignore-case.js";
 import { isHiddenFromScreenReader } from "../../utils/is-hidden-from-screen-reader.js";
@@ -100,15 +101,13 @@ const collectRoleBranches = (expression: EsTreeNode, out: RoleExpressionBranches
 const buildMessage = (tag: string): string =>
   `Keyboard & screen reader users can't trigger this \`<${tag}>\` because it isn't interactive, so use a button or link or add an interactive role.`;
 
-// Mouse / pointer / keyboard events that imply interaction.
-const INTERACTIVE_HANDLERS: ReadonlyArray<string> = [
-  "onClick",
-  "onMouseDown",
-  "onMouseUp",
-  "onKeyDown",
-  "onKeyPress",
-  "onKeyUp",
-];
+// Mouse / pointer / keyboard events that imply interaction, keyed by
+// lowercased form for a single case-insensitive pass over the attributes.
+const INTERACTIVE_HANDLERS_LOWER: ReadonlySet<string> = new Set(
+  ["onClick", "onMouseDown", "onMouseUp", "onKeyDown", "onKeyPress", "onKeyUp"].map((handlerName) =>
+    handlerName.toLowerCase(),
+  ),
+);
 
 // Port of `oxc_linter::rules::jsx_a11y::no_noninteractive_element_interactions`.
 // Reports interactive event handlers attached to non-interactive HTML
@@ -131,9 +130,15 @@ export const noNoninteractiveElementInteractions = defineRule({
         // ARIA role, and clicking a label forwards activation to its nested
         // keyboard-accessible input.
         if (tag === "label") return;
-        const hasHandler = INTERACTIVE_HANDLERS.some((handler) =>
-          hasJsxPropIgnoreCase(node.attributes, handler),
-        );
+        let hasHandler = false;
+        for (const attribute of node.attributes) {
+          if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+          const attributeName = getJsxAttributeName(attribute.name);
+          if (attributeName && INTERACTIVE_HANDLERS_LOWER.has(attributeName.toLowerCase())) {
+            hasHandler = true;
+            break;
+          }
+        }
         if (!hasHandler) return;
         if (isHiddenFromScreenReader(node, context.settings)) return;
         const roleAttr = hasJsxPropIgnoreCase(node.attributes, "role");
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts
index 1caada8169..5a1e17dbd8 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts
@@ -3,6 +3,7 @@ import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { getElementType } from "../../utils/get-element-type.js";
+import { getJsxAttributeName } from "../../utils/get-jsx-attribute-name.js";
 import { hasJsxPropIgnoreCase } from "../../utils/has-jsx-prop-ignore-case.js";
 import { isAbstractRole } from "../../utils/is-abstract-role.js";
 import { isHiddenFromScreenReader } from "../../utils/is-hidden-from-screen-reader.js";
@@ -70,6 +71,9 @@ export const noStaticElementInteractions = defineRule({
   category: "Accessibility",
   create: (context) => {
     const settings = resolveSettings(context.settings);
+    const handlersLower: ReadonlySet<string> = new Set(
+      settings.handlers.map((handlerName) => handlerName.toLowerCase()),
+    );
     const isTestlikeFile = isTestlikeFilename(context.filename);
     return {
       JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
@@ -82,9 +86,17 @@ export const noStaticElementInteractions = defineRule({
         // pass through.
         let hasNonBlockerHandler = false;
         let hasAnyHandler = false;
-        for (const handler of settings.handlers) {
-          const attribute = hasJsxPropIgnoreCase(node.attributes, handler);
-          if (!attribute) continue;
+        // Only the FIRST attribute per handler name counts (mirrors the
+        // per-handler `hasJsxPropIgnoreCase` first-match this replaces).
+        let seenHandlerNames: Set<string> | null = null;
+        for (const attribute of node.attributes) {
+          if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+          const attributeName = getJsxAttributeName(attribute.name);
+          if (!attributeName) continue;
+          const handlerNameLower = attributeName.toLowerCase();
+          if (!handlersLower.has(handlerNameLower)) continue;
+          if (seenHandlerNames?.has(handlerNameLower)) continue;
+          (seenHandlerNames ??= new Set()).add(handlerNameLower);
           if (isNullValue(attribute)) continue;
           hasAnyHandler = true;
           if (!isPureEventBlockerHandler(attribute)) {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unknown-property.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unknown-property.ts
index 7e77170d21..f340ead528 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unknown-property.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-unknown-property.ts
@@ -1,7 +1,7 @@
 import { isValidDomAriaProperty } from "../../constants/dom-aria-properties.js";
 import {
   DOM_ATTRIBUTES_TO_CAMEL,
-  DOM_PROPERTIES_IGNORE_CASE,
+  DOM_PROPERTIES_IGNORE_CASE_BY_LOWER,
   DOM_PROPERTY_NAMES,
   DOM_PROPERTY_NAMES_LOWER,
 } from "../../constants/dom-property-names.js";
@@ -44,12 +44,8 @@ const matchesHtmlTagConventions = (tagName: string): boolean => {
   return !tagName.includes("-");
 };
 
-const normalizeAttributeCase = (name: string): string => {
-  for (const ignoreCaseName of DOM_PROPERTIES_IGNORE_CASE) {
-    if (ignoreCaseName.toLowerCase() === name.toLowerCase()) return ignoreCaseName;
-  }
-  return name;
-};
+const normalizeAttributeCase = (name: string): string =>
+  DOM_PROPERTIES_IGNORE_CASE_BY_LOWER.get(name.toLowerCase()) ?? name;
 
 const hasUppercaseChar = (input: string): boolean => /[A-Z]/.test(input);
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
index d306be5df8..3acac797ec 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
@@ -67,9 +67,11 @@ const resolveTextBoundaryName = (
   return resolveJsxElementName(openingElement);
 };
 
+const TEXT_COMPONENT_KEYWORDS: ReadonlyArray<string> = [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS];
+
 const isTextHandlingComponent = (elementName: string): boolean => {
   if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
-  return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
+  return TEXT_COMPONENT_KEYWORDS.some((keyword) => elementName.includes(keyword));
 };
 
 const isTransparentTextWrapper = (elementName: string | null): boolean =>
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-route-property-order.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-route-property-order.ts
index d3b9905de3..26892a9430 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-route-property-order.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-route-property-order.ts
@@ -1,4 +1,7 @@
-import { TANSTACK_ROUTE_PROPERTY_ORDER } from "../../constants/tanstack.js";
+import {
+  TANSTACK_ROUTE_PROPERTY_INDEX,
+  TANSTACK_ROUTE_PROPERTY_ORDER,
+} from "../../constants/tanstack.js";
 import { defineRule } from "../../utils/define-rule.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import { getRouteOptionsObject } from "./utils/get-route-options-object.js";
@@ -28,12 +31,12 @@ export const tanstackStartRoutePropertyOrder = defineRule({
       }
 
       const sensitiveProperties = orderedPropertyNames.filter((propertyName) =>
-        TANSTACK_ROUTE_PROPERTY_ORDER.includes(propertyName),
+        TANSTACK_ROUTE_PROPERTY_INDEX.has(propertyName),
       );
 
       let lastIndex = -1;
       for (const propertyName of sensitiveProperties) {
-        const currentIndex = TANSTACK_ROUTE_PROPERTY_ORDER.indexOf(propertyName);
+        const currentIndex = TANSTACK_ROUTE_PROPERTY_INDEX.get(propertyName) ?? -1;
         if (currentIndex < lastIndex) {
           const expectedBefore = TANSTACK_ROUTE_PROPERTY_ORDER[lastIndex];
           context.report({
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-server-fn-method-order.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-server-fn-method-order.ts
index d2dce7d16c..5a722a552b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-server-fn-method-order.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-start/tanstack-start-server-fn-method-order.ts
@@ -1,5 +1,6 @@
 import {
   TANSTACK_INPUT_VALIDATOR_METHOD_NAMES,
+  TANSTACK_MIDDLEWARE_METHOD_INDEX,
   TANSTACK_MIDDLEWARE_METHOD_ORDER,
   TANSTACK_SERVER_FN_NAMES,
 } from "../../constants/tanstack.js";
@@ -53,14 +54,13 @@ export const tanstackStartServerFnMethodOrder = defineRule({
       if (methodNames[methodNames.length - 1] !== ownMethodName) return;
 
       const orderSensitiveMethods = methodNames.filter((name) =>
-        TANSTACK_MIDDLEWARE_METHOD_ORDER.includes(toMethodOrderToken(name)),
+        TANSTACK_MIDDLEWARE_METHOD_INDEX.has(toMethodOrderToken(name)),
       );
 
       let lastIndex = -1;
       for (const methodName of orderSensitiveMethods) {
-        const currentIndex = TANSTACK_MIDDLEWARE_METHOD_ORDER.indexOf(
-          toMethodOrderToken(methodName),
-        );
+        const currentIndex =
+          TANSTACK_MIDDLEWARE_METHOD_INDEX.get(toMethodOrderToken(methodName)) ?? -1;
         if (currentIndex < lastIndex) {
           const expectedBefore = TANSTACK_MIDDLEWARE_METHOD_ORDER[lastIndex];
           context.report({

From 59e817858240d4a4986ff03b8bb4f7d3355e22c6 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 18:21:14 -0500
Subject: [PATCH 13/33] perf(core): stop lint's pre-spawn burst and the scan
 walk from starving forked fibers (#1046)

The security-scan and supply-chain fibers fork before lint, but lint's
synchronous discovery + cache-hash prefix ran with zero suspensions, so
they could not start until the first oxlint spawn; the scan's own
directory walk was likewise one unyielding burst. One early yield, budget-
checked yields in the hash loop, and walk-progress markers cut the parent
event-loop max stall from 116ms to 64ms with byte-identical output.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/secscan-overlap-starvation.md      |  7 ++++++
 packages/core/src/check-security-scan.ts      | 25 +++++++++++++------
 .../collect-security-scan-files.ts            |  9 ++++++-
 .../src/checks/security-scan/constants.ts     |  6 -----
 packages/core/src/constants.ts                |  7 ++++++
 packages/core/src/run-oxlint.ts               | 19 +++++++++++++-
 .../core/tests/check-security-scan.test.ts    | 13 +++++++++-
 7 files changed, 69 insertions(+), 17 deletions(-)
 create mode 100644 .changeset/secscan-overlap-starvation.md

diff --git a/.changeset/secscan-overlap-starvation.md b/.changeset/secscan-overlap-starvation.md
new file mode 100644
index 0000000000..6561396d04
--- /dev/null
+++ b/.changeset/secscan-overlap-starvation.md
@@ -0,0 +1,7 @@
+---
+"react-doctor": patch
+---
+
+Stop lint's pre-spawn setup from starving the overlapped security-scan and supply-chain passes.
+
+The security scan already runs on a cooperative background fiber that overlaps the lint pass, but a forked fiber only advances when the main thread yields — and lint's synchronous pre-spawn prefix (full-scan file discovery plus the per-file cache's content-hash partition over every candidate file) held the event loop until the first oxlint subprocess spawned. The overlapped passes now start immediately: the lint runner hands the loop back once before discovery and yields on the shared cooperative time budget while hashing, and the security scan's own directory walk (previously one unyielding readdir+classify burst before its first budget checkpoint) yields walk-progress markers so large trees can't stall lint subprocess draining or concurrently-scanning sibling projects. Diagnostics are byte-identical and the report order is unchanged.
diff --git a/packages/core/src/check-security-scan.ts b/packages/core/src/check-security-scan.ts
index fc748f8876..1b6c366a1c 100644
--- a/packages/core/src/check-security-scan.ts
+++ b/packages/core/src/check-security-scan.ts
@@ -3,7 +3,7 @@ import type { FileScan, ScannedFile } from "oxlint-plugin-react-doctor";
 import { buildSecurityScanDiagnostic } from "./checks/security-scan/build-security-scan-diagnostic.js";
 import type { SecurityScanRuleEntry } from "./checks/security-scan/build-security-scan-diagnostic.js";
 import { collectSecurityScanFiles } from "./checks/security-scan/collect-security-scan-files.js";
-import { SECURITY_SCAN_YIELD_BUDGET_MS } from "./checks/security-scan/constants.js";
+import { COOPERATIVE_YIELD_BUDGET_MS } from "./constants.js";
 import { buildCapabilities, shouldEnableRule } from "./runners/oxlint/capabilities.js";
 import type { Diagnostic, ProjectInfo } from "./types/index.js";
 import { isPathGitIgnored } from "./utils/is-path-git-ignored.js";
@@ -103,6 +103,7 @@ export const checkSecurityScan = (
   const session = createSecurityScanSession(rootDirectory, options);
   if (session === null) return [];
   for (const file of collectSecurityScanFiles(rootDirectory)) {
+    if (file === null) continue;
     for (const _ruleStep of session.scanFileByRule(file)) {
       // Sync driver: exhaust the per-rule steps without yielding.
     }
@@ -112,12 +113,13 @@ export const checkSecurityScan = (
 
 // Cooperative variant: identical output to `checkSecurityScan`, but hands the
 // event loop back whenever a scan slice has held it for
-// `SECURITY_SCAN_YIELD_BUDGET_MS`, checked between every (file, rule) step, so
-// a caller that forks it (the orchestrator) can overlap its CPU with other
-// async work. A time budget rather than a file interval: lint's child
-// processes are spawned and drained from main-thread continuations, so any
-// long stall idles the whole worker pool — and one large minified bundle
-// could previously stall for its entire rule set.
+// `COOPERATIVE_YIELD_BUDGET_MS`, checked between every walk step and every
+// (file, rule) step, so a caller that forks it (the orchestrator) can overlap
+// its CPU with other async work. A time budget rather than a file interval:
+// lint's child processes are spawned and drained from main-thread
+// continuations, so any long stall idles the whole worker pool — and one
+// large minified bundle could previously stall for its entire rule set (as
+// could a large tree's whole directory walk, before the walk markers).
 export const checkSecurityScanCooperative = async (
   rootDirectory: string,
   options: CheckSecurityScanOptions = {},
@@ -126,8 +128,15 @@ export const checkSecurityScanCooperative = async (
   if (session === null) return [];
   let sliceStartedAt = performance.now();
   for (const file of collectSecurityScanFiles(rootDirectory)) {
+    if (file === null) {
+      if (performance.now() - sliceStartedAt >= COOPERATIVE_YIELD_BUDGET_MS) {
+        await yieldToEventLoop();
+        sliceStartedAt = performance.now();
+      }
+      continue;
+    }
     for (const _ruleStep of session.scanFileByRule(file)) {
-      if (performance.now() - sliceStartedAt >= SECURITY_SCAN_YIELD_BUDGET_MS) {
+      if (performance.now() - sliceStartedAt >= COOPERATIVE_YIELD_BUDGET_MS) {
         await yieldToEventLoop();
         sliceStartedAt = performance.now();
       }
diff --git a/packages/core/src/checks/security-scan/collect-security-scan-files.ts b/packages/core/src/checks/security-scan/collect-security-scan-files.ts
index b218a7304f..df71e57e75 100644
--- a/packages/core/src/checks/security-scan/collect-security-scan-files.ts
+++ b/packages/core/src/checks/security-scan/collect-security-scan-files.ts
@@ -62,9 +62,15 @@ const readScannedFile = (candidate: SecurityScanCandidate): ScannedFile | null =
 // lazily, one file per iteration (capped at SECURITY_SCAN_MAX_FILES
 // successful reads per bucket), so a caller that streams findings never
 // holds more than one file's content at a time.
+//
+// `null` is a walk-progress marker, yielded once per directory processed: the
+// path-collection phase runs BEFORE any file can be yielded (the buckets need
+// the whole tree), so without markers a large tree's readdir + classify pass
+// would be one unyielding burst — the cooperative driver uses them as budget
+// checkpoints. Drivers that don't pace themselves just skip them.
 export function* collectSecurityScanFiles(
   rootDirectory: string,
-): Generator<ScannedFile, void, void> {
+): Generator<ScannedFile | null, void, void> {
   const priorityCandidates: SecurityScanCandidate[] = [];
   const artifactCandidates: SecurityScanCandidate[] = [];
   const otherCandidates: SecurityScanCandidate[] = [];
@@ -99,6 +105,7 @@ export function* collectSecurityScanFiles(
         isGeneratedBundleByName: classification.isGeneratedBundleByName,
       });
     }
+    yield null;
   }
 
   for (const candidates of [priorityCandidates, artifactCandidates, otherCandidates]) {
diff --git a/packages/core/src/checks/security-scan/constants.ts b/packages/core/src/checks/security-scan/constants.ts
index d5d309b996..687b292aa5 100644
--- a/packages/core/src/checks/security-scan/constants.ts
+++ b/packages/core/src/checks/security-scan/constants.ts
@@ -3,12 +3,6 @@ export const SECURITY_SCAN_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
 export const SECURITY_SCAN_MAX_BUNDLE_FILE_SIZE_BYTES = 8 * 1024 * 1024;
 export const SECURITY_SCAN_MAX_DIRECTORY_DEPTH = 8;
 
-// Longest synchronous burst the cooperative scan may hold the event loop
-// before yielding, checked between every (file, rule) step. The overlapping
-// lint pass spawns and drains its child processes from main-thread
-// continuations, so bursts beyond ~a frame idle the whole worker pool.
-export const SECURITY_SCAN_YIELD_BUDGET_MS = 12;
-
 export const SKIPPED_DIRECTORY_NAMES = new Set([
   ".git",
   ".turbo",
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index a832d8ed3d..c2ac71ee60 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -306,6 +306,13 @@ export const OXLINT_OUTPUT_MAX_BYTES = 50 * 1024 * 1024;
 // binding is markedly slower than on a developer laptop.
 export const OXLINT_SPAWN_TIMEOUT_MS = 60_000;
 
+// Longest synchronous burst a cooperative main-thread pass (the security
+// scan's walk / file / rule steps, lint's pre-spawn cache hashing) may hold
+// the event loop before handing it back. Lint child processes are spawned and
+// drained from main-thread continuations, so bursts beyond ~a frame idle the
+// whole worker pool — and starve concurrently-scanning sibling projects.
+export const COOPERATIVE_YIELD_BUDGET_MS = 12;
+
 // Directory name appended to os.tmpdir() to form the shared base for the V8
 // compile cache. Matches the base Node's own module.enableCompileCache() uses,
 // so the bin (parent) and the spawned oxlint batches (children) share one tree.
diff --git a/packages/core/src/run-oxlint.ts b/packages/core/src/run-oxlint.ts
index c3e8616192..86a9525856 100644
--- a/packages/core/src/run-oxlint.ts
+++ b/packages/core/src/run-oxlint.ts
@@ -4,6 +4,7 @@ import * as path from "node:path";
 import { CROSS_FILE_RULE_IDS } from "oxlint-plugin-react-doctor";
 import type { Diagnostic, ProjectInfo, ReactDoctorConfig } from "./types/index.js";
 import { batchIncludePaths } from "./batch-include-paths.js";
+import { COOPERATIVE_YIELD_BUDGET_MS } from "./constants.js";
 import { buildRuleSeverityControls } from "./build-rule-severity-controls.js";
 import { canOxlintExtendConfig } from "./can-oxlint-extend-config.js";
 import { collectIgnorePatterns } from "./collect-ignore-patterns.js";
@@ -27,6 +28,7 @@ import { hashFileContents } from "./utils/hash-file-contents.js";
 import { listSourceFilesWithSize } from "./utils/list-source-files.js";
 import { planLintBatches } from "./utils/plan-lint-batches.js";
 import { resolveReactDoctorCacheDir } from "./utils/resolve-react-doctor-cache-dir.js";
+import { yieldToEventLoop } from "./utils/yield-to-event-loop.js";
 
 interface RunOxlintOptions {
   rootDirectory: string;
@@ -333,6 +335,13 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
     // diagnostics. Materializing the file list ahead of time and
     // feeding it through the batch planner keeps each spawn under
     // the timeout and recovers the diagnostics we were dropping.
+    // Hand the event loop back once before the synchronous discovery walk +
+    // cache-hash burst below. The orchestrator forked the security-scan and
+    // supply-chain fibers just before lint, but a forked fiber only runs when
+    // the current one suspends — this is their first chance to start (fire the
+    // Socket.dev requests, begin the scan walk) instead of stalling until the
+    // first oxlint spawn.
+    await yieldToEventLoop();
     // Only a full scan pays the walk — diff / staged scans pass
     // explicit paths.
     const sizedScanFiles =
@@ -441,10 +450,14 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       const cache = createFileLintCache(resolveReactDoctorCacheDir(rootDirectory), rulesetHash);
 
       // Partition candidates by content hash. An unreadable file (no hash) is
-      // treated as a miss and re-linted.
+      // treated as a miss and re-linted. Hashing reads every candidate's whole
+      // content, so the loop yields on the cooperative time budget — otherwise
+      // this pre-spawn burst starves the forked security-scan / supply-chain
+      // fibers (and sibling projects) until the first oxlint spawn.
       const cacheKeyByFile = new Map<string, string>();
       const missFiles: string[] = [];
       const replayedDiagnostics: Diagnostic[] = [];
+      let hashSliceStartedAt = performance.now();
       for (const candidateFile of candidateFiles) {
         const contentHash = hashFileContents(path.resolve(rootDirectory, candidateFile));
         if (contentHash === null) {
@@ -456,6 +469,10 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
         const cachedDiagnostics = cache.lookup(cacheKey);
         if (cachedDiagnostics === null) missFiles.push(candidateFile);
         else replayedDiagnostics.push(...cachedDiagnostics);
+        if (performance.now() - hashSliceStartedAt >= COOPERATIVE_YIELD_BUDGET_MS) {
+          await yieldToEventLoop();
+          hashSliceStartedAt = performance.now();
+        }
       }
       const cacheHitFileCount = candidateFiles.length - missFiles.length;
 
diff --git a/packages/core/tests/check-security-scan.test.ts b/packages/core/tests/check-security-scan.test.ts
index d9fd7e0097..798063fc91 100644
--- a/packages/core/tests/check-security-scan.test.ts
+++ b/packages/core/tests/check-security-scan.test.ts
@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
-import { checkSecurityScan } from "@react-doctor/core";
+import { checkSecurityScan, checkSecurityScanCooperative } from "@react-doctor/core";
 import type { Diagnostic } from "@react-doctor/core";
 import { REACT_DOCTOR_RULES } from "oxlint-plugin-react-doctor";
 
@@ -236,6 +236,17 @@ describe("checkSecurityScan", () => {
     });
   });
 
+  describe("cooperative driver", () => {
+    it("produces the same diagnostics, in the same order, as the sync driver", async () => {
+      const fixtureDirectory = path.join(FIXTURES_DIRECTORY, "eva-mintlify-docs-platform");
+      const syncDiagnostics = checkSecurityScan(fixtureDirectory);
+      expect(syncDiagnostics.length).toBeGreaterThan(0);
+      await expect(checkSecurityScanCooperative(fixtureDirectory)).resolves.toEqual(
+        syncDiagnostics,
+      );
+    });
+  });
+
   describe("supabase-rls-policy-risk regressions", () => {
     it("conservatively flags IF EXISTS disable-RLS (cross-migration drop state not tracked)", () => {
       // The per-file scan can't see that an earlier migration dropped the table,

From 173cc0a8ba5578229e3832b2167d3f7a5386c91b Mon Sep 17 00:00:00 2001
From: "devin-ai-integration[bot]"
 <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Fri, 3 Jul 2026 16:45:30 -0700
Subject: [PATCH 14/33] fix(rules): four false-positive fixes from corpus
 census + adversarial triage, plus slow-oracle hardening (#1032)

Co-authored-by: Aiden Bai <aiden.bai05@gmail.com>
---
 .changeset/array-index-aliased-placeholder.md |   5 +
 .changeset/button-has-type-as-const.md        |   5 +
 .changeset/checked-requires-disabled-fp.md    |  10 ++
 .changeset/differential-upstream-fp-fixes.md  |  26 ++++
 .changeset/display-name-block-body-factory.md |   5 +
 .../exhaustive-deps-ref-current-chain.md      |  10 ++
 .changeset/modern-corpus-fp-fixes.md          |  10 ++
 ...o-array-index-as-key-composite-identity.md |   5 +
 .../no-derived-state-ref-current-alias.md     |   5 +
 .../no-direct-state-mutation-callback-ref.md  |   5 +
 .../no-initialize-state-cleanup-resource.md   |   5 +
 .changeset/no-initialize-state-new-date.md    |   5 +
 .../no-initialize-state-observer-callback.md  |   5 +
 ...o-reset-all-state-subscription-callback.md |   5 +
 .../rn-no-raw-text-preview-whitespace.md      |   5 +
 .changeset/six-messages-stop-overclaiming.md  |   5 +
 ...--wrapped-roles-svg-and-dynamic-values.tsx |  29 ++++
 .../button-has-type--as-const-valid-type.tsx  |  10 ++
 ...nchange-or-readonly--disabled-checkbox.tsx |   9 ++
 ...e-deps--cleanup-ref-and-undefined-deps.tsx |  30 ++++
 ...xhaustive-deps--prop-ref-current-chain.tsx |  20 +++
 ...xtjs-missing-metadata--use-client-page.tsx |  22 +++
 ...x-as-key--aliased-placeholder-receiver.tsx |  13 ++
 ...-index-as-key--composite-item-identity.tsx |  33 +++++
 ...d-state--ref-current-alias-measurement.tsx |  26 ++++
 ...-state-mutation--callback-ref-dom-node.tsx |  13 ++
 ...alize-state--cleanup-disposed-resource.tsx |  20 +++
 .../no-initialize-state--new-date-clock.tsx   |  14 ++
 ...ialize-state--observer-callback-setter.tsx |  14 ++
 ...op-change--subscription-callback-reset.tsx |  19 +++
 ...ation-mismatch-time--og-image-response.tsx |  15 ++
 ...-hooks--anonymous-use-and-ternary-test.tsx |  18 +++
 ...tch-without-revalidate--og-asset-fetch.tsx |  15 ++
 ...independent-await--request-scoped-apis.tsx |  29 ++++
 .../fuzz/src/ast-equivalent-fuzz-variants.ts  |  90 ++++++++++++
 packages/fuzz/src/constants.ts                |   5 +
 packages/fuzz/src/fuzz-rule.ts                |  37 +++--
 .../img-redundant-alt.regressions.test.ts     |  25 ++++
 .../plugin/rules/a11y/img-redundant-alt.ts    |  10 +-
 ...ia-hidden-on-focusable.regressions.test.ts |  23 +++
 .../rules/a11y/no-aria-hidden-on-focusable.ts |   3 +-
 ...oninteractive-tabindex.regressions.test.ts |  14 ++
 .../rules/a11y/no-noninteractive-tabindex.ts  |  31 ++++
 ...c-element-interactions.regressions.test.ts |  37 +++++
 .../a11y/no-static-element-interactions.ts    |  12 +-
 .../no-render-in-render.regressions.test.ts   |  13 ++
 .../rules/architecture/no-render-in-render.ts |   4 +-
 .../correctness/no-array-index-as-key.test.ts | 118 ++++++++++++++++
 .../correctness/no-array-index-as-key.ts      | 114 ++++++++++++---
 ...extjs-missing-metadata.regressions.test.ts |  32 +++++
 .../rules/nextjs/nextjs-missing-metadata.ts   |  10 ++
 ...ydration-mismatch-time.regressions.test.ts |  25 ++++
 .../rendering-hydration-mismatch-time.ts      |   5 +
 .../button-has-type.regressions.test.ts       |  30 ++++
 .../rules/react-builtins/button-has-type.ts   |   4 +-
 ...s-onchange-or-readonly.regressions.test.ts |  20 +++
 .../checked-requires-onchange-or-readonly.ts  |  27 +++-
 .../display-name.regressions.test.ts          |  29 ++++
 .../rules/react-builtins/display-name.ts      |   5 +-
 .../exhaustive-deps.regressions.test.ts       | 132 ++++++++++++++++++
 .../rules/react-builtins/exhaustive-deps.ts   | 129 ++++++++++++-----
 ...-direct-mutation-state.regressions.test.ts |  34 +++++
 .../no-direct-mutation-state.ts               |   2 +-
 .../rules-of-hooks.regressions.test.ts        |  44 ++++++
 .../rules/react-builtins/rules-of-hooks.ts    |   9 +-
 .../rn-no-dimensions-get.regressions.test.ts  |  18 +++
 .../react-native/rn-no-dimensions-get.ts      |   2 +-
 .../rules/react-native/rn-no-raw-text.test.ts |  14 ++
 .../rules/react-native/rn-no-raw-text.ts      |  10 +-
 ...tch-without-revalidate.regressions.test.ts |  60 ++++++++
 .../server/server-fetch-without-revalidate.ts |  33 ++++-
 ...o-mutable-module-state.regressions.test.ts |  27 ++++
 .../server/server-no-mutable-module-state.ts  |   2 +-
 ...tial-independent-await.regressions.test.ts |  55 ++++++++
 .../server-sequential-independent-await.ts    |  80 ++++++-----
 .../no-derived-state.regressions.test.ts      |  63 +++++++++
 ...-direct-state-mutation.regressions.test.ts |  60 ++++++++
 .../no-direct-state-mutation.ts               |  33 ++++-
 .../no-initialize-state.regressions.test.ts   | 116 +++++++++++++++
 .../state-and-effects/no-initialize-state.ts  |  85 +++++++++++
 ...l-state-on-prop-change.regressions.test.ts |  46 ++++++
 .../no-reset-all-state-on-prop-change.ts      |  21 ++-
 .../state-and-effects/utils/effect/ast.ts     |  35 +++++
 ...n-missing-invalidation.regressions.test.ts |  16 +++
 .../query-mutation-missing-invalidation.ts    |   2 +-
 .../contains-non-deterministic-source.ts      |  12 ++
 .../plugin/utils/reads-post-mount-value.ts    |  61 +++++++-
 87 files changed, 2258 insertions(+), 131 deletions(-)
 create mode 100644 .changeset/array-index-aliased-placeholder.md
 create mode 100644 .changeset/button-has-type-as-const.md
 create mode 100644 .changeset/checked-requires-disabled-fp.md
 create mode 100644 .changeset/differential-upstream-fp-fixes.md
 create mode 100644 .changeset/display-name-block-body-factory.md
 create mode 100644 .changeset/exhaustive-deps-ref-current-chain.md
 create mode 100644 .changeset/modern-corpus-fp-fixes.md
 create mode 100644 .changeset/no-array-index-as-key-composite-identity.md
 create mode 100644 .changeset/no-derived-state-ref-current-alias.md
 create mode 100644 .changeset/no-direct-state-mutation-callback-ref.md
 create mode 100644 .changeset/no-initialize-state-cleanup-resource.md
 create mode 100644 .changeset/no-initialize-state-new-date.md
 create mode 100644 .changeset/no-initialize-state-observer-callback.md
 create mode 100644 .changeset/no-reset-all-state-subscription-callback.md
 create mode 100644 .changeset/rn-no-raw-text-preview-whitespace.md
 create mode 100644 .changeset/six-messages-stop-overclaiming.md
 create mode 100644 packages/fuzz/corpus/regressions/a11y--wrapped-roles-svg-and-dynamic-values.tsx
 create mode 100644 packages/fuzz/corpus/regressions/button-has-type--as-const-valid-type.tsx
 create mode 100644 packages/fuzz/corpus/regressions/checked-requires-onchange-or-readonly--disabled-checkbox.tsx
 create mode 100644 packages/fuzz/corpus/regressions/exhaustive-deps--cleanup-ref-and-undefined-deps.tsx
 create mode 100644 packages/fuzz/corpus/regressions/exhaustive-deps--prop-ref-current-chain.tsx
 create mode 100644 packages/fuzz/corpus/regressions/nextjs-missing-metadata--use-client-page.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-array-index-as-key--aliased-placeholder-receiver.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-array-index-as-key--composite-item-identity.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-derived-state--ref-current-alias-measurement.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-direct-state-mutation--callback-ref-dom-node.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-initialize-state--cleanup-disposed-resource.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-initialize-state--new-date-clock.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-initialize-state--observer-callback-setter.tsx
 create mode 100644 packages/fuzz/corpus/regressions/no-reset-all-state-on-prop-change--subscription-callback-reset.tsx
 create mode 100644 packages/fuzz/corpus/regressions/rendering-hydration-mismatch-time--og-image-response.tsx
 create mode 100644 packages/fuzz/corpus/regressions/rules-of-hooks--anonymous-use-and-ternary-test.tsx
 create mode 100644 packages/fuzz/corpus/regressions/server-fetch-without-revalidate--og-asset-fetch.tsx
 create mode 100644 packages/fuzz/corpus/regressions/server-sequential-independent-await--request-scoped-apis.tsx
 create mode 100644 packages/fuzz/src/ast-equivalent-fuzz-variants.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.regressions.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.regressions.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.regressions.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.regressions.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.regressions.test.ts

diff --git a/.changeset/array-index-aliased-placeholder.md b/.changeset/array-index-aliased-placeholder.md
new file mode 100644
index 0000000000..d008cb3264
--- /dev/null
+++ b/.changeset/array-index-aliased-placeholder.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-array-index-as-key: stop flagging index keys when the mapped receiver is a variable holding a static placeholder array (`const list = Array.from({ length: 3 }); list.map(...)`) — the binding is now resolved to its initializer, matching the existing inline `Array.from({ length: N })` exemption.
diff --git a/.changeset/button-has-type-as-const.md b/.changeset/button-has-type-as-const.md
new file mode 100644
index 0000000000..1890454a8f
--- /dev/null
+++ b/.changeset/button-has-type-as-const.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+button-has-type: stop flagging `type` values wrapped in TS assertion expressions (`"submit" as const`, `satisfies`) — the wrapper is stripped before proving validity, so a local `const kind = "submit" as const` now resolves like the bare literal; invalid values under a wrapper stay flagged.
diff --git a/.changeset/checked-requires-disabled-fp.md b/.changeset/checked-requires-disabled-fp.md
new file mode 100644
index 0000000000..e3eadafc23
--- /dev/null
+++ b/.changeset/checked-requires-disabled-fp.md
@@ -0,0 +1,10 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+fix(react-builtins): `checked-requires-onchange-or-readonly` no longer flags
+statically disabled checkboxes (`<input type="checkbox" checked={x} disabled />`).
+Users can't toggle a disabled input, so no `onChange` is needed — React's own
+controlled-checkbox runtime warning exempts `disabled` the same way. A dynamic
+`disabled={cond}` still reports, since the input can be enabled at runtime.
+Found by corpus census triage.
diff --git a/.changeset/differential-upstream-fp-fixes.md b/.changeset/differential-upstream-fp-fixes.md
new file mode 100644
index 0000000000..336646e25f
--- /dev/null
+++ b/.changeset/differential-upstream-fp-fixes.md
@@ -0,0 +1,26 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+fix: six false-positive classes found by differential testing against the
+upstream ESLint plugins over an OSS corpus:
+
+- `exhaustive-deps`: cleanup `ref.current` reads no longer warn when the ref
+  is assigned via a callback anywhere in the component, and an explicit
+  `undefined` deps argument is treated like an omitted one for effect hooks
+  (upstream parity; `null` still reports as a non-array deps list).
+- `no-static-element-interactions`: a string-literal role wrapped in a JSX
+  expression container (`role={'link'}`) now counts as a role, and `<svg>`
+  is skipped — it has the implicit `graphics-document` role, so it isn't
+  static (upstream parity).
+- `no-aria-hidden-on-focusable`: dynamic `aria-hidden` expressions
+  (`aria-hidden={!interactive || undefined}`) are no longer treated as
+  literal `true`.
+- `img-redundant-alt`: hyphens and underscores are word-continuation
+  characters, so `alt="image-left-top"` and `alt="my_image_1"` no longer
+  match the redundant word "image".
+- `no-noninteractive-tabindex`: the roving-tabindex pattern
+  (`tabIndex={active ? 0 : -1}`) is no longer flagged.
+- `rules-of-hooks`: hooks in anonymous callbacks with no resolved name are
+  skipped (upstream's conservative approach), and a hook call in a ternary
+  test position is no longer treated as conditional.
diff --git a/.changeset/display-name-block-body-factory.md b/.changeset/display-name-block-body-factory.md
new file mode 100644
index 0000000000..1d23e4fde1
--- /dev/null
+++ b/.changeset/display-name-block-body-factory.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+display-name: a curried component factory now reports consistently whether the outer arrow uses an expression body (`(order) => (props) => <X />`) or a block body with an explicit return — the block-body shape was silently skipped (found by the metamorphic arrow-body fuzz oracle).
diff --git a/.changeset/exhaustive-deps-ref-current-chain.md b/.changeset/exhaustive-deps-ref-current-chain.md
new file mode 100644
index 0000000000..70740f9d9a
--- /dev/null
+++ b/.changeset/exhaustive-deps-ref-current-chain.md
@@ -0,0 +1,10 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+fix(react-builtins): `exhaustive-deps` now truncates captured member chains at
+`.current` (e.g. `textareaRef.current.style.height` → `textareaRef`), matching
+upstream eslint-plugin-react-hooks. Previously an effect reading a prop-passed
+ref reported mutable `.current` paths as "stale" dependencies and effectively
+told users to add `ref.current.*` values to the deps array, which is never
+valid. Found by corpus census triage.
diff --git a/.changeset/modern-corpus-fp-fixes.md b/.changeset/modern-corpus-fp-fixes.md
new file mode 100644
index 0000000000..ca1f06788b
--- /dev/null
+++ b/.changeset/modern-corpus-fp-fixes.md
@@ -0,0 +1,10 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+Fix false positives found on a fresh React 19 / RSC / Next.js 15 corpus:
+
+- `server-sequential-independent-await` no longer flags awaits of Next.js request-scoped APIs (`headers()`, `cookies()`, `draftMode()`, `connection()`, next-intl server helpers) or awaits of already-existing promises such as Next.js 15 `props.params` / `props.searchParams`.
+- `server-fetch-without-revalidate` no longer flags the documented `next/og` static-asset fetch (`fetch(new URL(..., import.meta.url))`) or Remix / React Router `app/` route files, where the Next.js data cache never applies.
+- `rendering-hydration-mismatch-time` no longer flags time/random values in JSX rasterized by `ImageResponse` / satori (og images never hydrate).
+- `nextjs-missing-metadata` no longer flags `"use client"` pages, which cannot export `metadata` / `generateMetadata`.
diff --git a/.changeset/no-array-index-as-key-composite-identity.md b/.changeset/no-array-index-as-key-composite-identity.md
new file mode 100644
index 0000000000..1ee95e1fd5
--- /dev/null
+++ b/.changeset/no-array-index-as-key-composite-identity.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-array-index-as-key: recognize composite keys whose per-item identity comes from a destructured callback field (`({ message }, index) => key={`${message} ${index}`}`) or a method call on the item (`key={`${index}-${color.toHexString()}`}`) — the index is just a uniqueness fallback there; composite keys with no item-derived part stay flagged. Also extend the static-placeholder exemption to `Array.from({length: values.length}, …)` and to numeric `for (let i = 0; …)` loop counters — both imperative twins of the already-exempt `Array(N)` placeholder; a manually incremented index over real items stays flagged.
diff --git a/.changeset/no-derived-state-ref-current-alias.md b/.changeset/no-derived-state-ref-current-alias.md
new file mode 100644
index 0000000000..5f6b6b389f
--- /dev/null
+++ b/.changeset/no-derived-state-ref-current-alias.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-derived-state (and the shared post-mount-read detector): recognize layout measurements read through a local alias of a ref's `.current` (`const el = contentRef.current; setX(el.scrollHeight > max)`) as deferred DOM measurements, not derived state.
diff --git a/.changeset/no-direct-state-mutation-callback-ref.md b/.changeset/no-direct-state-mutation-callback-ref.md
new file mode 100644
index 0000000000..703a304593
--- /dev/null
+++ b/.changeset/no-direct-state-mutation-callback-ref.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-direct-state-mutation: stop flagging in-place writes to a callback-ref target. When a `useState` setter is passed straight to a JSX `ref` attribute (`ref={setNode}`), the paired state holds a DOM element / component instance, so `node.dataset.x = ...` or `node.style.x = ...` is deliberate imperative DOM work, not a lost state update. The wangeditor `useState(null)` + effect-mutation bug (whose ref comes from a separate `useRef`) stays flagged.
diff --git a/.changeset/no-initialize-state-cleanup-resource.md b/.changeset/no-initialize-state-cleanup-resource.md
new file mode 100644
index 0000000000..d973bf5d10
--- /dev/null
+++ b/.changeset/no-initialize-state-cleanup-resource.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-initialize-state: stop flagging mount effects that seed state from a resource their cleanup disposes. When the setter argument derives from an effect-local binding referenced by the returned cleanup (`const audioContext = new AudioContext(); setGainNode(audioContext.createGain()); return () => audioContext.close();` — same shape for WebSockets, editors, observers), the effect owns a resource lifecycle and the value cannot be hoisted into `useState(initial)` because render has no matching dispose slot. Deterministic inits beside an unrelated cleanup (`setCount(42)` next to a `clearInterval` cleanup) keep firing.
diff --git a/.changeset/no-initialize-state-new-date.md b/.changeset/no-initialize-state-new-date.md
new file mode 100644
index 0000000000..13252e0952
--- /dev/null
+++ b/.changeset/no-initialize-state-new-date.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-initialize-state: stop flagging mount effects that seed state from a zero-arg `new Date()` (e.g. an SSR-safe live clock's `setNow(new Date().toLocaleTimeString())`) — it captures the current instant like `Date.now()`, which was already exempt; `new Date(value)` stays flagged.
diff --git a/.changeset/no-initialize-state-observer-callback.md b/.changeset/no-initialize-state-observer-callback.md
new file mode 100644
index 0000000000..ac2cb82e73
--- /dev/null
+++ b/.changeset/no-initialize-state-observer-callback.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-initialize-state: stop flagging setters that only fire from a callback argument of an effect-local instance (`const observer = new MutationObserver((m) => setEntryCount(m.length)); observer.observe(...)`). The eventual-call resolver treated a callback passed to a constructor or factory as the binding's own call graph, so a method call on the instance counted as a synchronous setter call. Function-expression arguments of a binding's initializer call are now excluded from the resolver (hook wrappers like `useCallback(fn, deps)` still count, since calling the binding runs the wrapped function). Bare identifier arguments (`debounce(setN)`) are unaffected.
diff --git a/.changeset/no-reset-all-state-subscription-callback.md b/.changeset/no-reset-all-state-subscription-callback.md
new file mode 100644
index 0000000000..286302bd04
--- /dev/null
+++ b/.changeset/no-reset-all-state-subscription-callback.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+no-reset-all-state-on-prop-change: stop flagging effects whose state setters only run inside listener / observer / subscription callbacks — those reset on the external event, not on the prop change.
diff --git a/.changeset/rn-no-raw-text-preview-whitespace.md b/.changeset/rn-no-raw-text-preview-whitespace.md
new file mode 100644
index 0000000000..43bb6fed65
--- /dev/null
+++ b/.changeset/rn-no-raw-text-preview-whitespace.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+rn-no-raw-text: collapse internal whitespace in the quoted raw-text preview so multi-line JSX text produces a single-line message and CRLF vs LF sources report identically (found by the new metamorphic CRLF fuzz oracle).
diff --git a/.changeset/six-messages-stop-overclaiming.md b/.changeset/six-messages-stop-overclaiming.md
new file mode 100644
index 0000000000..650f6b8883
--- /dev/null
+++ b/.changeset/six-messages-stop-overclaiming.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+Reword six diagnostic messages that asserted concrete runtime harm on trigger shapes where the harm does not occur: no-render-in-render (plain render-helper calls do not remount or lose state), no-direct-state-mutation (a setter call after the mutation still redraws), no-direct-mutation-state (setState after the mutation still redraws), server-no-mutable-module-state (a never-written module `let` leaks nothing), query-mutation-missing-invalidation (invalidation can happen at the mutate() call site), and rn-no-dimensions-get (a Dimensions.get() read inside an event handler is fresh, not stale).
diff --git a/packages/fuzz/corpus/regressions/a11y--wrapped-roles-svg-and-dynamic-values.tsx b/packages/fuzz/corpus/regressions/a11y--wrapped-roles-svg-and-dynamic-values.tsx
new file mode 100644
index 0000000000..e8956dd2b6
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/a11y--wrapped-roles-svg-and-dynamic-values.tsx
@@ -0,0 +1,29 @@
+// rule: no-static-element-interactions, no-aria-hidden-on-focusable, img-redundant-alt, no-noninteractive-tabindex
+// weakness: jsx-expression-container-literal, svg-implicit-role, dynamic-aria-hidden, word-boundaries, roving-tabindex
+// source: differential vs eslint-plugin-jsx-a11y (mantine, nivo, next.js examples)
+export const WrappedRole = ({ onClick }: { onClick: () => void }) => (
+  <div role={"link"} onClick={onClick} onKeyDown={onClick} tabIndex={0} />
+);
+
+export const SvgCanvas = ({ onClick }: { onClick: () => void }) => (
+  <svg width="100vw" height="100vh" onClick={onClick} onKeyDown={onClick} />
+);
+
+export const MaybeHiddenControl = ({ interactive }: { interactive: boolean }) => (
+  <button type="button" aria-hidden={!interactive || undefined}>
+    bold
+  </button>
+);
+
+export const PositionedImages = () => (
+  <div>
+    <img src="/hero.png" alt="image-left-top" />
+    <img src="/thumb.png" alt="my_image_1" />
+  </div>
+);
+
+export const RovingTabs = ({ isActive }: { isActive: boolean }) => (
+  <div role="tab" tabIndex={isActive ? 0 : -1}>
+    tab
+  </div>
+);
diff --git a/packages/fuzz/corpus/regressions/button-has-type--as-const-valid-type.tsx b/packages/fuzz/corpus/regressions/button-has-type--as-const-valid-type.tsx
new file mode 100644
index 0000000000..a85bdf405f
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/button-has-type--as-const-valid-type.tsx
@@ -0,0 +1,10 @@
+// rule: button-has-type
+// weakness: ast-shape
+// source: cross-rule consistency audit (TS assertion wrappers around a provably valid type)
+export const SaveButton = () => {
+  const kind = "submit" as const;
+  return <button type={kind}>Save</button>;
+};
+export const InlineSatisfiesButton = () => (
+  <button type={"button" satisfies "button"}>Cancel</button>
+);
diff --git a/packages/fuzz/corpus/regressions/checked-requires-onchange-or-readonly--disabled-checkbox.tsx b/packages/fuzz/corpus/regressions/checked-requires-onchange-or-readonly--disabled-checkbox.tsx
new file mode 100644
index 0000000000..eedb96a6bb
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/checked-requires-onchange-or-readonly--disabled-checkbox.tsx
@@ -0,0 +1,9 @@
+// rule: checked-requires-onchange-or-readonly
+// weakness: control-flow
+// source: corpus census triage (Irev-Dev/cadhub AdminProjects — disabled display-only checkbox)
+export const DisplayOnlyCheckbox = ({ checked }: { checked: boolean }) => (
+  <input type="checkbox" checked={checked} disabled />
+);
+export const ExplicitlyDisabledCheckbox = ({ checked }: { checked: boolean }) => (
+  <input type="checkbox" checked={checked} disabled={true} />
+);
diff --git a/packages/fuzz/corpus/regressions/exhaustive-deps--cleanup-ref-and-undefined-deps.tsx b/packages/fuzz/corpus/regressions/exhaustive-deps--cleanup-ref-and-undefined-deps.tsx
new file mode 100644
index 0000000000..16b2cec6c3
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/exhaustive-deps--cleanup-ref-and-undefined-deps.tsx
@@ -0,0 +1,30 @@
+// rule: exhaustive-deps
+// weakness: cleanup-ref-assignment, explicit-undefined-deps
+// source: differential vs eslint-plugin-react-hooks (seanime video-core-drawer, next.js layout-router)
+import { useEffect, useLayoutEffect, useRef } from "react";
+
+export const DraggableArea = () => {
+  const areaRef = useRef<HTMLDivElement | null>(null);
+  const attach = (node: HTMLDivElement | null) => {
+    areaRef.current = node;
+  };
+  useEffect(() => {
+    const handleMouseDown = () => {};
+    areaRef.current?.addEventListener("mousedown", handleMouseDown);
+    return () => {
+      areaRef.current?.removeEventListener("mousedown", handleMouseDown);
+    };
+  }, []);
+  return <div ref={attach} />;
+};
+
+export const EveryCommitEffect = ({
+  focusAndScrollRef,
+}: {
+  focusAndScrollRef: { apply: boolean };
+}) => {
+  useLayoutEffect(() => {
+    focusAndScrollRef.apply = false;
+  }, undefined);
+  return null;
+};
diff --git a/packages/fuzz/corpus/regressions/exhaustive-deps--prop-ref-current-chain.tsx b/packages/fuzz/corpus/regressions/exhaustive-deps--prop-ref-current-chain.tsx
new file mode 100644
index 0000000000..ed9fac3480
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/exhaustive-deps--prop-ref-current-chain.tsx
@@ -0,0 +1,20 @@
+// rule: exhaustive-deps
+// weakness: copy-tracking
+// source: corpus census triage (guangzhengli/vectorhub ChatInput — prop ref autosize effect)
+import { useEffect } from "react";
+
+export const AutosizeTextarea = ({
+  textareaRef,
+  content,
+}: {
+  textareaRef: React.MutableRefObject<HTMLTextAreaElement | null>;
+  content: string;
+}) => {
+  useEffect(() => {
+    if (textareaRef.current) {
+      textareaRef.current.style.height = "inherit";
+      textareaRef.current.style.height = `${textareaRef.current.scrollHeight}px`;
+    }
+  }, [content, textareaRef]);
+  return <textarea ref={textareaRef} value={content} readOnly />;
+};
diff --git a/packages/fuzz/corpus/regressions/nextjs-missing-metadata--use-client-page.tsx b/packages/fuzz/corpus/regressions/nextjs-missing-metadata--use-client-page.tsx
new file mode 100644
index 0000000000..18f32abf9c
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/nextjs-missing-metadata--use-client-page.tsx
@@ -0,0 +1,22 @@
+// rule: nextjs-missing-metadata
+// weakness: framework-gating
+// source: fresh modern-corpus FP hunt ("use client" pages cannot export metadata)
+"use client";
+
+import { useState } from "react";
+
+export default function ChatPage() {
+  const [messages, setMessages] = useState<string[]>([]);
+  return (
+    <main>
+      <button type="button" onClick={() => setMessages((previous) => [...previous, "hi"])}>
+        Send
+      </button>
+      <ul>
+        {messages.map((message) => (
+          <li key={message}>{message}</li>
+        ))}
+      </ul>
+    </main>
+  );
+}
diff --git a/packages/fuzz/corpus/regressions/no-array-index-as-key--aliased-placeholder-receiver.tsx b/packages/fuzz/corpus/regressions/no-array-index-as-key--aliased-placeholder-receiver.tsx
new file mode 100644
index 0000000000..fe8f2d845e
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-array-index-as-key--aliased-placeholder-receiver.tsx
@@ -0,0 +1,13 @@
+// rule: no-array-index-as-key
+// weakness: copy-tracking
+// source: corpus census (ant-design BannerRecommends skeleton list)
+export const SkeletonRow = () => {
+  const list = Array.from({ length: 3 });
+  return (
+    <div>
+      {list.map((_, index) => (
+        <div key={`skeleton-${index}`} />
+      ))}
+    </div>
+  );
+};
diff --git a/packages/fuzz/corpus/regressions/no-array-index-as-key--composite-item-identity.tsx b/packages/fuzz/corpus/regressions/no-array-index-as-key--composite-item-identity.tsx
new file mode 100644
index 0000000000..77736eb529
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-array-index-as-key--composite-item-identity.tsx
@@ -0,0 +1,33 @@
+// rule: no-array-index-as-key
+// weakness: ast-shape
+// source: cross-rule consistency audit (Irev-Dev/cadhub IdeConsole, ant-design ColorPresets)
+export const ConsoleMessages = ({ messages }: { messages: { message: string; time: Date }[] }) => (
+  <div>
+    {messages.map(({ message, time }, index) => (
+      <Entry key={`${message} ${index}`} time={time} />
+    ))}
+  </div>
+);
+export const ColorSwatches = ({ colors }: { colors: { toHexString: () => string }[] }) => (
+  <div>
+    {colors.map((presetColor, index) => (
+      <Swatch key={`preset-${index}-${presetColor.toHexString()}`} />
+    ))}
+  </div>
+);
+export const SliderThumbs = ({ values }: { values: number[] }) => (
+  <div>
+    {Array.from({ length: values.length }, (_, index) => (
+      <Swatch key={index} />
+    ))}
+  </div>
+);
+export const PlaygroundGrid = ({ count }: { count: number }) => {
+  const cols = [];
+  for (let i = 0; i < count; i++) {
+    cols.push(<Swatch key={i} />);
+  }
+  return <div>{cols}</div>;
+};
+declare const Entry: (props: { key?: string; time: Date }) => null;
+declare const Swatch: (props: { key?: string }) => null;
diff --git a/packages/fuzz/corpus/regressions/no-derived-state--ref-current-alias-measurement.tsx b/packages/fuzz/corpus/regressions/no-derived-state--ref-current-alias-measurement.tsx
new file mode 100644
index 0000000000..88ed750ad7
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-derived-state--ref-current-alias-measurement.tsx
@@ -0,0 +1,26 @@
+// rule: no-derived-state
+// weakness: ref-current-alias
+// source: RDE fizz run (posthog CollapsibleContent — layout read through a local alias)
+import { useEffect, useRef, useState } from "react";
+
+export const CollapsibleContent = ({
+  maxHeight,
+  children,
+}: {
+  maxHeight: number;
+  children: React.ReactNode;
+}) => {
+  const [isOverflowing, setIsOverflowing] = useState(false);
+  const contentRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    const el = contentRef.current;
+    if (el) {
+      setIsOverflowing(el.scrollHeight > maxHeight);
+    }
+  }, [children, maxHeight]);
+  return (
+    <div ref={contentRef} data-overflowing={isOverflowing}>
+      {children}
+    </div>
+  );
+};
diff --git a/packages/fuzz/corpus/regressions/no-direct-state-mutation--callback-ref-dom-node.tsx b/packages/fuzz/corpus/regressions/no-direct-state-mutation--callback-ref-dom-node.tsx
new file mode 100644
index 0000000000..19582af274
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-direct-state-mutation--callback-ref-dom-node.tsx
@@ -0,0 +1,13 @@
+// rule: no-direct-state-mutation
+// weakness: library-idiom
+// source: adversarial edge-case hunt (callback-ref DOM node written to imperatively)
+import { useEffect, useState } from "react";
+
+export const CallbackRefCounter = () => {
+  const [node, setNode] = useState<HTMLSpanElement | null>(null);
+  useEffect(() => {
+    if (!node) return;
+    node.dataset.mounted = "true";
+  }, [node]);
+  return <span ref={setNode}>ready</span>;
+};
diff --git a/packages/fuzz/corpus/regressions/no-initialize-state--cleanup-disposed-resource.tsx b/packages/fuzz/corpus/regressions/no-initialize-state--cleanup-disposed-resource.tsx
new file mode 100644
index 0000000000..8139a5ced6
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-initialize-state--cleanup-disposed-resource.tsx
@@ -0,0 +1,20 @@
+// rule: no-initialize-state
+// weakness: library-idiom
+// source: adversarial edge-case hunt (mount effect seeding state from a resource its cleanup disposes)
+import { useEffect, useState } from "react";
+
+export const AudioNodeState = () => {
+  const [gainNode, setGainNode] = useState<GainNode | null>(null);
+  useEffect(() => {
+    if (!gainNode) return;
+    gainNode.gain.value = 0.5;
+  }, [gainNode]);
+  useEffect(() => {
+    const audioContext = new AudioContext();
+    setGainNode(audioContext.createGain());
+    return () => {
+      audioContext.close();
+    };
+  }, []);
+  return null;
+};
diff --git a/packages/fuzz/corpus/regressions/no-initialize-state--new-date-clock.tsx b/packages/fuzz/corpus/regressions/no-initialize-state--new-date-clock.tsx
new file mode 100644
index 0000000000..48f8d34b09
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-initialize-state--new-date-clock.tsx
@@ -0,0 +1,14 @@
+// rule: no-initialize-state
+// weakness: library-idiom
+// source: adversarial edge-case hunt (SSR-safe live clock seeded on mount)
+import { useEffect, useState } from "react";
+
+export const Clock = () => {
+  const [now, setNow] = useState<string | null>(null);
+  useEffect(() => {
+    setNow(new Date().toLocaleTimeString());
+    const interval = window.setInterval(() => setNow(new Date().toLocaleTimeString()), 1000);
+    return () => window.clearInterval(interval);
+  }, []);
+  return <time>{now}</time>;
+};
diff --git a/packages/fuzz/corpus/regressions/no-initialize-state--observer-callback-setter.tsx b/packages/fuzz/corpus/regressions/no-initialize-state--observer-callback-setter.tsx
new file mode 100644
index 0000000000..b6814c43d6
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-initialize-state--observer-callback-setter.tsx
@@ -0,0 +1,14 @@
+// rule: no-initialize-state
+// weakness: callback-argument call graph
+// source: adversarial edge-case hunt (setter fired only from an observer callback in a mount effect)
+import { useEffect, useState } from "react";
+
+export const ObserverConnected = () => {
+  const [entryCount, setEntryCount] = useState(0);
+  useEffect(() => {
+    const observer = new MutationObserver((mutations) => setEntryCount(mutations.length));
+    observer.observe(document.body, { childList: true });
+    return () => observer.disconnect();
+  }, []);
+  return <output>{entryCount}</output>;
+};
diff --git a/packages/fuzz/corpus/regressions/no-reset-all-state-on-prop-change--subscription-callback-reset.tsx b/packages/fuzz/corpus/regressions/no-reset-all-state-on-prop-change--subscription-callback-reset.tsx
new file mode 100644
index 0000000000..74f537a850
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/no-reset-all-state-on-prop-change--subscription-callback-reset.tsx
@@ -0,0 +1,19 @@
+// rule: no-reset-all-state-on-prop-change
+// weakness: setter-inside-subscription-callback
+// source: RDE fizz run (excalidraw ToolPopover — emitter subscription reset)
+import { useEffect, useState } from "react";
+
+export const ToolPopover = ({
+  app,
+}: {
+  app: { onPointerDownEmitter: { on: (fn: () => void) => (() => void) | undefined } };
+}) => {
+  const [isPopupOpen, setIsPopupOpen] = useState(false);
+  useEffect(() => {
+    const unsubscribe = app.onPointerDownEmitter.on(() => {
+      setIsPopupOpen(false);
+    });
+    return () => unsubscribe?.();
+  }, [app]);
+  return <div>{String(isPopupOpen)}</div>;
+};
diff --git a/packages/fuzz/corpus/regressions/rendering-hydration-mismatch-time--og-image-response.tsx b/packages/fuzz/corpus/regressions/rendering-hydration-mismatch-time--og-image-response.tsx
new file mode 100644
index 0000000000..9e1c590449
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/rendering-hydration-mismatch-time--og-image-response.tsx
@@ -0,0 +1,15 @@
+// rule: rendering-hydration-mismatch-time
+// weakness: framework-gating
+// source: fresh modern-corpus FP hunt (JSX rasterized by next/og never hydrates)
+import { ImageResponse } from "next/og";
+
+declare const formatDate: (date: Date) => string;
+
+export async function GET() {
+  return new ImageResponse(
+    <div style={{ display: "flex", flexDirection: "column" }}>
+      <p>Status report</p>
+      <p>{formatDate(new Date())}</p>
+    </div>,
+  );
+}
diff --git a/packages/fuzz/corpus/regressions/rules-of-hooks--anonymous-use-and-ternary-test.tsx b/packages/fuzz/corpus/regressions/rules-of-hooks--anonymous-use-and-ternary-test.tsx
new file mode 100644
index 0000000000..bcda8353c6
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/rules-of-hooks--anonymous-use-and-ternary-test.tsx
@@ -0,0 +1,18 @@
+// rule: rules-of-hooks
+// weakness: anonymous-callback-use, ternary-test-position
+// source: differential vs eslint-plugin-react-hooks
+import { use } from "react";
+import { useFlag } from "./flags";
+
+declare const somePromise: Promise<number>;
+declare const register: (callback: () => number) => void;
+
+register(() => {
+  const value = use(somePromise);
+  return value;
+});
+
+export const FlagLabel = () => {
+  const label = useFlag("beta") ? "beta" : "stable";
+  return <span>{label}</span>;
+};
diff --git a/packages/fuzz/corpus/regressions/server-fetch-without-revalidate--og-asset-fetch.tsx b/packages/fuzz/corpus/regressions/server-fetch-without-revalidate--og-asset-fetch.tsx
new file mode 100644
index 0000000000..76a5e63435
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/server-fetch-without-revalidate--og-asset-fetch.tsx
@@ -0,0 +1,15 @@
+// rule: server-fetch-without-revalidate
+// weakness: library-idiom
+// source: fresh modern-corpus FP hunt (next/og static-asset fetch + Remix app/ routes)
+import { ImageResponse } from "next/og";
+
+export async function GET(request: Request) {
+  const fontMonoRegular = await fetch(
+    new URL("../../public/fonts/RobotoMono-Regular.ttf", import.meta.url),
+  ).then((res) => res.arrayBuffer());
+  const { searchParams } = new URL(request.url);
+  const title = searchParams.get("title") ?? "Status";
+  return new ImageResponse(<div style={{ fontFamily: "Roboto Mono" }}>{title}</div>, {
+    fonts: [{ name: "Roboto Mono", data: fontMonoRegular, style: "normal" }],
+  });
+}
diff --git a/packages/fuzz/corpus/regressions/server-sequential-independent-await--request-scoped-apis.tsx b/packages/fuzz/corpus/regressions/server-sequential-independent-await--request-scoped-apis.tsx
new file mode 100644
index 0000000000..33312473c3
--- /dev/null
+++ b/packages/fuzz/corpus/regressions/server-sequential-independent-await--request-scoped-apis.tsx
@@ -0,0 +1,29 @@
+// rule: server-sequential-independent-await
+// weakness: library-idiom
+// source: fresh modern-corpus FP hunt (Next.js 15 request-scoped async APIs)
+import { headers } from "next/headers";
+import { getTranslations } from "next-intl/server";
+
+declare const db: { findCounter: (id: number) => Promise<number> };
+
+interface PageProps {
+  params: Promise<{ slug: string }>;
+  searchParams: Promise<Record<string, string>>;
+}
+
+export default async function Page(props: PageProps) {
+  const t = await getTranslations("CurrentCount");
+  const headersList = await headers();
+  const id = Number(headersList.get("x-e2e-random-id")) || 0;
+  const count = await db.findCounter(id);
+  const searchParams = await props.searchParams;
+  const { slug } = await props.params;
+  return (
+    <main>
+      <h1>{t("title")}</h1>
+      <p>
+        {slug}: {count} ({searchParams.view})
+      </p>
+    </main>
+  );
+}
diff --git a/packages/fuzz/src/ast-equivalent-fuzz-variants.ts b/packages/fuzz/src/ast-equivalent-fuzz-variants.ts
new file mode 100644
index 0000000000..c53d75fcb1
--- /dev/null
+++ b/packages/fuzz/src/ast-equivalent-fuzz-variants.ts
@@ -0,0 +1,90 @@
+import { parseFixture } from "../../oxlint-plugin-react-doctor/src/test-utils/parse-fixture.js";
+import type { EquivalentVariant } from "./equivalent-fuzz-variants.js";
+
+interface SpannedNode {
+  start?: number;
+  end?: number;
+  type?: string;
+}
+
+const getTopLevelStatementSpans = (
+  code: string,
+  filename: string,
+): Array<{ start: number; end: number }> => {
+  try {
+    const { program, errors } = parseFixture(code, { filename, forceJsx: true });
+    if (errors.length > 0) return [];
+    const body = (program as unknown as { body?: SpannedNode[] }).body ?? [];
+    const spans: Array<{ start: number; end: number }> = [];
+    for (const statement of body) {
+      if (typeof statement.start !== "number" || typeof statement.end !== "number") return [];
+      spans.push({ start: statement.start, end: statement.end });
+    }
+    return spans;
+  } catch {
+    return [];
+  }
+};
+
+const spliceBetweenStatements = (
+  code: string,
+  spans: ReadonlyArray<{ start: number; end: number }>,
+  separator: string,
+): string => {
+  let result = "";
+  let cursor = 0;
+  for (let index = 0; index < spans.length; index += 1) {
+    const span = spans[index];
+    result += code.slice(cursor, span.end);
+    cursor = span.end;
+    if (index < spans.length - 1) result += separator;
+  }
+  result += code.slice(cursor);
+  return result;
+};
+
+// CRLF conversion changes the VALUE of multi-line template literals and
+// line-continuation strings, so those programs are excluded rather than
+// producing a semantics-changing "equivalent".
+const isCrlfSafe = (code: string): boolean => !code.includes("`") && !code.includes("\\\n");
+
+// AST-derived semantics-preserving rewrites for ANY parseable program
+// (including verbatim corpus files, which have no generator-provided
+// section list): splices land exactly between top-level statements, so
+// they can never fall inside a template literal or JSX text.
+export const buildAstEquivalentFuzzVariants = (
+  code: string,
+  filename: string,
+): EquivalentVariant[] => {
+  const variants: EquivalentVariant[] = [];
+  if (isCrlfSafe(code) && code.includes("\n")) {
+    variants.push({
+      label: "CRLF line endings",
+      code: code.replace(/\r?\n/g, "\r\n"),
+    });
+  }
+  const spans = getTopLevelStatementSpans(code, filename);
+  if (spans.length > 1) {
+    const doAllGapsContainNewline = spans.every(
+      (span, index) =>
+        index === spans.length - 1 || code.slice(span.end, spans[index + 1].start).includes("\n"),
+    );
+    if (doAllGapsContainNewline) {
+      variants.push({
+        label: "line comments between top-level statements",
+        code: spliceBetweenStatements(code, spans, "\n// metamorphic statement separator"),
+      });
+    }
+    variants.push(
+      {
+        label: "block comments between top-level statements",
+        code: spliceBetweenStatements(code, spans, "\n/* metamorphic\n   statement separator */"),
+      },
+      {
+        label: "blank lines between top-level statements",
+        code: spliceBetweenStatements(code, spans, "\n\n\n"),
+      },
+    );
+  }
+  return variants;
+};
diff --git a/packages/fuzz/src/constants.ts b/packages/fuzz/src/constants.ts
index aa2121ece4..6c9c276970 100644
--- a/packages/fuzz/src/constants.ts
+++ b/packages/fuzz/src/constants.ts
@@ -1,6 +1,11 @@
 export const DEFAULT_FUZZ_ITERATIONS = 25;
 export const DEFAULT_FUZZ_SEED = 1;
 export const SLOW_RULE_THRESHOLD_MS = 2_000;
+// A slow measurement is only a finding if the program stays slow across
+// this many re-runs of the same code (fastest time wins). Filters out
+// wall-clock spikes from CPU contention that masquerade as pathological
+// inputs.
+export const SLOW_VERIFY_RERUN_COUNT = 2;
 export const NOISE_MUTATION_PROBABILITY = 0.4;
 export const MAX_NOISE_MUTATIONS = 3;
 // One iteration in ~8 produces a pathological-shape program (deep JSX,
diff --git a/packages/fuzz/src/fuzz-rule.ts b/packages/fuzz/src/fuzz-rule.ts
index 31595f2ff9..a1d5fd1803 100644
--- a/packages/fuzz/src/fuzz-rule.ts
+++ b/packages/fuzz/src/fuzz-rule.ts
@@ -9,7 +9,9 @@ import {
   MAX_NOISE_MUTATIONS,
   NOISE_MUTATION_PROBABILITY,
   SLOW_RULE_THRESHOLD_MS,
+  SLOW_VERIFY_RERUN_COUNT,
 } from "./constants.js";
+import { buildAstEquivalentFuzzVariants } from "./ast-equivalent-fuzz-variants.js";
 import { buildEquivalentFuzzVariants } from "./equivalent-fuzz-variants.js";
 import { generateStructuredFuzzProgram } from "./generate-fuzz-program.js";
 import type { FuzzCorpusEntry } from "./load-fuzz-corpus.js";
@@ -147,15 +149,27 @@ export const fuzzRuleWithStats = (
     }
     if ((outcome.diagnosticSignature?.length ?? 0) > 0) stats.firedProgramCount += 1;
     if (outcome.elapsedMs > slowThresholdMs) {
-      findings.push({
-        ruleId,
-        kind: "slow",
-        seed: iterationSeed,
-        iteration,
-        detail: `took ${Math.round(outcome.elapsedMs)}ms (threshold ${slowThresholdMs}ms)`,
-        code,
-        variantLabel,
-      });
+      // Wall-clock spikes from CPU contention (parallel test runs, CI
+      // neighbors) masquerade as pathological rules. Re-run the exact
+      // program and keep the fastest time — a genuinely slow input stays
+      // slow on every run, while a descheduled one drops to milliseconds.
+      let fastestElapsedMs = outcome.elapsedMs;
+      for (let retry = 0; retry < SLOW_VERIFY_RERUN_COUNT; retry += 1) {
+        const rerun = runRuleOnCode(rule, code, filename);
+        if (rerun.elapsedMs < fastestElapsedMs) fastestElapsedMs = rerun.elapsedMs;
+        if (fastestElapsedMs <= slowThresholdMs) break;
+      }
+      if (fastestElapsedMs > slowThresholdMs) {
+        findings.push({
+          ruleId,
+          kind: "slow",
+          seed: iterationSeed,
+          iteration,
+          detail: `took ${Math.round(fastestElapsedMs)}ms verified across reruns (threshold ${slowThresholdMs}ms)`,
+          code,
+          variantLabel,
+        });
+      }
     }
     return outcome;
   };
@@ -205,7 +219,10 @@ export const fuzzRuleWithStats = (
     }
 
     if (!options.checkInvariants || isScanRule || didApplyNoise) continue;
-    for (const variant of buildEquivalentFuzzVariants(code, sections)) {
+    for (const variant of [
+      ...buildEquivalentFuzzVariants(code, sections),
+      ...buildAstEquivalentFuzzVariants(code, filename),
+    ]) {
       if (hasParseErrors(variant.code, filename)) continue;
       const variantOutcome = runRuleOnCode(rule, variant.code, filename);
       if (variantOutcome.crashDetail !== undefined) {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.regressions.test.ts
index 27cba63003..65d320e1cc 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.regressions.test.ts
@@ -90,4 +90,29 @@ describe("a11y/img-redundant-alt regressions", () => {
 
     expect(result.diagnostics.length).toBeGreaterThan(0);
   });
+
+  it("does not flag redundant words joined by hyphens or underscores", () => {
+    const result = runRule(
+      imgRedundantAlt,
+      `export const Page = () => (
+        <div>
+          <img src="/a.png" alt="image-left-top" />
+          <img src="/b.png" alt="my_image_1" />
+        </div>
+      );`,
+      { filename: "/proj/app/page.tsx" },
+    );
+
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a redundant word separated by spaces", () => {
+    const result = runRule(
+      imgRedundantAlt,
+      `export const Page = () => <img src="/a.png" alt="image of a cat" />;`,
+      { filename: "/proj/app/page.tsx" },
+    );
+
+    expect(result.diagnostics).toHaveLength(1);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts
index 4434ca313a..ccc337cd36 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/img-redundant-alt.ts
@@ -34,12 +34,14 @@ const resolveSettings = (
 };
 
 const isWordBoundary = (text: string, start: number, end: number): boolean => {
-  const isAlphanumeric = (charCode: number): boolean =>
+  const isWordCharacter = (charCode: number): boolean =>
     (charCode >= 48 && charCode <= 57) ||
     (charCode >= 65 && charCode <= 90) ||
-    (charCode >= 97 && charCode <= 122);
-  const startsBoundary = start === 0 || !isAlphanumeric(text.charCodeAt(start - 1));
-  const endsBoundary = end === text.length || !isAlphanumeric(text.charCodeAt(end));
+    (charCode >= 97 && charCode <= 122) ||
+    charCode === 45 ||
+    charCode === 95;
+  const startsBoundary = start === 0 || !isWordCharacter(text.charCodeAt(start - 1));
+  const endsBoundary = end === text.length || !isWordCharacter(text.charCodeAt(end));
   return startsBoundary && endsBoundary;
 };
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.regressions.test.ts
new file mode 100644
index 0000000000..45e60871af
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.regressions.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vite-plus/test";
+import { runRule } from "../../../test-utils/run-rule.js";
+import { noAriaHiddenOnFocusable } from "./no-aria-hidden-on-focusable.js";
+
+describe("a11y/no-aria-hidden-on-focusable regressions", () => {
+  it("does not flag a dynamic aria-hidden expression on a focusable element", () => {
+    const result = runRule(
+      noAriaHiddenOnFocusable,
+      `export const A = ({ interactive }) => (
+        <button aria-hidden={!interactive || undefined} type="button">x</button>
+      );`,
+    );
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a literal aria-hidden on a focusable element", () => {
+    const result = runRule(
+      noAriaHiddenOnFocusable,
+      `export const A = () => <button aria-hidden={true} type="button">x</button>;`,
+    );
+    expect(result.diagnostics).toHaveLength(1);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
index 64d3f70282..c0c4d291eb 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
@@ -30,7 +30,8 @@ export const noAriaHiddenOnFocusable = defineRule({
         if (isNodeOfType(value, "Literal") && value.value !== "true") return;
         if (isNodeOfType(value, "JSXExpressionContainer")) {
           const expression = value.expression;
-          if (isNodeOfType(expression, "Literal") && !expression.value) return;
+          if (!isNodeOfType(expression, "Literal")) return;
+          if (expression.value !== true && expression.value !== "true") return;
         }
       }
       const tag = getElementType(node, context.settings);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.regressions.test.ts
index b73abbe2cf..df6602743c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.regressions.test.ts
@@ -71,4 +71,18 @@ describe("a11y/no-noninteractive-tabindex regressions", () => {
       ).toHaveLength(1);
     });
   });
+
+  describe("roving tabindex", () => {
+    it("does not flag a conditional roving tabIndex with a negative branch", () => {
+      expect(
+        runRule(noNoninteractiveTabindex, `<div tabIndex={isActive ? 0 : -1} />`).diagnostics,
+      ).toEqual([]);
+    });
+
+    it("still flags a conditional tabIndex whose branches are both non-negative", () => {
+      expect(
+        runRule(noNoninteractiveTabindex, `<div tabIndex={isActive ? 0 : 1} />`).diagnostics,
+      ).toHaveLength(1);
+    });
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.ts
index b10a0e7fef..66ac3b6012 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-noninteractive-tabindex.ts
@@ -21,6 +21,36 @@ const isKeyboardOperable = (node: EsTreeNodeOfType<"JSXOpeningElement">): boolea
     Boolean(hasJsxPropIgnoreCase(node.attributes, propName)),
   );
 
+const parseNumericBranch = (expression: EsTreeNode): number | null => {
+  if (isNodeOfType(expression, "Literal") && typeof expression.value === "number") {
+    return expression.value;
+  }
+  if (
+    isNodeOfType(expression, "UnaryExpression") &&
+    expression.operator === "-" &&
+    isNodeOfType(expression.argument, "Literal") &&
+    typeof expression.argument.value === "number"
+  ) {
+    return -expression.argument.value;
+  }
+  return null;
+};
+
+// `tabIndex={active ? 0 : -1}` is the roving-tabindex pattern: only one
+// element in the composite is tabbable at a time, and the `-1` branch keeps
+// the rest reachable by script. The `tabIndex` is intentional, so skip it.
+const isRovingTabindexValue = (value: EsTreeNode): boolean => {
+  if (!isNodeOfType(value, "JSXExpressionContainer")) return false;
+  const expression = value.expression;
+  if (!isNodeOfType(expression, "ConditionalExpression")) return false;
+  if (isNodeOfType(expression.test, "Literal")) return false;
+  const branchValues = [
+    parseNumericBranch(expression.consequent),
+    parseNumericBranch(expression.alternate),
+  ];
+  return branchValues.some((branchValue) => branchValue !== null && branchValue < 0);
+};
+
 interface NoNoninteractiveTabindexSettings {
   tags?: ReadonlyArray<string>;
   roles?: ReadonlyArray<string>;
@@ -59,6 +89,7 @@ export const noNoninteractiveTabindex = defineRule({
         if (!tabIndex) return;
         const tabIndexValue = tabIndex.value as EsTreeNode | null;
         if (!tabIndexValue) return;
+        if (isRovingTabindexValue(tabIndexValue)) return;
         const numeric = parseJsxValue(tabIndexValue);
         if (numeric === null) {
           if (
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.regressions.test.ts
new file mode 100644
index 0000000000..7cb64a04ce
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.regressions.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vite-plus/test";
+import { runRule } from "../../../test-utils/run-rule.js";
+import { noStaticElementInteractions } from "./no-static-element-interactions.js";
+
+describe("a11y/no-static-element-interactions regressions", () => {
+  it("does not flag a string-literal role wrapped in a JSX expression container", () => {
+    const result = runRule(
+      noStaticElementInteractions,
+      `export const A = ({ onClick }) => <div role={'link'} onClick={onClick} />;`,
+    );
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a wrapped string-literal role that is not interactive", () => {
+    const result = runRule(
+      noStaticElementInteractions,
+      `export const A = ({ onClick }) => <div role={'wat'} onClick={onClick} />;`,
+    );
+    expect(result.diagnostics).toHaveLength(1);
+  });
+
+  it("does not flag an svg with a click handler", () => {
+    const result = runRule(
+      noStaticElementInteractions,
+      `export const A = ({ onClick }) => <svg width="10" height="10" onClick={onClick} />;`,
+    );
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a div with a click handler and no role", () => {
+    const result = runRule(
+      noStaticElementInteractions,
+      `export const A = ({ onClick }) => <div onClick={onClick} />;`,
+    );
+    expect(result.diagnostics).toHaveLength(1);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts
index 5a1e17dbd8..5d4820e84c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/a11y/no-static-element-interactions.ts
@@ -110,6 +110,9 @@ export const noStaticElementInteractions = defineRule({
         const elementType = getElementType(node, context.settings);
         // Custom JSX elements pass through.
         if (!HTML_TAGS.has(elementType)) return;
+        // <svg> has the implicit `graphics-document` role, so it isn't
+        // static; upstream skips it too.
+        if (elementType === "svg") return;
         if (isHiddenFromScreenReader(node, context.settings)) return;
         if (isPresentationRole(node)) return;
         if (isInteractiveElement(elementType, node)) return;
@@ -122,7 +125,14 @@ export const noStaticElementInteractions = defineRule({
           return;
         }
 
-        const attributeValue = roleAttribute.value as EsTreeNode;
+        let attributeValue = roleAttribute.value as EsTreeNode;
+        if (
+          isNodeOfType(attributeValue, "JSXExpressionContainer") &&
+          isNodeOfType(attributeValue.expression, "Literal") &&
+          typeof attributeValue.expression.value === "string"
+        ) {
+          attributeValue = attributeValue.expression;
+        }
         if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
           const firstRole = attributeValue.value.toLowerCase().trim().split(/\s+/)[0];
           if (firstRole && (isInteractiveRole(firstRole) || isNonInteractiveRole(firstRole))) {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.regressions.test.ts
index a07147bc26..02f9ad3382 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.regressions.test.ts
@@ -193,4 +193,17 @@ describe("architecture/no-render-in-render — regressions", () => {
     );
     expect(result.diagnostics.length).toBeGreaterThan(0);
   });
+
+  it("does not claim a remount or state loss for a plain render-helper call", () => {
+    const result = run(
+      `function Page() {
+        const renderHeader = () => <h1>Title</h1>;
+        return <div>{renderHeader()}</div>;
+      }`,
+    );
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).not.toContain("remount");
+    expect(result.diagnostics[0].message).not.toContain("lose state");
+    expect(result.diagnostics[0].message).toContain("renderHeader()");
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts
index 77a12df0b8..2a5aa0b39c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/architecture/no-render-in-render.ts
@@ -91,7 +91,7 @@ export const noRenderInRender = defineRule({
   severity: "warn",
   tags: ["test-noise"],
   recommendation:
-    "Make it a named component so React preserves its identity and does not remount its state.",
+    "Make it a named component rendered as JSX so React can track it and preserve its state.",
   create: (context: RuleContext) => ({
     JSXExpressionContainer(node: EsTreeNodeOfType<"JSXExpressionContainer">) {
       const expression = node.expression;
@@ -119,7 +119,7 @@ export const noRenderInRender = defineRule({
 
       context.report({
         node: expression,
-        message: `Your users lose state because "${calleeName}()" builds UI from an inline call that React remounts, so pull it into its own component instead.`,
+        message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`,
       });
     },
   }),
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.test.ts
index e8ea9c066d..8853a92e98 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.test.ts
@@ -28,6 +28,28 @@ describe("no-array-index-as-key (test-harness smoke test)", () => {
     expect(result.diagnostics).toHaveLength(0);
   });
 
+  it("does not flag index when the receiver is a variable holding a static placeholder", () => {
+    const code = `const App = () => {
+  const list = Array.from({ length: 3 });
+  return list.map((_, index) => <li key={\`mobile-\${index}\`} />);
+};
+`;
+    const result = runRule(noArrayIndexAsKey, code);
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(0);
+  });
+
+  it("still flags index when the receiver variable holds dynamic data", () => {
+    const code = `const App = ({ items }) => {
+  const list = items.slice(0, 3);
+  return list.map((item, index) => <li key={index}>{item.name}</li>);
+};
+`;
+    const result = runRule(noArrayIndexAsKey, code);
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+  });
+
   it("flags String(index) coercion used as JSX key", () => {
     const code = `const App = ({ items }) => items.map((item, index) => <li key={String(index)}>{item}</li>);
 `;
@@ -159,6 +181,102 @@ const MatchedName = ({ name, matchedIndices, isSelected }: MatchedNameProps) =>
       expect(result.diagnostics).toHaveLength(1);
     });
 
+    it("does not flag a composite key mixing the index with a destructured item field", () => {
+      const code = `const Console = ({ messages }) => (
+  <div>{messages.map(({ message, time }, index) => <Entry key={\`\${message} \${index}\`} time={time} />)}</div>
+);
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toEqual([]);
+    });
+
+    it("does not flag a composite key mixing the index with a method call on the item", () => {
+      const code = `const Presets = ({ colors }) => (
+  <div>{colors.map((presetColor, index) => <Swatch key={\`preset-\${index}-\${presetColor.toHexString()}\`} />)}</div>
+);
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toEqual([]);
+    });
+
+    it("does not flag Array.from({length: values.length}) placeholder index keys", () => {
+      const code = `const Thumbs = ({ values }) => (
+  <div>{Array.from({ length: values.length }, (_, index) => <Thumb key={index} />)}</div>
+);
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toEqual([]);
+    });
+
+    it("does not flag a numeric for-loop counter used as key", () => {
+      const code = `const Grid = ({ count }) => {
+  const cols = [];
+  for (let i = 0; i < count; i++) {
+    cols.push(<Col key={i} span={24 / count} />);
+  }
+  return <Row>{cols}</Row>;
+};
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toEqual([]);
+    });
+
+    it("still flags a for-loop counter bounded by real list data's .length", () => {
+      const code = `const List = ({ items }) => {
+  const out = [];
+  for (let i = 0; i < items.length; i++) {
+    out.push(<Row key={i} item={items[i]} />);
+  }
+  return out;
+};
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toHaveLength(1);
+    });
+
+    it("still flags when a placeholder-initialized binding is reassigned to real data", () => {
+      const code = `const List = ({ items }) => {
+  let list = Array.from({ length: 3 });
+  list = items;
+  return <ul>{list.map((item, index) => <Row key={\`s-\${index}\`} item={item} />)}</ul>;
+};
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toHaveLength(1);
+    });
+
+    it("still flags a manually incremented index inside a for-of over items", () => {
+      const code = `const List = ({ items }) => {
+  const out = [];
+  let index = 0;
+  for (const item of items) {
+    out.push(<Row key={index} item={item} />);
+    index++;
+  }
+  return out;
+};
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toHaveLength(1);
+    });
+
+    it("still flags a composite key whose other expression is not item-derived", () => {
+      const code = `const List = ({ items, prefix }) => (
+  <div>{items.map((item, index) => <Row key={\`\${prefix}-\${index}\`} />)}</div>
+);
+`;
+      const result = runRule(noArrayIndexAsKey, code);
+      expect(result.parseErrors).toEqual([]);
+      expect(result.diagnostics).toHaveLength(1);
+    });
+
     it("still flags a spread of an untyped inner binding shadowing a typed string prop", () => {
       const code = `const Rows = ({ name, groups }: { name: string; groups: string[][] }) => {
   return groups.map((name) => (
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.ts
index dc02079f66..7f78075a76 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.ts
@@ -3,11 +3,14 @@ import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import { findProgramRoot } from "../../utils/find-program-root.js";
+import { getRootIdentifierName } from "../../utils/get-root-identifier-name.js";
+import { collectPatternNames } from "../../utils/collect-pattern-names.js";
 import { findVariableInitializer } from "../../utils/find-variable-initializer.js";
 import { isAllLiteralArrayExpression } from "../../utils/is-all-literal-array-expression.js";
 import { isFunctionLike } from "../../utils/is-function-like.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { stripParenExpression } from "../../utils/strip-paren-expression.js";
+import { walkAst } from "../../utils/walk-ast.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import {
   containsStatefulDescendant,
@@ -119,11 +122,37 @@ const isArrayFromCall = (node: EsTreeNode | null | undefined): boolean => {
  *
  * Used both for `<receiver>.map(...)` and for `Array.from(<length>, fn)`.
  */
-const isStaticPlaceholderReceiver = (receiver: EsTreeNode): boolean => {
+const isBindingReassigned = (referenceNode: EsTreeNode, bindingName: string): boolean => {
+  const programRoot = findProgramRoot(referenceNode);
+  if (!programRoot) return false;
+  let didFindReassignment = false;
+  walkAst(programRoot, (child: EsTreeNode): boolean | void => {
+    if (didFindReassignment) return false;
+    if (
+      isNodeOfType(child, "AssignmentExpression") &&
+      isNodeOfType(child.left, "Identifier") &&
+      child.left.name === bindingName
+    ) {
+      didFindReassignment = true;
+      return false;
+    }
+  });
+  return didFindReassignment;
+};
+
+const isStaticPlaceholderReceiver = (receiver: EsTreeNode, depth = 0): boolean => {
   if (isArrayFromCall(receiver)) return true;
   if (isArrayConstructorCallWithNumericLength(receiver)) return true;
   if (isAllLiteralArrayExpression(receiver)) return true;
 
+  if (isNodeOfType(receiver, "Identifier")) {
+    if (depth >= TYPE_RESOLUTION_DEPTH_LIMIT) return false;
+    const binding = findVariableInitializer(receiver, receiver.name);
+    if (!binding?.initializer) return false;
+    if (isBindingReassigned(receiver, receiver.name)) return false;
+    return isStaticPlaceholderReceiver(binding.initializer, depth + 1);
+  }
+
   if (isNodeOfType(receiver, "CallExpression")) {
     const callee = receiver.callee;
     if (
@@ -163,6 +192,13 @@ const isArrayFromLengthObjectCall = (node: EsTreeNode): boolean => {
     // also accept simple identifier — `{length: count}` — assume it's a numeric
     // constant; almost always is in placeholder constructions.
     if (isNodeOfType(prop.value, "Identifier")) return true;
+    // `{length: values.length}` — a `.length` read is a numeric count too.
+    if (
+      isNodeOfType(prop.value, "MemberExpression") &&
+      isNodeOfType(prop.value.property, "Identifier") &&
+      prop.value.property.name === "length"
+    )
+      return true;
   }
   return false;
 };
@@ -376,10 +412,11 @@ const isInsideStaticPlaceholderMap = (node: EsTreeNode): boolean =>
 /**
  * Walk up from a JSXAttribute node looking for the enclosing iterator
  * callback (`.map(cb)`, `.flatMap(cb)`, `.forEach(cb)`, `Array.from(_, cb)`)
- * and return the first parameter's name. The first param is the per-item
- * value, e.g. `item` in `arr.map((item, index) => …)`.
+ * and return the names bound by the first parameter — `item` in
+ * `arr.map((item, index) => …)`, or every destructured field in
+ * `arr.map(({ id, label }, index) => …)`.
  */
-const findIteratorItemName = (node: EsTreeNode): string | null => {
+const findIteratorItemNames = (node: EsTreeNode): Set<string> | null => {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
@@ -404,8 +441,10 @@ const findIteratorItemName = (node: EsTreeNode): string | null => {
       if (isIteratorMethodCall || isArrayFromCallback) {
         const cbParams = (current as EsTreeNodeOfType<"ArrowFunctionExpression">).params ?? [];
         const first = cbParams[0];
-        if (first && isNodeOfType(first, "Identifier")) return first.name;
-        return null;
+        if (!first) return null;
+        const names = new Set<string>();
+        collectPatternNames(first, names);
+        return names.size > 0 ? names : null;
       }
     }
 
@@ -416,16 +455,11 @@ const findIteratorItemName = (node: EsTreeNode): string | null => {
 
 const templateLiteralHasIteratorIdentity = (
   template: EsTreeNodeOfType<"TemplateLiteral">,
-  itemName: string,
+  itemNames: ReadonlySet<string>,
 ): boolean => {
   for (const expression of template.expressions ?? []) {
-    if (isNodeOfType(expression, "Identifier") && expression.name === itemName) return true;
-    if (
-      isNodeOfType(expression, "MemberExpression") &&
-      isNodeOfType(expression.object, "Identifier") &&
-      expression.object.name === itemName
-    )
-      return true;
+    const rootName = getRootIdentifierName(expression, { followCallChains: true });
+    if (rootName !== null && itemNames.has(rootName)) return true;
   }
   return false;
 };
@@ -443,9 +477,54 @@ const isCompositeKeyWithIteratorIdentity = (
   if (!isNodeOfType(keyExpression, "TemplateLiteral")) return false;
   const expressions = keyExpression.expressions ?? [];
   if (expressions.length < 2) return false;
-  const itemName = findIteratorItemName(attributeNode);
-  if (!itemName) return false;
-  return templateLiteralHasIteratorIdentity(keyExpression, itemName);
+  const itemNames = findIteratorItemNames(attributeNode);
+  if (!itemNames) return false;
+  return templateLiteralHasIteratorIdentity(keyExpression, itemNames);
+};
+
+const forLoopTestReadsDataLength = (test: EsTreeNode): boolean => {
+  let didFindLengthRead = false;
+  walkAst(test, (child: EsTreeNode): boolean | void => {
+    if (didFindLengthRead) return false;
+    if (
+      isNodeOfType(child, "MemberExpression") &&
+      isNodeOfType(child.property, "Identifier") &&
+      child.property.name === "length"
+    ) {
+      didFindLengthRead = true;
+      return false;
+    }
+  });
+  return didFindLengthRead;
+};
+
+// `for (let i = 0; i < count; i++) { children.push(<Col key={i} />) }` is
+// the imperative twin of the exempt `Array.from({length: count}).map(…)`
+// placeholder — the counter has no identity beyond its position.
+const isNumericForLoopCounter = (attributeNode: EsTreeNode, indexName: string): boolean => {
+  const binding = findVariableInitializer(attributeNode, indexName);
+  if (!binding) return false;
+  const declarator = binding.bindingIdentifier.parent;
+  if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
+  const declaration = declarator.parent;
+  if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return false;
+  const forStatement = declaration.parent;
+  if (
+    !forStatement ||
+    !isNodeOfType(forStatement, "ForStatement") ||
+    forStatement.init !== declaration ||
+    !declarator.init ||
+    !isNodeOfType(declarator.init, "Literal") ||
+    typeof declarator.init.value !== "number"
+  ) {
+    return false;
+  }
+  // `for (let i = 0; i < items.length; i++)` walks real list data — the
+  // items carry identity, so an index key there still breaks on reorder.
+  if (forStatement.test && forLoopTestReadsDataLength(forStatement.test as EsTreeNode)) {
+    return false;
+  }
+  return true;
 };
 
 export const noArrayIndexAsKey = defineRule({
@@ -461,6 +540,7 @@ export const noArrayIndexAsKey = defineRule({
 
       const indexName = extractIndexName(node.value.expression);
       if (!indexName) return;
+      if (isNumericForLoopCounter(node, indexName)) return;
       if (isInsideStaticPlaceholderMap(node)) return;
       if (isInsideStringDerivedMap(node)) return;
       if (isCompositeKeyWithIteratorIdentity(node.value.expression, node)) return;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.regressions.test.ts
new file mode 100644
index 0000000000..ed510f0d0d
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.regressions.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vite-plus/test";
+import { runRule } from "../../../test-utils/run-rule.js";
+import { nextjsMissingMetadata } from "./nextjs-missing-metadata.js";
+
+describe("nextjs/nextjs-missing-metadata — regressions", () => {
+  it('does not flag a "use client" page, which cannot export metadata', () => {
+    const result = runRule(
+      nextjsMissingMetadata,
+      `"use client";
+import { useChat } from "@ai-sdk/react";
+export default function ChatPage() {
+  const { messages } = useChat();
+  return <div>{messages.length}</div>;
+}`,
+      { filename: "app/chat/page.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a server page with no metadata export", () => {
+    const result = runRule(
+      nextjsMissingMetadata,
+      `export default function Page() {
+  return <main>Home</main>;
+}`,
+      { filename: "app/page.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.ts
index 652ac30098..3c53caeb25 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/nextjs/nextjs-missing-metadata.ts
@@ -23,6 +23,16 @@ export const nextjsMissingMetadata = defineRule({
       const filename = normalizeFilename(context.filename ?? "");
       if (!PAGE_FILE_PATTERN.test(filename)) return;
       if (INTERNAL_PAGE_PATH_PATTERN.test(filename)) return;
+      // A "use client" page cannot export `metadata` / `generateMetadata`
+      // (Next.js fails the build), so metadata for it can only live in a
+      // layout — there is nothing to fix in this file.
+      const hasUseClientDirective = (programNode.body ?? []).some(
+        (statement) =>
+          isNodeOfType(statement, "ExpressionStatement") &&
+          isNodeOfType(statement.expression, "Literal") &&
+          statement.expression.value === "use client",
+      );
+      if (hasUseClientDirective) return;
 
       const hasMetadataExport = programNode.body?.some((statement) => {
         if (!isNodeOfType(statement, "ExportNamedDeclaration")) return false;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.regressions.test.ts
index fc302c5711..4e015f660f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.regressions.test.ts
@@ -63,6 +63,31 @@ describe("performance/rendering-hydration-mismatch-time — regressions", () =>
     expect(result.diagnostics).toHaveLength(0);
   });
 
+  it("does not flag new Date() inside JSX rendered by next/og ImageResponse", () => {
+    expectPass(`
+      import { ImageResponse } from "next/og";
+      export async function GET() {
+        return new ImageResponse(
+          <div>
+            <p>{formatDate(new Date())}</p>
+          </div>,
+        );
+      }
+    `);
+  });
+
+  it("does not flag Date.now() in an opengraph-image file", () => {
+    const result = runRule(
+      renderingHydrationMismatchTime,
+      `export default function Image() {
+        return <div>{Date.now()}</div>;
+      }`,
+      { filename: "app/blog/opengraph-image.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(0);
+  });
+
   it("still flags an IIFE returning new Date().toLocaleString()", () => {
     expectFail(`export const Banner = () => <span>{(() => new Date().toLocaleString())()}</span>;`);
   });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.ts
index 761757bde1..9d369fffd7 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/performance/rendering-hydration-mismatch-time.ts
@@ -2,6 +2,7 @@ import { defineRule } from "../../utils/define-rule.js";
 import { walkAst } from "../../utils/walk-ast.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import { isFunctionLike } from "../../utils/is-function-like.js";
+import { isGeneratedImageRenderContext } from "../../utils/is-generated-image-render-context.js";
 import { isHookCall } from "../../utils/is-hook-call.js";
 import { isTestlikeFilename } from "../../utils/is-testlike-filename.js";
 import type { RuleContext } from "../../utils/rule-context.js";
@@ -121,6 +122,10 @@ export const renderingHydrationMismatchTime = defineRule({
       JSXExpressionContainer(node: EsTreeNodeOfType<"JSXExpressionContainer">) {
         if (isTestlikeFile) return;
         if (!node.expression) return;
+        // JSX rasterized by `ImageResponse` / satori (og images) renders
+        // once on the server into a static image — it never hydrates, so
+        // a time/random value there cannot mismatch.
+        if (isGeneratedImageRenderContext(context, findOpeningElementOfChild(node) ?? node)) return;
         const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) =>
           pattern.matches(node.expression),
         );
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.regressions.test.ts
index 1d8eca8457..4e4f9f6a3b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.regressions.test.ts
@@ -40,6 +40,36 @@ describe("react-builtins/button-has-type — regressions", () => {
     expect(result.diagnostics).toEqual([]);
   });
 
+  // A TS assertion wrapper (`as const` / `satisfies`) around a valid
+  // literal is the type-safest way to write the binding — strip the
+  // wrapper before proving validity.
+  it("stays silent on a local const with an `as const` valid type", () => {
+    const result = runRule(
+      buttonHasType,
+      `function Save() { const kind = "submit" as const; return <button type={kind}>Save</button>; }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent on an inline `satisfies`-wrapped valid type", () => {
+    const result = runRule(
+      buttonHasType,
+      `const Save = () => <button type={"submit" satisfies "submit"}>Save</button>;`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags an `as const` INVALID literal type", () => {
+    const result = runRule(
+      buttonHasType,
+      `function Save() { const kind = "banana" as const; return <button type={kind}>Save</button>; }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
   // An identifier with no resolvable initializer stays "unknown →
   // invalid" and must fire.
   it("still flags an unresolvable identifier type", () => {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.ts
index cabfd63201..ef5cb51f91 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/button-has-type.ts
@@ -11,6 +11,7 @@ import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { isNullishExpression } from "../../utils/is-nullish-expression.js";
 import { isTestlikeFilename } from "../../utils/is-testlike-filename.js";
 import type { Rule } from "../../utils/rule.js";
+import { stripParenExpression } from "../../utils/strip-paren-expression.js";
 
 const MISSING_MESSAGE =
   "Your users can submit the form by accident because a `<button>` with no `type` defaults to submit.";
@@ -52,10 +53,11 @@ const isValidTypeValue = (rawValue: string, settings: Required<ButtonHasTypeSett
 // fires the diagnostic. This matches OXC's "if you can't show me a
 // valid value, it's invalid" stance.
 const isProvenValidExpression = (
-  expression: EsTreeNode,
+  rawExpression: EsTreeNode,
   settings: Required<ButtonHasTypeSettings>,
   resolvedBindings: ReadonlySet<string> = new Set(),
 ): boolean => {
+  const expression = stripParenExpression(rawExpression);
   if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") {
     return isValidTypeValue(expression.value, settings);
   }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.regressions.test.ts
index a7277e103e..42e1a3a4cb 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.regressions.test.ts
@@ -14,6 +14,26 @@ describe("react-builtins/checked-requires-onchange-or-readonly — regressions",
     expect(result.diagnostics).toEqual([]);
   });
 
+  // React's controlled-checkbox runtime warning exempts `disabled`
+  // inputs — users can't toggle them, so no `onChange` is needed.
+  it("stays silent for a statically disabled checkbox without onChange", () => {
+    const result = runRule(
+      checkedRequiresOnchangeOrReadonly,
+      `const C = ({ checked }) => <input type="checkbox" checked={checked} disabled />;`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a dynamically disabled checkbox (it can be enabled at runtime)", () => {
+    const result = runRule(
+      checkedRequiresOnchangeOrReadonly,
+      `const C = ({ checked, locked }) => <input type="checkbox" checked={checked} disabled={locked} />;`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
   it("still flags checked + defaultChecked used together even with a spread", () => {
     const result = runRule(
       checkedRequiresOnchangeOrReadonly,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.ts
index d2fc82632f..10fed437c0 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.ts
@@ -34,13 +34,24 @@ interface AttributePresence {
   defaultCheckedNode: EsTreeNode | null;
   hasOnChangeOrReadOnly: boolean;
   hasSpread: boolean;
+  hasTruthyDisabled: boolean;
 }
 
+const isTruthyDisabledJsxValue = (attribute: EsTreeNodeOfType<"JSXAttribute">): boolean => {
+  if (!attribute.value) return true;
+  if (isNodeOfType(attribute.value, "JSXExpressionContainer")) {
+    const expression = attribute.value.expression as EsTreeNode;
+    return isNodeOfType(expression, "Literal") && expression.value === true;
+  }
+  return false;
+};
+
 const collectFromJsxAttributes = (attributes: ReadonlyArray<EsTreeNode>): AttributePresence => {
   let checkedNode: EsTreeNode | null = null;
   let defaultCheckedNode: EsTreeNode | null = null;
   let hasOnChangeOrReadOnly = false;
   let hasSpread = false;
+  let hasTruthyDisabled = false;
   for (const attribute of attributes) {
     if (isNodeOfType(attribute, "JSXSpreadAttribute")) {
       hasSpread = true;
@@ -51,8 +62,9 @@ const collectFromJsxAttributes = (attributes: ReadonlyArray<EsTreeNode>): Attrib
     if (name === "checked") checkedNode = attribute;
     else if (name === "defaultChecked" && !defaultCheckedNode) defaultCheckedNode = attribute;
     else if (name === "onChange" || name === "readOnly") hasOnChangeOrReadOnly = true;
+    else if (name === "disabled" && isTruthyDisabledJsxValue(attribute)) hasTruthyDisabled = true;
   }
-  return { checkedNode, defaultCheckedNode, hasOnChangeOrReadOnly, hasSpread };
+  return { checkedNode, defaultCheckedNode, hasOnChangeOrReadOnly, hasSpread, hasTruthyDisabled };
 };
 
 const collectFromObjectProperties = (
@@ -62,6 +74,7 @@ const collectFromObjectProperties = (
   let defaultCheckedNode: EsTreeNode | null = null;
   let hasOnChangeOrReadOnly = false;
   let hasSpread = false;
+  let hasTruthyDisabled = false;
   for (const property of objectExpression.properties) {
     if (isNodeOfType(property, "SpreadElement")) {
       hasSpread = true;
@@ -79,8 +92,13 @@ const collectFromObjectProperties = (
       defaultCheckedNode = property;
     else if (propertyName === "onChange" || propertyName === "readOnly")
       hasOnChangeOrReadOnly = true;
+    else if (propertyName === "disabled") {
+      const propertyValue = property.value as EsTreeNode;
+      if (isNodeOfType(propertyValue, "Literal") && propertyValue.value === true)
+        hasTruthyDisabled = true;
+    }
   }
-  return { checkedNode, defaultCheckedNode, hasOnChangeOrReadOnly, hasSpread };
+  return { checkedNode, defaultCheckedNode, hasOnChangeOrReadOnly, hasSpread, hasTruthyDisabled };
 };
 
 // Port of `oxc_linter::rules::react::checked_requires_onchange_or_readonly`.
@@ -109,10 +127,13 @@ export const checkedRequiresOnchangeOrReadonly = defineRule({
         presence.checkedNode &&
         !presence.hasOnChangeOrReadOnly &&
         !presence.hasSpread &&
+        !presence.hasTruthyDisabled &&
         !settings.ignoreMissingProperties
       ) {
         // A spread (`{...rest}`) can supply `onChange`/`readOnly` at
-        // runtime, so their absence in the explicit attributes isn't proof.
+        // runtime, so their absence in the explicit attributes isn't
+        // proof, and React's own controlled-checkbox warning exempts
+        // `disabled` inputs (users can't toggle them anyway).
         context.report({ node: presence.checkedNode, message: MISSING_MESSAGE });
       }
     };
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.regressions.test.ts
index 5afe895b7c..3ffb065251 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.regressions.test.ts
@@ -85,3 +85,32 @@ describe("react-builtins/display-name — regressions: extended HoC awareness",
     expect(result.diagnostics).toEqual([]);
   });
 });
+
+describe("react-builtins/display-name — regressions: curried factory body shapes", () => {
+  it("flags an anonymous arrow component returned from a block-body arrow factory", () => {
+    const result = runJsx(`
+      export const h = (order) => { return (props) => <Title order={order} {...props} />; };
+    `);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
+  it("flags the same factory with an expression body identically", () => {
+    const blockBody = runJsx(`
+      export const h = (order) => { return (props) => <Title order={order} {...props} />; };
+    `);
+    const expressionBody = runJsx(`
+      export const h = (order) => (props) => <Title order={order} {...props} />;
+    `);
+    expect(blockBody.diagnostics.map((diagnostic) => diagnostic.message)).toEqual(
+      expressionBody.diagnostics.map((diagnostic) => diagnostic.message),
+    );
+  });
+
+  it("does not flag a PascalCase arrow component with a block body", () => {
+    const result = runJsx(`
+      const Header = (props) => { return <div {...props} />; };
+      export default Header;
+    `);
+    expect(result.diagnostics).toEqual([]);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts
index 442ac3490b..fef1e2b5ba 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/display-name.ts
@@ -437,7 +437,10 @@ export const displayName = defineRule({
       },
       ArrowFunctionExpression(node: EsTreeNodeOfType<"ArrowFunctionExpression">) {
         if (!containsJsx(node)) return;
-        if (isNodeOfType(node.parent, "ArrowFunctionExpression")) {
+        if (
+          isNodeOfType(node.parent, "ArrowFunctionExpression") ||
+          isNodeOfType(node.parent, "ReturnStatement")
+        ) {
           reportAt(node as EsTreeNode);
           return;
         }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.regressions.test.ts
index 5b5f1bd0a3..db8fd3ff38 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.regressions.test.ts
@@ -300,4 +300,136 @@ describe("react-builtins/exhaustive-deps — regressions", () => {
     const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
     expect(messages).toContain("A complex expression");
   });
+
+  it("truncates prop-ref member chains at .current instead of demanding mutable paths", () => {
+    const code = `
+      function ChatInput({ textareaRef, content }) {
+        useEffect(() => {
+          if (textareaRef.current) {
+            textareaRef.current.style.height = \`\${textareaRef.current.scrollHeight}px\`;
+          }
+        }, [content]);
+        return null;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code);
+    expect(result.parseErrors).toEqual([]);
+    const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+    expect(messages).toContain("textareaRef");
+    expect(messages).not.toContain("textareaRef.current");
+  });
+
+  it("still reports the truncated prop-ref root when it is missing from deps", () => {
+    const code = `
+      function MyComponent({ myRef }) {
+        useCallback(() => { console.log(myRef.current.innerHTML); }, []);
+        return null;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code);
+    expect(result.parseErrors).toEqual([]);
+    const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+    expect(messages).toContain("myRef");
+  });
+
+  it("does not warn about cleanup ref reads when the ref is only assigned by React via JSX", () => {
+    const code = `
+      function MyComponent() {
+        const areaRef = useRef(null);
+        const attach = (node) => { areaRef.current = node; };
+        useEffect(() => {
+          const handle = () => {};
+          areaRef.current?.addEventListener("mousedown", handle);
+          return () => {
+            areaRef.current?.removeEventListener("mousedown", handle);
+          };
+        }, []);
+        return <div ref={attach} />;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code, { filename: "fixture.tsx" });
+    expect(result.parseErrors).toEqual([]);
+    const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+    expect(messages).not.toContain("wrong node");
+  });
+
+  it("still warns about cleanup ref reads when the ref is never assigned in the component", () => {
+    const code = `
+      function MyComponent() {
+        const areaRef = useRef(null);
+        useEffect(() => {
+          const handle = () => {};
+          areaRef.current?.addEventListener("mousedown", handle);
+          return () => {
+            areaRef.current?.removeEventListener("mousedown", handle);
+          };
+        }, []);
+        return <div ref={areaRef} />;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code, { filename: "fixture.tsx" });
+    expect(result.parseErrors).toEqual([]);
+    const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+    expect(messages).toContain("wrong node");
+  });
+
+  it("treats an explicit undefined deps argument like an omitted one for effect hooks", () => {
+    const code = `
+      function MyComponent({ focusAndScrollRef }) {
+        useLayoutEffect(
+          () => {
+            focusAndScrollRef.apply = false;
+          },
+          undefined
+        );
+        return null;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code);
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still reports an explicit undefined deps argument for hooks that require deps", () => {
+    const code = `
+      function MyComponent({ compute }) {
+        const value = useMemo(() => compute(), undefined);
+        return value;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code);
+    expect(result.parseErrors).toEqual([]);
+    const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+    expect(messages).toContain("useMemo");
+  });
+
+  it("suggests aggregate props when the only props call is a nested chain like props.api.load()", () => {
+    const code = `
+      function MyComponent(props) {
+        useEffect(() => {
+          console.log(props.a, props.b);
+          props.api.load();
+        }, []);
+        return null;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code);
+    expect(result.parseErrors).toEqual([]);
+    const messages = result.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+    expect(messages).toContain("props");
+  });
+
+  it("still reports a null deps argument on an effect hook as a non-array deps list", () => {
+    const code = `
+      function MyComponent(props) {
+        useEffect(() => {
+          console.log(props.foo);
+        }, null);
+        return null;
+      }
+    `;
+    const result = runRule(exhaustiveDeps, code);
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.ts
index 22b15dcb14..ac88c51cb3 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/exhaustive-deps.ts
@@ -175,6 +175,22 @@ const flattenReferenceRootName = (reference: ReferenceDescriptor): string => {
   return "";
 };
 
+// Cuts a member-chain dep key at its `.current` segment: `.current` is
+// a mutable ref cell, so anything read through it can't be a dependency
+// — the ref itself is the dependable value (upstream truncates
+// `props.someOtherRefs.current.innerHTML` to `props.someOtherRefs` the
+// same way, even when the ref isn't a local `useRef`).
+const REF_CURRENT_SEGMENT = ".current";
+const truncateAtRefCurrent = (chain: string): string => {
+  const refCurrentIndex = chain.indexOf(REF_CURRENT_SEGMENT);
+  if (refCurrentIndex === -1) return chain;
+  const segmentEndIndex = refCurrentIndex + REF_CURRENT_SEGMENT.length;
+  if (segmentEndIndex === chain.length || chain[segmentEndIndex] === ".") {
+    return chain.slice(0, refCurrentIndex);
+  }
+  return chain;
+};
+
 // Computes the dep "key" (root identifier name OR the full member-path)
 // for a captured reference. e.g.:
 //   reference points to `count`            → "count"
@@ -235,18 +251,14 @@ const computeDepKey = (reference: ReferenceDescriptor): string => {
     declarator.init === outermost
   ) {
     const destructuredPath = getDestructuredPropertyPath(declarator.id);
-    if (destructuredPath) return `${fullName}.${destructuredPath}`;
+    if (destructuredPath) return truncateAtRefCurrent(`${fullName}.${destructuredPath}`);
   }
+  const truncatedName = truncateAtRefCurrent(fullName);
+  if (truncatedName !== fullName) return truncatedName;
   if (reference.flag !== "read") {
     const lastDotIndex = fullName.lastIndexOf(".");
     if (lastDotIndex !== -1) return fullName.slice(0, lastDotIndex);
   }
-  // Strip `.current` suffix for ref-like values; that property is
-  // mutable but the ref itself is stable.
-  const REF_CURRENT_SUFFIX = ".current";
-  if (fullName.endsWith(REF_CURRENT_SUFFIX)) {
-    return fullName.slice(0, -REF_CURRENT_SUFFIX.length);
-  }
   return fullName;
 };
 
@@ -531,7 +543,15 @@ const getRefCurrentNameFromMemberExpression = (node: EsTreeNode): string | null
   return currentIndex === -1 ? null : chain.slice(0, currentIndex + ".current".length);
 };
 
-const findRefCurrentInCleanup = (callback: EsTreeNode, scopes: ScopeAnalysis): string | null => {
+interface RefCurrentInCleanup {
+  refCurrentName: string;
+  refSymbol: SymbolDescriptor | null;
+}
+
+const findRefCurrentInCleanup = (
+  callback: EsTreeNode,
+  scopes: ScopeAnalysis,
+): RefCurrentInCleanup | null => {
   let cleanupFunction: EsTreeNode | null = null;
   const findReturn = (node: EsTreeNode): void => {
     if (cleanupFunction) return;
@@ -566,9 +586,9 @@ const findRefCurrentInCleanup = (callback: EsTreeNode, scopes: ScopeAnalysis): s
   findReturn(callback);
   if (!cleanupFunction) return null;
 
-  let refCurrentName: string | null = null;
+  let found: RefCurrentInCleanup | null = null;
   const visitCleanup = (node: EsTreeNode): void => {
-    if (refCurrentName) return;
+    if (found) return;
     if (isNodeOfType(node, "MemberExpression")) {
       const candidateName = getRefCurrentNameFromMemberExpression(node);
       if (candidateName) {
@@ -576,7 +596,7 @@ const findRefCurrentInCleanup = (callback: EsTreeNode, scopes: ScopeAnalysis): s
         const symbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
         const callbackScope = scopes.ownScopeFor(callback) ?? scopes.scopeFor(callback);
         if (!symbol || !isDescendantScope(symbol.scope, callbackScope)) {
-          refCurrentName = candidateName;
+          found = { refCurrentName: candidateName, refSymbol: symbol };
           return;
         }
       }
@@ -593,7 +613,26 @@ const findRefCurrentInCleanup = (callback: EsTreeNode, scopes: ScopeAnalysis): s
     }
   };
   visitCleanup(cleanupFunction);
-  return refCurrentName;
+  return found;
+};
+
+const hasRefCurrentAssignmentInComponent = (refSymbol: SymbolDescriptor | null): boolean => {
+  if (!refSymbol) return false;
+  for (const reference of refSymbol.references) {
+    const memberParent = reference.identifier.parent;
+    if (!memberParent || !isNodeOfType(memberParent, "MemberExpression")) continue;
+    if (memberParent.object !== reference.identifier) continue;
+    if (getRefCurrentNameFromMemberExpression(memberParent) === null) continue;
+    const assignmentParent = memberParent.parent;
+    if (
+      assignmentParent &&
+      isNodeOfType(assignmentParent, "AssignmentExpression") &&
+      assignmentParent.left === memberParent
+    ) {
+      return true;
+    }
+  }
+  return false;
 };
 
 const hasRefCurrentAssignment = (callback: EsTreeNode, refCurrentName: string): boolean => {
@@ -650,10 +689,28 @@ const hasMemberCallForRoot = (node: EsTreeNode, rootName: string): boolean => {
     if (didFindMemberCall) return;
     if (isNodeOfType(current, "CallExpression")) {
       const callee = unwrapExpression(current.callee);
-      const rootIdentifier = getMemberRootIdentifier(callee);
-      if (rootIdentifier?.name === rootName) {
-        didFindMemberCall = true;
-        return;
+      if (isNodeOfType(callee, "MemberExpression")) {
+        let chainObject = unwrapExpression(callee.object);
+        let doesChainPassThroughCurrent = false;
+        while (chainObject && isNodeOfType(chainObject, "MemberExpression")) {
+          if (
+            isNodeOfType(chainObject.property, "Identifier") &&
+            chainObject.property.name === "current"
+          ) {
+            doesChainPassThroughCurrent = true;
+            break;
+          }
+          chainObject = unwrapExpression(chainObject.object);
+        }
+        if (
+          !doesChainPassThroughCurrent &&
+          chainObject &&
+          isNodeOfType(chainObject, "Identifier") &&
+          chainObject.name === rootName
+        ) {
+          didFindMemberCall = true;
+          return;
+        }
       }
     }
     const record = current as unknown as Record<string, unknown>;
@@ -795,18 +852,19 @@ If the missing value is recreated every render, move it inside the hook or stabi
             });
           }
           if (outerAssignments.length > 0) return;
-          const refCurrentName = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
+          const refCurrentInCleanup = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
           const shouldCheckRefCleanup =
             EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) ||
             Boolean(additionalHooksRegex && additionalHooksRegex.test(hookName));
           if (
-            refCurrentName &&
+            refCurrentInCleanup &&
             shouldCheckRefCleanup &&
-            !hasRefCurrentAssignment(callbackToAnalyze, refCurrentName)
+            !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) &&
+            !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol)
           ) {
             context.report({
               node: callbackToAnalyze,
-              message: buildRefCleanupMessage(refCurrentName),
+              message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName),
             });
           }
         }
@@ -831,36 +889,31 @@ If the missing value is recreated every render, move it inside the hook or stabi
           return;
         }
 
-        // null / undefined deps argument → treat as "no deps". Upstream
-        // tolerates these as "intentional no-deps" for useEffect-style
-        // hooks but flags them for hooks that require deps.
+        // An explicit `undefined` deps argument is the same as omitting
+        // it (run on every commit), so upstream treats it as "no deps"
+        // for useEffect-style hooks and only flags it for hooks that
+        // require deps. A `null` deps argument stays a non-array report
+        // below, matching upstream.
         const depsArgument = unwrapExpression(depsArgumentRaw as EsTreeNode);
-        if (
-          (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null) ||
-          (isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined")
-        ) {
+        if (isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined") {
           if (isAutoDependenciesHook(hookName)) return;
           if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) {
             context.report({
               node: depsArgument,
               message: buildMissingDepArrayMessage(hookName),
             });
-            return;
           }
-          const nonArrayCaptureKeys =
-            callbackToAnalyze !== null
-              ? new Set(collectCaptureDepKeys(callbackToAnalyze, context.scopes).keys)
-              : new Set<string>();
-          for (const forcedCaptureKey of forcedCaptureKeys)
-            nonArrayCaptureKeys.add(forcedCaptureKey);
-          if (nonArrayCaptureKeys.size > 0) {
-            context.report({ node: depsArgument, message: buildNonArrayDepsMessage(hookName) });
+          return;
+        }
+        if (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null) {
+          if (isAutoDependenciesHook(hookName)) return;
+          if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) {
             context.report({
               node: depsArgument,
-              message: buildMissingDepMessage(hookName, [...nonArrayCaptureKeys].join(", ")),
+              message: buildMissingDepArrayMessage(hookName),
             });
+            return;
           }
-          return;
         }
 
         if (!isNodeOfType(depsArgument, "ArrayExpression")) {
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.regressions.test.ts
new file mode 100644
index 0000000000..02a5591dbc
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.regressions.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vite-plus/test";
+import { runRule } from "../../../test-utils/run-rule.js";
+import { noDirectMutationState } from "./no-direct-mutation-state.js";
+
+describe("react-builtins/no-direct-mutation-state — regressions", () => {
+  it("does not claim users see stale data when setState runs after the mutation", () => {
+    const result = runRule(
+      noDirectMutationState,
+      `class Counter extends React.Component {
+        increment() {
+          this.state.count = this.state.count + 1;
+          this.setState({ count: this.state.count });
+        }
+        render() { return <button onClick={() => this.increment()}>{this.state.count}</button>; }
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).not.toContain("stale data");
+    expect(result.diagnostics[0].message).toContain("this.setState");
+  });
+
+  it("still flags a bare mutation outside the constructor", () => {
+    const result = runRule(
+      noDirectMutationState,
+      `class Counter extends React.Component {
+        increment() { this.state.count = this.state.count + 1; }
+        render() { return <span>{this.state.count}</span>; }
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.ts
index 591f169e27..683c7a81c7 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-direct-mutation-state.ts
@@ -9,7 +9,7 @@ import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { Rule } from "../../utils/rule.js";
 
 const MESSAGE =
-  "Your users see stale data because mutating `this.state` by hand never redraws & gets overwritten.";
+  "Mutating `this.state` by hand never triggers a redraw on its own & a later setState can overwrite it, so use `this.setState` instead.";
 
 // Ancestor walk replicates `oxc_linter::rules::react::no_direct_mutation_state`'s
 // `should_ignore_component`: walk up from the assignment until we either
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts
index f642981eaf..d3aa0faf2a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts
@@ -296,4 +296,48 @@ describe("react-builtins/rules-of-hooks — regressions: local non-hook use* cal
       "`useCounter` runs inside `calculateTotal`, which is not a component or Hook, so React cannot attach Hook state to a render.",
     );
   });
+
+  it("does not flag hooks inside an anonymous inline callback with no resolved name", () => {
+    const result = runTsx(`
+      import { use } from "react";
+      register(() => {
+        const value = use(somePromise);
+        return value;
+      });
+    `);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags hooks inside a named non-component function", () => {
+    const result = runTsx(`
+      import { useState } from "react";
+      function calculateTotal() {
+        const [value] = useState(0);
+        return value;
+      }
+    `);
+    expect(result.diagnostics).toHaveLength(1);
+  });
+
+  it("does not treat a hook call in a ternary test position as conditional", () => {
+    const result = runTsx(`
+      import { useFlag, useState } from "./flags";
+      const MyComponent = () => {
+        const label = useFlag("beta") ? "beta" : "stable";
+        return label;
+      };
+    `);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a hook call in a ternary branch position", () => {
+    const result = runTsx(`
+      import { useState } from "react";
+      const MyComponent = ({ enabled }) => {
+        const value = enabled ? useState(0)[0] : 0;
+        return value;
+      };
+    `);
+    expect(result.diagnostics).toHaveLength(1);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts
index 72f3d4b030..2eaf31f886 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts
@@ -550,7 +550,13 @@ const isInsideClassComponent = (node: EsTreeNode): boolean => {
 const hasShortCircuitAncestor = (descendant: EsTreeNode, ancestor: EsTreeNode): boolean => {
   let current: EsTreeNode | null | undefined = descendant.parent;
   while (current && current !== ancestor) {
-    if (isNodeOfType(current, "ConditionalExpression")) return true;
+    if (
+      isNodeOfType(current, "ConditionalExpression") &&
+      (isWithinRange(descendant, current.consequent) ||
+        isWithinRange(descendant, current.alternate))
+    ) {
+      return true;
+    }
     if (
       isNodeOfType(current, "LogicalExpression") &&
       (current.operator === "&&" || current.operator === "||" || current.operator === "??") &&
@@ -768,6 +774,7 @@ export const rulesOfHooks = defineRule({
             if (parentInfo.isComponentOrHook) isInsideComponentOrHook = true;
           }
           if (!isInsideComponentOrHook) {
+            if (!enclosing.hasResolvedName) return;
             if (isLocalNonHookFunctionCallee(node, context.scopes, settings)) return;
             context.report({
               node: node.callee,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.regressions.test.ts
index 670fb23926..555fd77883 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.regressions.test.ts
@@ -119,4 +119,22 @@ describe("react-native/rn-no-dimensions-get — regressions", () => {
     expect(result.parseErrors).toEqual([]);
     expect(result.diagnostics).toEqual([]);
   });
+
+  it("does not claim users see a stale layout for a fresh read in an event handler", () => {
+    const result = runRule(
+      rnNoDimensionsGet,
+      `import { Dimensions } from "react-native";
+      function Card() {
+        const onPress = () => {
+          const { width } = Dimensions.get("window");
+          logTapPosition(width);
+        };
+        return <Pressable onPress={onPress} />;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).not.toContain("Your users see a stale layout");
+    expect(result.diagnostics[0].message).toContain("never updates");
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.ts
index 5335dfdb6f..93b2cebf13 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-dimensions-get.ts
@@ -63,7 +63,7 @@ export const rnNoDimensionsGet = defineRule({
         context.report({
           node,
           message:
-            "Your users see a stale layout on rotation or resize because Dimensions.get() does not update.",
+            "Dimensions.get() reads the size once and never updates, so layouts built from it go stale on rotation or resize.",
         });
       }
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.test.ts
index 9d5e41f5ca..8b3723fb8a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.test.ts
@@ -643,4 +643,18 @@ describe("react-native/rn-no-raw-text", () => {
       `);
     });
   });
+
+  describe("message preview", () => {
+    it("collapses internal whitespace so CRLF and LF sources produce the same message", () => {
+      const source = `const App = () => (\n  <View>\n    a long raw headline that\n    wraps across source lines in the file body\n  </View>\n);`;
+      const lfResult = runRule(rnNoRawText, source, { filename: "App.native.tsx" });
+      const crlfResult = runRule(rnNoRawText, source.replace(/\n/g, "\r\n"), {
+        filename: "App.native.tsx",
+      });
+      expect(lfResult.diagnostics.map((diagnostic) => diagnostic.message)).toEqual(
+        crlfResult.diagnostics.map((diagnostic) => diagnostic.message),
+      );
+      expect(lfResult.diagnostics[0]?.message).not.toContain("\n");
+    });
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
index 3acac797ec..739b212bfb 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-native/rn-no-raw-text.ts
@@ -19,10 +19,12 @@ import { isExpoUiComponentElement } from "./utils/is-expo-ui-component-element.j
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 
-const truncateText = (text: string): string =>
-  text.length > RAW_TEXT_PREVIEW_MAX_CHARS
-    ? `${text.slice(0, RAW_TEXT_PREVIEW_MAX_CHARS)}...`
-    : text;
+const truncateText = (text: string): string => {
+  const collapsedText = text.replace(/\s+/g, " ");
+  return collapsedText.length > RAW_TEXT_PREVIEW_MAX_CHARS
+    ? `${collapsedText.slice(0, RAW_TEXT_PREVIEW_MAX_CHARS)}...`
+    : collapsedText;
+};
 
 const isRawTextContent = (child: EsTreeNode): boolean => {
   if (isNodeOfType(child, "JSXText")) return Boolean(child.value?.trim());
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.regressions.test.ts
index 76d8900007..17801305ab 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.regressions.test.ts
@@ -83,6 +83,66 @@ export default async function Page() {
     expect(result.diagnostics.length).toBeGreaterThan(0);
   });
 
+  it("does not flag the next/og static-asset fetch (new URL with import.meta.url)", () => {
+    const result = runRule(
+      serverFetchWithoutRevalidate,
+      `export async function GET() {
+  const font = await fetch(new URL("../../fonts/Mono.ttf", import.meta.url)).then((res) =>
+    res.arrayBuffer(),
+  );
+  return new Response(font);
+}`,
+      { filename: "src/app/api/og/route.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("does not flag a Remix route.tsx even though it lives under app/", () => {
+    const result = runRule(
+      serverFetchWithoutRevalidate,
+      `import { useLoaderData } from "@remix-run/react";
+export const loader = async () => {
+  const data = await fetch("https://api.example.com/feed");
+  return data.json();
+};
+export default function Page() {
+  const data = useLoaderData();
+  return <div>{data.title}</div>;
+}`,
+      { filename: "apps/webapp/app/routes/feed/route.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a Next.js page whose only router import is type-only", () => {
+    const result = runRule(
+      serverFetchWithoutRevalidate,
+      `import type { LinkProps } from "react-router";
+export default async function Page() {
+  const data = await fetch("https://api.example.com/feed");
+  return <div>{(await data.json()).title}</div>;
+}`,
+      { filename: "src/app/feed/page.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
+  it("still flags a runtime-URL fetch in an og route handler", () => {
+    const result = runRule(
+      serverFetchWithoutRevalidate,
+      `export async function GET() {
+  const feed = await fetch("https://api.example.com/feed");
+  return Response.json(await feed.json());
+}`,
+      { filename: "src/app/api/og/route.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
   it("still flags a bare fetch with no caching config", () => {
     const result = runRule(
       serverFetchWithoutRevalidate,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.ts
index 81f5e3b26a..dd2cde90f1 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-fetch-without-revalidate.ts
@@ -3,6 +3,7 @@ import { isInProjectDirectory } from "../../utils/is-in-project-directory.js";
 import { normalizeFilename } from "../../utils/normalize-filename.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import { isTypeOnlyImport } from "../../utils/is-type-only-import.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { isMutatingFetchCall } from "../../utils/find-side-effect.js";
@@ -60,6 +61,35 @@ const APP_ROUTER_FILE_PATTERN = new RegExp(
 
 const NON_PROJECT_PATH_PATTERN = /\/(?:node_modules|dist|build|\.next)\//;
 
+// Remix / React Router also use an `app/` directory with `route.tsx`
+// files, but their `fetch` has standard browser/undici semantics — the
+// Next.js data-cache never applies there.
+const REMIX_IMPORT_SOURCE_PATTERN = /^(?:@remix-run\/|@react-router\/|react-router(?:-dom)?$)/;
+
+const programImportsRemixRouter = (programNode: EsTreeNodeOfType<"Program">): boolean =>
+  (programNode.body ?? []).some(
+    (statement) =>
+      isNodeOfType(statement, "ImportDeclaration") &&
+      !isTypeOnlyImport(statement) &&
+      typeof statement.source?.value === "string" &&
+      REMIX_IMPORT_SOURCE_PATTERN.test(statement.source.value),
+  );
+
+// `fetch(new URL("./font.ttf", import.meta.url))` is the documented
+// `next/og` pattern for loading a bundled static asset — caching it
+// forever is the intended behavior, so "stale data" never applies.
+const isImportMetaUrlAssetArgument = (urlArg: EsTreeNode | undefined): boolean => {
+  if (!isNodeOfType(urlArg, "NewExpression")) return false;
+  if (!isNodeOfType(urlArg.callee, "Identifier") || urlArg.callee.name !== "URL") return false;
+  const baseArg = urlArg.arguments?.[1];
+  return (
+    isNodeOfType(baseArg, "MemberExpression") &&
+    isNodeOfType(baseArg.object, "MetaProperty") &&
+    isNodeOfType(baseArg.property, "Identifier") &&
+    baseArg.property.name === "url"
+  );
+};
+
 export const serverFetchWithoutRevalidate = defineRule({
   id: "server-fetch-without-revalidate",
   title: "Fetch without revalidate",
@@ -87,7 +117,7 @@ export const serverFetchWithoutRevalidate = defineRule({
             isNodeOfType(statement.expression, "Literal") &&
             statement.expression.value === "use client",
         );
-        isServerSideFile = !hasUseClient;
+        isServerSideFile = !hasUseClient && !programImportsRemixRouter(node);
       },
       CallExpression(node: EsTreeNodeOfType<"CallExpression">) {
         if (!isServerSideFile) return;
@@ -112,6 +142,7 @@ export const serverFetchWithoutRevalidate = defineRule({
         }
 
         const urlArg = node.arguments?.[0];
+        if (isImportMetaUrlAssetArgument(urlArg)) return;
         const urlText =
           isNodeOfType(urlArg, "Literal") && typeof urlArg.value === "string"
             ? `"${urlArg.value}"`
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.regressions.test.ts
index 9517e9e49f..46030b2066 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.regressions.test.ts
@@ -190,4 +190,31 @@ export async function isAdmin(role) {
     expect(result.parseErrors).toEqual([]);
     expect(result.diagnostics).toEqual([]);
   });
+
+  it("does not claim a leak for a never-written let, only that a write would leak", () => {
+    const result = runRule(
+      serverNoMutableModuleState,
+      `"use server";
+let apiVersion = "v1";
+export async function getVersion() {
+  return apiVersion;
+}`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).toContain("any write to it leaks");
+  });
+
+  it("still flags a reassigned module-scoped let", () => {
+    const result = runRule(
+      serverNoMutableModuleState,
+      `"use server";
+let lastUserId = null;
+export async function track(userId) {
+  lastUserId = userId;
+}`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.ts
index e92edcfe91..d74a8412e8 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-no-mutable-module-state.ts
@@ -229,7 +229,7 @@ export const serverNoMutableModuleState = defineRule({
           if (node.kind === "let" || node.kind === "var") {
             context.report({
               node: declarator,
-              message: `Module-scoped ${node.kind} "${variableName}" leaks state between your users, since every request shares it.`,
+              message: `Module-scoped ${node.kind} "${variableName}" is shared by every request, so any write to it leaks state between your users.`,
             });
             continue;
           }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.regressions.test.ts
index d4ff9cd75b..319084d04b 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.regressions.test.ts
@@ -44,6 +44,61 @@ describe("server-sequential-independent-await — regressions", () => {
     expect(result.diagnostics).toEqual([]);
   });
 
+  it("stays silent when one await is a Next.js request-scoped API (headers)", () => {
+    const result = runRule(
+      serverSequentialIndependentAwait,
+      `import { headers } from "next/headers";
+export default async function Page() {
+  const headersList = await headers();
+  const rows = await fetchRows();
+  return rows;
+}`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent when the first await is a next-intl server helper", () => {
+    const result = runRule(
+      serverSequentialIndependentAwait,
+      `import { getTranslations } from "next-intl/server";
+export default async function Page() {
+  const t = await getTranslations("Home");
+  const session = await getSession();
+  return session;
+}`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent when awaiting Next.js 15 promise props (params/searchParams)", () => {
+    const result = runRule(
+      serverSequentialIndependentAwait,
+      `export default async function Page(props) {
+  const searchParams = await props.searchParams;
+  const { segments } = await props.params;
+  return segments;
+}`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a fetch pair when a same-named local headers() is not the Next.js API", () => {
+    const result = runRule(
+      serverSequentialIndependentAwait,
+      `import { headers } from "./my-io.js";
+export default async function Page() {
+  const headersList = await headers();
+  const rows = await fetchRows();
+  return rows;
+}`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
   it("still flags two genuinely independent data fetches", () => {
     const result = runRule(
       serverSequentialIndependentAwait,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.ts
index 8e10c71564..445e0763b7 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/server/server-sequential-independent-await.ts
@@ -1,6 +1,7 @@
 import { collectPatternNames } from "../../utils/collect-pattern-names.js";
 import { defineRule } from "../../utils/define-rule.js";
 import { getCalleeName } from "../../utils/get-callee-name.js";
+import { getImportedNameFromModule } from "../../utils/find-import-source-for-name.js";
 import { isAuthGuardName } from "../../utils/is-auth-guard-name.js";
 import { tokenizeIdentifierWords } from "../../utils/tokenize-identifier-words.js";
 import { walkAst } from "../../utils/walk-ast.js";
@@ -79,45 +80,50 @@ const GATE_LEADING_VERBS = new Set([
   "authenticate",
 ]);
 
-// True when `name` is bound by an earlier statement in the same block to
-// a non-awaited expression — i.e. a promise that was *started* before
-// this await. `const p = fetchUser(); ... const user = await p;` is
-// already concurrent, so awaiting `p` is not a waterfall.
-const isStartedPromiseBinding = (
-  name: string,
-  statements: EsTreeNode[],
-  beforeIndex: number,
-): boolean => {
-  for (let index = 0; index < beforeIndex; index++) {
-    const statement = statements[index];
-    if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-    for (const declarator of statement.declarations ?? []) {
-      if (!isNodeOfType(declarator.id, "Identifier")) continue;
-      if (declarator.id.name !== name) continue;
-      if (declarator.init && !isNodeOfType(declarator.init, "AwaitExpression")) return true;
+// True when the declaration awaits an already-existing promise value
+// rather than starting new work — a bare Identifier (`await postsPromise`)
+// or a member read (`await props.params` in Next.js 15). The promise was
+// created before this statement ran, so the await is not the second leg
+// of a waterfall.
+const declarationAwaitsExistingPromise = (declaration: EsTreeNode): boolean => {
+  if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
+  for (const declarator of declaration.declarations ?? []) {
+    const init = declarator.init;
+    if (!isNodeOfType(init, "AwaitExpression")) continue;
+    const argument = init.argument;
+    if (isNodeOfType(argument, "Identifier") || isNodeOfType(argument, "MemberExpression")) {
+      return true;
     }
   }
   return false;
 };
 
-// True when the declaration awaits a bare Identifier that was started as
-// a promise earlier in the same block (`await postsPromise`). Such an
-// await is already running concurrently, so it is not the second leg of
-// a waterfall.
-const declarationAwaitsStartedPromise = (
-  declaration: EsTreeNode,
-  statements: EsTreeNode[],
-  declarationIndex: number,
-): boolean => {
+// Next.js request-scoped async APIs (`headers()`, `cookies()`,
+// `draftMode()`, `connection()`) and next-intl's server helpers
+// (`getTranslations()`, `getMessages()`, …) resolve from the ambient
+// request context, not the network — wrapping them in `Promise.all`
+// saves nothing.
+const REQUEST_SCOPED_IMPORT_SOURCES = ["next/headers", "next-intl/server"];
+
+const isRequestScopedCallee = (callee: EsTreeNode): boolean => {
+  if (!isNodeOfType(callee, "Identifier")) return false;
+  if (
+    REQUEST_SCOPED_IMPORT_SOURCES.some(
+      (moduleSource) => getImportedNameFromModule(callee, callee.name, moduleSource) !== null,
+    )
+  ) {
+    return true;
+  }
+  return getImportedNameFromModule(callee, callee.name, "next/server") === "connection";
+};
+
+const declarationAwaitsRequestScopedCall = (declaration: EsTreeNode): boolean => {
   if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
   for (const declarator of declaration.declarations ?? []) {
     const init = declarator.init;
     if (!isNodeOfType(init, "AwaitExpression")) continue;
     const argument = init.argument;
-    if (
-      isNodeOfType(argument, "Identifier") &&
-      isStartedPromiseBinding(argument.name, statements, declarationIndex)
-    ) {
+    if (isNodeOfType(argument, "CallExpression") && isRequestScopedCallee(argument.callee)) {
       return true;
     }
   }
@@ -165,10 +171,18 @@ export const serverSequentialIndependentAwait = defineRule({
         if (!declarationStartsWithAwait(nextStatement)) continue;
 
         if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
-        // The second await is on a promise started earlier in the block
-        // (`const p = fetchPosts(); … const posts = await p;`) — already
-        // concurrent, so there's no waterfall to flatten.
-        if (declarationAwaitsStartedPromise(nextStatement, statements, statementIndex + 1))
+        // The second await is on a promise that already exists
+        // (`const p = fetchPosts(); … const posts = await p;`,
+        // `await props.params`) — already running, so there's no
+        // waterfall to flatten.
+        if (declarationAwaitsExistingPromise(nextStatement)) continue;
+        // A request-scoped API (`await headers()`, `await getTranslations()`)
+        // resolves from the ambient request context, not the network, so
+        // pairing it with a real fetch is not a waterfall.
+        if (
+          declarationAwaitsRequestScopedCall(currentStatement) ||
+          declarationAwaitsRequestScopedCall(nextStatement)
+        )
           continue;
         // A guard / side-effect gate (`await requireSession()`, `db.connect()`)
         // must run before the next await — its ordering is intentional, not a
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-state.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-state.regressions.test.ts
index b7ef722874..55ae0acff9 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-state.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-derived-state.regressions.test.ts
@@ -465,4 +465,67 @@ describe("no-derived-state — regressions", () => {
     expect(result.parseErrors).toEqual([]);
     expect(result.diagnostics).toHaveLength(1);
   });
+
+  it("stays silent on a layout measurement read through a ref.current alias (posthog CollapsibleContent)", () => {
+    const result = runRule(
+      noDerivedState,
+      `import { useEffect, useRef, useState } from "react";
+      const CollapsibleContent = ({ maxHeight, children }) => {
+        const [isOverflowing, setIsOverflowing] = useState(false);
+        const contentRef = useRef(null);
+        useEffect(() => {
+          const el = contentRef.current;
+          if (el) {
+            setIsOverflowing(el.scrollHeight > maxHeight);
+          }
+        }, [children, maxHeight]);
+        return <div ref={contentRef}>{children}</div>;
+      };`,
+      { forceJsx: true },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("does not stack-overflow on mutually referencing .current aliases", () => {
+    const result = runRule(
+      noDerivedState,
+      `import { useEffect, useState } from "react";
+      const Cycle = ({ maxHeight }) => {
+        const [isOverflowing, setIsOverflowing] = useState(false);
+        const a = b.current;
+        const b = a.current;
+        useEffect(() => {
+          const el = a;
+          if (el) {
+            setIsOverflowing(el.scrollHeight > maxHeight);
+          }
+        }, [maxHeight]);
+        return <div>{String(isOverflowing)}</div>;
+      };`,
+      { forceJsx: true },
+    );
+    expect(result.parseErrors).toEqual([]);
+  });
+
+  it("still flags a plain-data alias whose value is derivable at render time", () => {
+    const result = runRule(
+      noDerivedState,
+      `import { useEffect, useState } from "react";
+      const Summary = ({ maxHeight, content }) => {
+        const [isOverflowing, setIsOverflowing] = useState(false);
+        useEffect(() => {
+          const el = content;
+          if (el) {
+            setIsOverflowing(el.length > maxHeight);
+          }
+        }, [content, maxHeight]);
+        return <div>{String(isOverflowing)}</div>;
+      };`,
+      { forceJsx: true },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0]?.message).toContain('"isOverflowing"');
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.regressions.test.ts
index 8bfebc74e7..c1768dd80c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.regressions.test.ts
@@ -282,6 +282,66 @@ describe("no-direct-state-mutation — regressions", () => {
     expect(result.diagnostics[0].message).toContain("items");
   });
 
+  it("stays silent on a callback-ref DOM node written to in an effect", () => {
+    const result = runRule(
+      noDirectStateMutation,
+      `function CallbackRefCounter() {
+        const [node, setNode] = useState(null);
+        useEffect(() => {
+          if (!node) return;
+          node.dataset.mounted = "true";
+        }, [node]);
+        return <span ref={setNode}>ready</span>;
+      }`,
+      { filename: "counter.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent when a callback-ref DOM node has its style mutated inline", () => {
+    const result = runRule(
+      noDirectStateMutation,
+      `function Highlight() {
+        const [element, setElement] = useState(null);
+        if (element) element.style.outline = "2px solid";
+        return <div ref={setElement} />;
+      }`,
+      { filename: "highlight.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags null-initialized plain-object state when the setter is not a callback ref", () => {
+    const result = runRule(
+      noDirectStateMutation,
+      `function Form() {
+        const [draft, setDraft] = useState(null);
+        const touch = () => { draft.dirty = true; };
+        return <button onClick={touch}>save</button>;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).toContain("draft");
+  });
+
+  it("does not claim the screen won't update when a setter runs after the mutation", () => {
+    const result = runRule(
+      noDirectStateMutation,
+      `function List() {
+        const [items, setItems] = useState([]);
+        const add = (x) => { items.push(x); setItems([...items]); };
+        return <button onClick={() => add(1)}>{items.length}</button>;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).not.toContain("won't update");
+    expect(result.diagnostics[0].message).toContain("items");
+  });
+
   it("stays silent on a lazy initializer returning an opaque instance", () => {
     const result = runRule(
       noDirectStateMutation,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.ts
index 107bff45e4..3cb419a232 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-direct-state-mutation.ts
@@ -6,6 +6,7 @@ import { isComponentAssignment } from "../../utils/is-component-assignment.js";
 import { isFunctionLike } from "../../utils/is-function-like.js";
 import { isUppercaseName } from "../../utils/is-uppercase-name.js";
 import { stripParenExpression } from "../../utils/strip-paren-expression.js";
+import { walkAst } from "../../utils/walk-ast.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { RuleContext } from "../../utils/rule-context.js";
 import { collectUseStateBindings } from "./utils/collect-use-state-bindings.js";
@@ -87,6 +88,32 @@ const initializerMarksPlainState = (initializerArgument: EsTreeNode | undefined)
   return producesPlainStateValue(unwrapped);
 };
 
+// Setter names passed straight to a JSX `ref` attribute (`ref={setNode}`) are
+// callback refs, so their paired state holds a DOM element / component
+// instance — not React render data. Writing to its fields
+// (`node.dataset.x = ...`, `node.style.x = ...`) is deliberate imperative DOM
+// work, not a lost state update, so those bindings must not be treated as
+// plain-object state.
+const collectCallbackRefSetterNames = (componentBody: EsTreeNode): Set<string> => {
+  const callbackRefSetterNames = new Set<string>();
+  walkAst(componentBody, (node: EsTreeNode): void => {
+    if (!isNodeOfType(node, "JSXAttribute")) return;
+    const attributeName = node.name;
+    if (
+      isNodeOfType(attributeName, "JSXIdentifier") &&
+      attributeName.name === "ref" &&
+      node.value &&
+      isNodeOfType(node.value, "JSXExpressionContainer")
+    ) {
+      const expression = stripParenExpression(node.value.expression);
+      if (isNodeOfType(expression, "Identifier")) {
+        callbackRefSetterNames.add(expression.name);
+      }
+    }
+  });
+  return callbackRefSetterNames;
+};
+
 const collectFunctionLocalBindings = (functionNode: EsTreeNode): Set<string> => {
   const localBindings = new Set<string>();
   if (
@@ -173,8 +200,10 @@ export const noDirectStateMutation = defineRule({
       // is only React-owned-state mutation when the state plausibly holds
       // React-managed data — see `initializerMarksPlainState` for the exact
       // boundary between plain data and opaque third-party instances.
+      const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
       const plainObjectStateValueNames = new Set<string>();
       for (const binding of bindings) {
+        if (callbackRefSetterNames.has(binding.setterName)) continue;
         if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
         if (initializerMarksPlainState(binding.declarator.init.arguments?.[0])) {
           plainObjectStateValueNames.add(binding.valueName);
@@ -193,7 +222,7 @@ export const noDirectStateMutation = defineRule({
             if (currentlyShadowed.has(rootName)) return;
             context.report({
               node: child,
-              message: `Your screen won't update because you change "${rootName}" in place.`,
+              message: `React can't tell you changed "${rootName}" in place, so this update can be skipped or lost.`,
             });
             return;
           }
@@ -210,7 +239,7 @@ export const noDirectStateMutation = defineRule({
             if (currentlyShadowed.has(rootName)) return;
             context.report({
               node: child,
-              message: `Your screen won't update because .${methodName}() changes "${rootName}" in place.`,
+              message: `React can't tell .${methodName}() changed "${rootName}" in place, so this update can be skipped or lost.`,
             });
           }
         },
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.regressions.test.ts
index 4a8ef83db3..1f86203db0 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.regressions.test.ts
@@ -30,6 +30,122 @@ describe("no-initialize-state — regressions", () => {
     expect(result.diagnostics).toEqual([]);
   });
 
+  it("stays silent when a mount effect seeds a zero-arg new Date() value", () => {
+    const result = runRule(
+      noInitializeState,
+      `function Clock() {
+        const [now, setNow] = useState(null);
+        useEffect(() => { setNow(new Date().toLocaleTimeString()); }, []);
+        return <time>{now}</time>;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent when the cleanup disposes the resource feeding the setter", () => {
+    const result = runRule(
+      noInitializeState,
+      `function AudioNodeState() {
+        const [gainNode, setGainNode] = useState(null);
+        useEffect(() => {
+          const audioContext = new AudioContext();
+          setGainNode(audioContext.createGain());
+          return () => {
+            audioContext.close();
+          };
+        }, []);
+        return null;
+      }`,
+      { filename: "audio.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent when a mount effect stores a socket its cleanup closes", () => {
+    const result = runRule(
+      noInitializeState,
+      `function LiveFeed({ url }) {
+        const [socket, setSocket] = useState(null);
+        useEffect(() => {
+          const webSocket = new WebSocket(url);
+          setSocket(webSocket);
+          return () => webSocket.close();
+        }, []);
+        return null;
+      }`,
+      { filename: "feed.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("stays silent when the setter only fires from an observer callback", () => {
+    const result = runRule(
+      noInitializeState,
+      `function ObserverConnected() {
+        const [entryCount, setEntryCount] = useState(0);
+        useEffect(() => {
+          const observer = new MutationObserver((mutations) => setEntryCount(mutations.length));
+          observer.observe(document.body, { childList: true });
+          return () => observer.disconnect();
+        }, []);
+        return <output>{entryCount}</output>;
+      }`,
+      { filename: "observer.tsx" },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a hoistable literal local even when the cleanup mentions it", () => {
+    const result = runRule(
+      noInitializeState,
+      `function C() {
+        const [count, setCount] = useState(null);
+        useEffect(() => {
+          const initial = 42;
+          setCount(initial);
+          return () => console.log(initial);
+        }, []);
+        return null;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
+  it("still flags a literal init even when the effect has an unrelated cleanup", () => {
+    const result = runRule(
+      noInitializeState,
+      `function C() {
+        const [count, setCount] = useState(null);
+        useEffect(() => {
+          setCount(42);
+          const id = setInterval(() => {}, 1000);
+          return () => clearInterval(id);
+        }, []);
+        return null;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
+  it("still flags a deterministic new Date(value) init from a mount effect", () => {
+    const result = runRule(
+      noInitializeState,
+      `function C({ createdAt }) {
+        const [label, setLabel] = useState("");
+        useEffect(() => { setLabel(new Date(0).toISOString()); }, []);
+        return <span>{label}</span>;
+      }`,
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
   it("still flags a deterministic literal init from a mount effect", () => {
     const result = runRule(
       noInitializeState,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.ts
index b1562d4626..ccb9da6b7a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-initialize-state.ts
@@ -100,6 +100,84 @@ const argumentReadsPostMountMeasurement = (
   return found;
 };
 
+// A resource is something constructed at runtime (`new AudioContext()`,
+// `navigator.mediaDevices.getUserMedia()`); plain data initializers
+// (literals, object/array expressions) are hoistable and never need a
+// dispose slot.
+const isResourceLikeInitializer = (initializer: EsTreeNode): boolean => {
+  if (isNodeOfType(initializer, "AwaitExpression")) {
+    return isResourceLikeInitializer(initializer.argument as EsTreeNode);
+  }
+  return isNodeOfType(initializer, "NewExpression") || isNodeOfType(initializer, "CallExpression");
+};
+
+// Effect-local names that (transitively) produce the setter argument:
+// `const audioContext = new AudioContext(); setGainNode(audioContext.createGain())`
+// yields { audioContext }.
+const collectArgumentSourceLocalNames = (
+  argument: EsTreeNode,
+  effectFn: EsTreeNode,
+  sourceLocalNames: Set<string> = new Set(),
+): Set<string> => {
+  walkAst(argument, (child: EsTreeNode): void => {
+    if (!isNodeOfType(child, "Identifier")) return;
+    if (sourceLocalNames.has(child.name)) return;
+    const localInitializer = findEffectLocalInitializer(effectFn, child.name);
+    if (!localInitializer || !isResourceLikeInitializer(localInitializer)) return;
+    sourceLocalNames.add(child.name);
+    collectArgumentSourceLocalNames(localInitializer, effectFn, sourceLocalNames);
+  });
+  return sourceLocalNames;
+};
+
+const isFunctionExpressionLike = (node: EsTreeNode): boolean =>
+  isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression");
+
+const findCleanupFunction = (effectFn: EsTreeNode): EsTreeNode | null => {
+  if (
+    !isNodeOfType(effectFn, "ArrowFunctionExpression") &&
+    !isNodeOfType(effectFn, "FunctionExpression")
+  ) {
+    return null;
+  }
+  const body = effectFn.body;
+  if (!isNodeOfType(body, "BlockStatement")) return null;
+  let cleanupFunction: EsTreeNode | null = null;
+  walkAst(body, (child: EsTreeNode): boolean | void => {
+    if (cleanupFunction) return false;
+    if (isNodeOfType(child, "ReturnStatement")) {
+      if (child.argument && isFunctionExpressionLike(child.argument as EsTreeNode)) {
+        cleanupFunction = child.argument as EsTreeNode;
+      }
+      return false;
+    }
+    if (child !== body && isFunctionExpressionLike(child)) return false;
+    if (isNodeOfType(child, "FunctionDeclaration")) return false;
+  });
+  return cleanupFunction;
+};
+
+// A mount effect whose CLEANUP disposes the very resource feeding the setter
+// (`const audioContext = new AudioContext(); setGainNode(audioContext.createGain());
+// return () => audioContext.close();`) owns a resource lifecycle — the value
+// cannot be hoisted into `useState(initial)` because render has no matching
+// dispose slot, so the effect is the correct home for the init.
+const cleanupDisposesArgumentSource = (argument: EsTreeNode, effectFn: EsTreeNode): boolean => {
+  const cleanupFunction = findCleanupFunction(effectFn);
+  if (!cleanupFunction) return false;
+  const sourceLocalNames = collectArgumentSourceLocalNames(argument, effectFn);
+  if (sourceLocalNames.size === 0) return false;
+  let referencesSource = false;
+  walkAst(cleanupFunction, (child: EsTreeNode): boolean | void => {
+    if (referencesSource) return false;
+    if (isNodeOfType(child, "Identifier") && sourceLocalNames.has(child.name)) {
+      referencesSource = true;
+      return false;
+    }
+  });
+  return referencesSource;
+};
+
 // 1:1 port of upstream `src/rules/no-initialize-state.js`.
 // Difference vs upstream: upstream uses `context.sourceCode.getText`
 // for the diagnostic's "arguments" field; we use
@@ -153,6 +231,13 @@ export const noInitializeState = defineRule({
         ) {
           continue;
         }
+        if (
+          callExpr.arguments?.some(
+            (argument) => Boolean(argument) && cleanupDisposesArgumentSource(argument, effectFn),
+          )
+        ) {
+          continue;
+        }
         const useStateDecl = getUseStateDecl(analysis, ref);
         if (!useStateDecl || !isNodeOfType(useStateDecl, "VariableDeclarator")) continue;
         if (!isNodeOfType(useStateDecl.id, "ArrayPattern")) continue;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.regressions.test.ts
new file mode 100644
index 0000000000..7dad72fad6
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.regressions.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vite-plus/test";
+import { runRule } from "../../../test-utils/run-rule.js";
+import { noResetAllStateOnPropChange } from "./no-reset-all-state-on-prop-change.js";
+
+describe("no-reset-all-state-on-prop-change — regressions", () => {
+  // excalidraw ToolPopover: the setter only runs inside an event-subscription
+  // callback registered by the effect, so state resets when the emitter
+  // fires — not when the `app` prop changes.
+  it("stays silent when the setter only runs inside a subscription callback", () => {
+    const result = runRule(
+      noResetAllStateOnPropChange,
+      `import { useEffect, useState } from "react";
+      const ToolPopover = ({ app }) => {
+        const [isPopupOpen, setIsPopupOpen] = useState(false);
+        useEffect(() => {
+          const unsubscribe = app.onPointerDownEmitter.on(() => {
+            setIsPopupOpen(false);
+          });
+          return () => unsubscribe?.();
+        }, [app]);
+        return <div>{String(isPopupOpen)}</div>;
+      };`,
+      { forceJsx: true },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags a synchronous all-state reset keyed on a prop", () => {
+    const result = runRule(
+      noResetAllStateOnPropChange,
+      `import { useEffect, useState } from "react";
+      const Profile = ({ userId }) => {
+        const [comment, setComment] = useState("");
+        useEffect(() => {
+          setComment("");
+        }, [userId]);
+        return <textarea value={comment} onChange={(e) => setComment(e.target.value)} />;
+      };`,
+      { forceJsx: true },
+    );
+    expect(result.parseErrors).toEqual([]);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0]?.message).toContain("clears all state");
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.ts
index 7d94855a76..62a09c5bd4 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.ts
@@ -9,12 +9,13 @@ import { getProgramAnalysis, type ProgramAnalysis } from "./utils/effect/get-pro
 import {
   findContainingNode,
   getEffectDepsRefs,
+  getEffectFn,
   getEffectFnRefs,
   getUseStateDecl,
   isCustomHook,
   isProp,
   isState,
-  isStateSetterCall,
+  isSyncStateSetterCall,
   isUseEffect,
 } from "./utils/effect/react.js";
 
@@ -66,8 +67,14 @@ const findPropUsedToResetAllState = (
   effectFnRefs: Reference[],
   depsRefs: Reference[],
   useEffectNode: EsTreeNode,
+  effectFn: EsTreeNode,
 ): Reference | null => {
-  const stateSetterRefs = effectFnRefs.filter((ref) => isStateSetterCall(analysis, ref));
+  // A setter that only runs inside a listener / observer / subscription
+  // callback fires on that event, not when the prop changes — only
+  // synchronous setter calls are the reset-on-prop-change shape.
+  const stateSetterRefs = effectFnRefs.filter((ref) =>
+    isSyncStateSetterCall(analysis, ref, effectFn),
+  );
   if (stateSetterRefs.length === 0) return null;
 
   const allResetToInitial = stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, ref));
@@ -101,8 +108,16 @@ export const noResetAllStateOnPropChange = defineRule({
       if (!effectFnRefs || !depsRefs) return;
       const containing = findContainingNode(analysis, node);
       if (containing && isCustomHook(containing)) return;
+      const effectFn = getEffectFn(analysis, node);
+      if (!effectFn) return;
 
-      const propUsedToReset = findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node);
+      const propUsedToReset = findPropUsedToResetAllState(
+        analysis,
+        effectFnRefs,
+        depsRefs,
+        node,
+        effectFn,
+      );
       if (!propUsedToReset) return;
       context.report({
         node,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts
index 68e7a9260d..f96b7ca6fa 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/ast.ts
@@ -17,6 +17,38 @@ import { VISITOR_KEYS } from "./constants.js";
 const getChildKeys = (node: EsTreeNode): ReadonlyArray<string> =>
   VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
 
+// A function-expression ARGUMENT of a binding's initializer call
+// (`const observer = new MutationObserver((m) => setN(m.length))`) is a
+// callback the instance invokes later — using the binding does not run
+// it, so refs inside it must not count as the binding's own call graph.
+// Bare identifier arguments (`const debounced = debounce(setN)`) still do.
+const HOOK_NAME_PATTERN = /^use[A-Z0-9]/;
+
+const isInsideCallbackArgumentOf = (identifier: EsTreeNode, initializer: EsTreeNode): boolean => {
+  if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) {
+    return false;
+  }
+  // Hook wrappers (`useCallback(fn, deps)`, `useMemo(() => fn, deps)`)
+  // return the wrapped function itself — calling the binding DOES run it.
+  if (
+    isNodeOfType(initializer, "CallExpression") &&
+    isNodeOfType(initializer.callee, "Identifier") &&
+    HOOK_NAME_PATTERN.test(initializer.callee.name)
+  ) {
+    return false;
+  }
+  const callbackArguments = (initializer.arguments ?? []).filter((argument) =>
+    isFunctionLike(argument as EsTreeNode),
+  );
+  if (callbackArguments.length === 0) return false;
+  let node: EsTreeNode | null | undefined = identifier;
+  while (node && node !== initializer) {
+    if ((callbackArguments as ReadonlyArray<unknown>).includes(node)) return true;
+    node = (node as unknown as { parent?: EsTreeNode | null }).parent;
+  }
+  return false;
+};
+
 const ascend = (
   analysis: ProgramAnalysis,
   ref: Reference,
@@ -40,6 +72,9 @@ const ascend = (
     const next = (defNode.init ?? defNode.body) as EsTreeNode | undefined;
     if (!next) continue;
     for (const innerRef of getDownstreamRefs(analysis, next)) {
+      if (isInsideCallbackArgumentOf(innerRef.identifier as unknown as EsTreeNode, next)) {
+        continue;
+      }
       ascend(analysis, innerRef, visit, visited);
     }
   }
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.regressions.test.ts
index 50f71ded25..21ec37b581 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.regressions.test.ts
@@ -58,4 +58,20 @@ describe("tanstack-query/query-mutation-missing-invalidation — regressions", (
     );
     expect(diagnostics.length).toBeGreaterThan(0);
   });
+
+  it("does not assert stale data as certain when invalidation happens at the mutate() call site", () => {
+    const { diagnostics } = runRule(
+      queryMutationMissingInvalidation,
+      `function SaveButton() {
+        const queryClient = useQueryClient();
+        const mutation = useMutation({ mutationFn: (data) => api.save(data) });
+        const onClick = () => mutation.mutate(payload, {
+          onSuccess: () => queryClient.invalidateQueries({ queryKey: ["items"] }),
+        });
+        return <button onClick={onClick}>Save</button>;
+      }`,
+    );
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].message).toContain("can leave");
+  });
 });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.ts
index 1bb1cf182d..e20371715c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.ts
@@ -115,7 +115,7 @@ export const queryMutationMissingInvalidation = defineRule({
         context.report({
           node,
           message:
-            "useMutation with no cache update leaves your users looking at stale data after it runs.",
+            "useMutation with no cache update here can leave your users looking at stale data after it runs.",
         });
       }
     },
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-non-deterministic-source.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-non-deterministic-source.ts
index 18995b3d97..1e4985816a 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-non-deterministic-source.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/contains-non-deterministic-source.ts
@@ -31,11 +31,23 @@ const NON_DETERMINISTIC_ID_GENERATOR_NAMES: ReadonlySet<string> = new Set([
 // setId(id)`) rather than being the direct setter argument — but never
 // descends into function expressions: a stored callback
 // (`setCallback(() => Date.now())`) is itself a deterministic value.
+// `new Date()` with no arguments captures the current instant, so it is as
+// non-deterministic as `Date.now()`; `new Date(value)` stays deterministic.
+const isZeroArgDateConstruction = (node: EsTreeNode): boolean =>
+  isNodeOfType(node, "NewExpression") &&
+  isNodeOfType(node.callee, "Identifier") &&
+  node.callee.name === "Date" &&
+  (node.arguments?.length ?? 0) === 0;
+
 export const containsNonDeterministicSource = (root: EsTreeNode): boolean => {
   let found = false;
   walkAst(root, (child: EsTreeNode): boolean | void => {
     if (found) return false;
     if (isFunctionLike(child)) return false;
+    if (isZeroArgDateConstruction(child)) {
+      found = true;
+      return false;
+    }
     if (!isNodeOfType(child, "CallExpression")) return;
     const callee = child.callee;
     if (
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/reads-post-mount-value.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/reads-post-mount-value.ts
index 5aaa312b7f..ac387e5ebd 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/reads-post-mount-value.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/reads-post-mount-value.ts
@@ -86,21 +86,72 @@ const resolvesToRefFactoryCall = (identifier: EsTreeNodeOfType<"Identifier">): b
   return found;
 };
 
-const isRefLikeReceiver = (receiver: EsTreeNode | null | undefined): boolean => {
+const unwrapExpression = (node: EsTreeNode | null | undefined): EsTreeNode | null => {
+  if (!node) return null;
+  if (isNodeOfType(node, "ChainExpression")) return unwrapExpression(node.expression as EsTreeNode);
+  if (isNodeOfType(node, "TSNonNullExpression")) {
+    return unwrapExpression(node.expression as EsTreeNode);
+  }
+  return node;
+};
+
+// `const el = contentRef.current` — a local alias of a ref's `.current`
+// carries the mounted element, so layout reads through the alias
+// (`el.scrollHeight`) are post-mount measurements too.
+const resolvesToRefCurrentAlias = (
+  identifier: EsTreeNodeOfType<"Identifier">,
+  visitedAliasNames: ReadonlySet<string>,
+): boolean => {
+  if (visitedAliasNames.has(identifier.name)) return false;
+  const root = findProgramRoot(identifier);
+  if (!root) return false;
+  const nextVisited = new Set([...visitedAliasNames, identifier.name]);
+  let found = false;
+  walkAst(root, (child: EsTreeNode): boolean | void => {
+    if (found) return false;
+    if (
+      isNodeOfType(child, "VariableDeclarator") &&
+      isNodeOfType(child.id, "Identifier") &&
+      child.id.name === identifier.name
+    ) {
+      const init = unwrapExpression(child.init as EsTreeNode | null);
+      if (
+        init &&
+        isNodeOfType(init, "MemberExpression") &&
+        isNodeOfType(init.property, "Identifier") &&
+        init.property.name === "current" &&
+        isRefLikeReceiver(init.object as EsTreeNode, nextVisited)
+      ) {
+        found = true;
+        return false;
+      }
+    }
+  });
+  return found;
+};
+
+const isRefLikeReceiver = (
+  receiver: EsTreeNode | null | undefined,
+  visitedAliasNames: ReadonlySet<string> = new Set(),
+): boolean => {
   if (!receiver) return false;
   if (isNodeOfType(receiver, "ChainExpression")) {
-    return isRefLikeReceiver(receiver.expression as EsTreeNode);
+    return isRefLikeReceiver(receiver.expression as EsTreeNode, visitedAliasNames);
   }
   if (isNodeOfType(receiver, "TSNonNullExpression")) {
-    return isRefLikeReceiver(receiver.expression as EsTreeNode);
+    return isRefLikeReceiver(receiver.expression as EsTreeNode, visitedAliasNames);
   }
   if (isNodeOfType(receiver, "Identifier")) {
-    return hasRefLikeName(receiver.name) || resolvesToRefFactoryCall(receiver);
+    return (
+      hasRefLikeName(receiver.name) ||
+      resolvesToRefFactoryCall(receiver) ||
+      resolvesToRefCurrentAlias(receiver, visitedAliasNames)
+    );
   }
   if (isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.property, "Identifier")) {
     if (hasRefLikeName(receiver.property.name)) return true;
     if (receiver.property.name === "current")
-      return isRefLikeReceiver(receiver.object as EsTreeNode);
+      return isRefLikeReceiver(receiver.object as EsTreeNode, visitedAliasNames);
   }
   return false;
 };

From 832534342135bd115c3ccb0cd99207850a43a643 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 3 Jul 2026 17:18:50 -0700
Subject: [PATCH 15/33] chore: version packages (#1031)

---
 .changeset/array-index-aliased-placeholder.md |   5 -
 .changeset/balanced-lpt-lint-batches.md       |   5 -
 .changeset/button-has-type-as-const.md        |   5 -
 .changeset/checked-requires-disabled-fp.md    |  10 --
 .changeset/differential-upstream-fp-fixes.md  |  26 ----
 .changeset/display-name-block-body-factory.md |   5 -
 .../exhaustive-deps-ref-current-chain.md      |  10 --
 .changeset/jsx-no-jsx-as-prop-slot-names.md   |  12 --
 .changeset/modern-corpus-fp-fixes.md          |  10 --
 ...o-array-index-as-key-composite-identity.md |   5 -
 .../no-derived-state-ref-current-alias.md     |   5 -
 .../no-direct-state-mutation-callback-ref.md  |   5 -
 .../no-initialize-state-cleanup-resource.md   |   5 -
 .changeset/no-initialize-state-new-date.md    |   5 -
 .../no-initialize-state-observer-callback.md  |   5 -
 ...o-reset-all-state-subscription-callback.md |   5 -
 .changeset/no-secrets-author-name-fp.md       |  10 --
 .../only-export-components-nested-scope-fp.md |  12 --
 .changeset/perf-closure-captures-memo.md      |   5 -
 .changeset/perf-compile-glob-cache.md         |   5 -
 .changeset/perf-get-element-type-memo.md      |   5 -
 .changeset/perf-render-output-walk-cache.md   |   5 -
 .changeset/perf-security-scan-line-index.md   |   5 -
 .changeset/perf-sweep-early-exit.md           |   5 -
 .changeset/perf-sweep-fused-walks.md          |   5 -
 .changeset/perf-sweep-memo.md                 |   5 -
 .changeset/perf-sweep-regex-hoist.md          |   5 -
 .changeset/perf-sweep-set-membership.md       |   5 -
 .../perf-tanstack-in-project-dir-hoist.md     |   5 -
 .../rn-no-raw-text-preview-whitespace.md      |   5 -
 .changeset/secscan-overlap-starvation.md      |   7 --
 .changeset/six-messages-stop-overclaiming.md  |   5 -
 packages/api/CHANGELOG.md                     |   7 ++
 packages/api/package.json                     |   2 +-
 packages/core/CHANGELOG.md                    |   8 ++
 packages/core/package.json                    |   2 +-
 packages/deslop-cli/CHANGELOG.md              |   7 ++
 packages/deslop-cli/package.json              |   2 +-
 packages/deslop-js/CHANGELOG.md               |   2 +
 packages/deslop-js/package.json               |   2 +-
 .../eslint-plugin-react-doctor/CHANGELOG.md   |   7 ++
 .../eslint-plugin-react-doctor/package.json   |   2 +-
 packages/fuzz/CHANGELOG.md                    |   7 ++
 packages/fuzz/package.json                    |   2 +-
 packages/language-server/CHANGELOG.md         |   7 ++
 packages/language-server/package.json         |   2 +-
 .../oxlint-plugin-react-doctor/CHANGELOG.md   | 119 ++++++++++++++++++
 .../oxlint-plugin-react-doctor/package.json   |   2 +-
 packages/react-doctor/CHANGELOG.md            |  14 +++
 packages/react-doctor/package.json            |   2 +-
 50 files changed, 187 insertions(+), 226 deletions(-)
 delete mode 100644 .changeset/array-index-aliased-placeholder.md
 delete mode 100644 .changeset/balanced-lpt-lint-batches.md
 delete mode 100644 .changeset/button-has-type-as-const.md
 delete mode 100644 .changeset/checked-requires-disabled-fp.md
 delete mode 100644 .changeset/differential-upstream-fp-fixes.md
 delete mode 100644 .changeset/display-name-block-body-factory.md
 delete mode 100644 .changeset/exhaustive-deps-ref-current-chain.md
 delete mode 100644 .changeset/jsx-no-jsx-as-prop-slot-names.md
 delete mode 100644 .changeset/modern-corpus-fp-fixes.md
 delete mode 100644 .changeset/no-array-index-as-key-composite-identity.md
 delete mode 100644 .changeset/no-derived-state-ref-current-alias.md
 delete mode 100644 .changeset/no-direct-state-mutation-callback-ref.md
 delete mode 100644 .changeset/no-initialize-state-cleanup-resource.md
 delete mode 100644 .changeset/no-initialize-state-new-date.md
 delete mode 100644 .changeset/no-initialize-state-observer-callback.md
 delete mode 100644 .changeset/no-reset-all-state-subscription-callback.md
 delete mode 100644 .changeset/no-secrets-author-name-fp.md
 delete mode 100644 .changeset/only-export-components-nested-scope-fp.md
 delete mode 100644 .changeset/perf-closure-captures-memo.md
 delete mode 100644 .changeset/perf-compile-glob-cache.md
 delete mode 100644 .changeset/perf-get-element-type-memo.md
 delete mode 100644 .changeset/perf-render-output-walk-cache.md
 delete mode 100644 .changeset/perf-security-scan-line-index.md
 delete mode 100644 .changeset/perf-sweep-early-exit.md
 delete mode 100644 .changeset/perf-sweep-fused-walks.md
 delete mode 100644 .changeset/perf-sweep-memo.md
 delete mode 100644 .changeset/perf-sweep-regex-hoist.md
 delete mode 100644 .changeset/perf-sweep-set-membership.md
 delete mode 100644 .changeset/perf-tanstack-in-project-dir-hoist.md
 delete mode 100644 .changeset/rn-no-raw-text-preview-whitespace.md
 delete mode 100644 .changeset/secscan-overlap-starvation.md
 delete mode 100644 .changeset/six-messages-stop-overclaiming.md

diff --git a/.changeset/array-index-aliased-placeholder.md b/.changeset/array-index-aliased-placeholder.md
deleted file mode 100644
index d008cb3264..0000000000
--- a/.changeset/array-index-aliased-placeholder.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-array-index-as-key: stop flagging index keys when the mapped receiver is a variable holding a static placeholder array (`const list = Array.from({ length: 3 }); list.map(...)`) — the binding is now resolved to its initializer, matching the existing inline `Array.from({ length: N })` exemption.
diff --git a/.changeset/balanced-lpt-lint-batches.md b/.changeset/balanced-lpt-lint-batches.md
deleted file mode 100644
index 00bbe399fe..0000000000
--- a/.changeset/balanced-lpt-lint-batches.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"react-doctor": patch
----
-
-Balance lint batches by file size (LPT) so one oversized batch no longer sets the whole scan's wall clock. The full-scan batcher greedily filled 100-file chunks in discovery order, so a directory of large files (generated modules, vendored bundles, big test fixtures — adjacent in `git ls-files` order) all landed in ONE batch: on a 619-file corpus with six ~240 KB files that straggler batch ran ~7.5 s while the other six workers finished in ~1 s and idled — and a big enough cluster can trip the 60 s per-batch timeout and drop files. The planner now keeps the same batch count (and therefore the same subprocess count and CPU) but assigns files largest-first to the least-loaded batch, so every batch carries an even share of files and bytes: 2.2× faster wall clock on the skewed corpus (9.7 s → 4.3 s), no measurable change on uniform repos, and diagnostics verified byte-identical on both. Splitting into MORE batches to feed idle workers was measured to regress (each extra concurrent subprocess pays a contended cold start that outweighs its smaller file share) and is deliberately not done. `REACT_DOCTOR_LINT_BATCH_ORDERING=arrival` rolls back to the old greedy chunking; the previous opt-in `cost` mode (sort-descending-then-chunk, which concentrated the heavy files instead of spreading them) is superseded by the balanced plan.
diff --git a/.changeset/button-has-type-as-const.md b/.changeset/button-has-type-as-const.md
deleted file mode 100644
index 1890454a8f..0000000000
--- a/.changeset/button-has-type-as-const.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-button-has-type: stop flagging `type` values wrapped in TS assertion expressions (`"submit" as const`, `satisfies`) — the wrapper is stripped before proving validity, so a local `const kind = "submit" as const` now resolves like the bare literal; invalid values under a wrapper stay flagged.
diff --git a/.changeset/checked-requires-disabled-fp.md b/.changeset/checked-requires-disabled-fp.md
deleted file mode 100644
index e3eadafc23..0000000000
--- a/.changeset/checked-requires-disabled-fp.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-fix(react-builtins): `checked-requires-onchange-or-readonly` no longer flags
-statically disabled checkboxes (`<input type="checkbox" checked={x} disabled />`).
-Users can't toggle a disabled input, so no `onChange` is needed — React's own
-controlled-checkbox runtime warning exempts `disabled` the same way. A dynamic
-`disabled={cond}` still reports, since the input can be enabled at runtime.
-Found by corpus census triage.
diff --git a/.changeset/differential-upstream-fp-fixes.md b/.changeset/differential-upstream-fp-fixes.md
deleted file mode 100644
index 336646e25f..0000000000
--- a/.changeset/differential-upstream-fp-fixes.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-fix: six false-positive classes found by differential testing against the
-upstream ESLint plugins over an OSS corpus:
-
-- `exhaustive-deps`: cleanup `ref.current` reads no longer warn when the ref
-  is assigned via a callback anywhere in the component, and an explicit
-  `undefined` deps argument is treated like an omitted one for effect hooks
-  (upstream parity; `null` still reports as a non-array deps list).
-- `no-static-element-interactions`: a string-literal role wrapped in a JSX
-  expression container (`role={'link'}`) now counts as a role, and `<svg>`
-  is skipped — it has the implicit `graphics-document` role, so it isn't
-  static (upstream parity).
-- `no-aria-hidden-on-focusable`: dynamic `aria-hidden` expressions
-  (`aria-hidden={!interactive || undefined}`) are no longer treated as
-  literal `true`.
-- `img-redundant-alt`: hyphens and underscores are word-continuation
-  characters, so `alt="image-left-top"` and `alt="my_image_1"` no longer
-  match the redundant word "image".
-- `no-noninteractive-tabindex`: the roving-tabindex pattern
-  (`tabIndex={active ? 0 : -1}`) is no longer flagged.
-- `rules-of-hooks`: hooks in anonymous callbacks with no resolved name are
-  skipped (upstream's conservative approach), and a hook call in a ternary
-  test position is no longer treated as conditional.
diff --git a/.changeset/display-name-block-body-factory.md b/.changeset/display-name-block-body-factory.md
deleted file mode 100644
index 1d23e4fde1..0000000000
--- a/.changeset/display-name-block-body-factory.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-display-name: a curried component factory now reports consistently whether the outer arrow uses an expression body (`(order) => (props) => <X />`) or a block body with an explicit return — the block-body shape was silently skipped (found by the metamorphic arrow-body fuzz oracle).
diff --git a/.changeset/exhaustive-deps-ref-current-chain.md b/.changeset/exhaustive-deps-ref-current-chain.md
deleted file mode 100644
index 70740f9d9a..0000000000
--- a/.changeset/exhaustive-deps-ref-current-chain.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-fix(react-builtins): `exhaustive-deps` now truncates captured member chains at
-`.current` (e.g. `textareaRef.current.style.height` → `textareaRef`), matching
-upstream eslint-plugin-react-hooks. Previously an effect reading a prop-passed
-ref reported mutable `.current` paths as "stale" dependencies and effectively
-told users to add `ref.current.*` values to the deps array, which is never
-valid. Found by corpus census triage.
diff --git a/.changeset/jsx-no-jsx-as-prop-slot-names.md b/.changeset/jsx-no-jsx-as-prop-slot-names.md
deleted file mode 100644
index dae1db2ee5..0000000000
--- a/.changeset/jsx-no-jsx-as-prop-slot-names.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-fix(react-builtins): `jsx-no-jsx-as-prop` recognises more conventional JSX
-slot props mined from the real-world corpus — the `*Avatar`, `*Text`,
-`*State`, and `*Zone` suffixes (material-ui `ListItem
-leftAvatar`/`primaryText`, supabase `ChartContent loadingState`, leemons
-`leftZone`/`rightZone`), the `config` slot, and capitalised exact forms of
-known slot names (`Footer={<PageFooter />}`). Inline JSX in these slots is the
-component's designed API, so flagging it was unactionable noise. Found by the
-fuzz FP oracle.
diff --git a/.changeset/modern-corpus-fp-fixes.md b/.changeset/modern-corpus-fp-fixes.md
deleted file mode 100644
index ca1f06788b..0000000000
--- a/.changeset/modern-corpus-fp-fixes.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-Fix false positives found on a fresh React 19 / RSC / Next.js 15 corpus:
-
-- `server-sequential-independent-await` no longer flags awaits of Next.js request-scoped APIs (`headers()`, `cookies()`, `draftMode()`, `connection()`, next-intl server helpers) or awaits of already-existing promises such as Next.js 15 `props.params` / `props.searchParams`.
-- `server-fetch-without-revalidate` no longer flags the documented `next/og` static-asset fetch (`fetch(new URL(..., import.meta.url))`) or Remix / React Router `app/` route files, where the Next.js data cache never applies.
-- `rendering-hydration-mismatch-time` no longer flags time/random values in JSX rasterized by `ImageResponse` / satori (og images never hydrate).
-- `nextjs-missing-metadata` no longer flags `"use client"` pages, which cannot export `metadata` / `generateMetadata`.
diff --git a/.changeset/no-array-index-as-key-composite-identity.md b/.changeset/no-array-index-as-key-composite-identity.md
deleted file mode 100644
index 1ee95e1fd5..0000000000
--- a/.changeset/no-array-index-as-key-composite-identity.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-array-index-as-key: recognize composite keys whose per-item identity comes from a destructured callback field (`({ message }, index) => key={`${message} ${index}`}`) or a method call on the item (`key={`${index}-${color.toHexString()}`}`) — the index is just a uniqueness fallback there; composite keys with no item-derived part stay flagged. Also extend the static-placeholder exemption to `Array.from({length: values.length}, …)` and to numeric `for (let i = 0; …)` loop counters — both imperative twins of the already-exempt `Array(N)` placeholder; a manually incremented index over real items stays flagged.
diff --git a/.changeset/no-derived-state-ref-current-alias.md b/.changeset/no-derived-state-ref-current-alias.md
deleted file mode 100644
index 5f6b6b389f..0000000000
--- a/.changeset/no-derived-state-ref-current-alias.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-derived-state (and the shared post-mount-read detector): recognize layout measurements read through a local alias of a ref's `.current` (`const el = contentRef.current; setX(el.scrollHeight > max)`) as deferred DOM measurements, not derived state.
diff --git a/.changeset/no-direct-state-mutation-callback-ref.md b/.changeset/no-direct-state-mutation-callback-ref.md
deleted file mode 100644
index 703a304593..0000000000
--- a/.changeset/no-direct-state-mutation-callback-ref.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-direct-state-mutation: stop flagging in-place writes to a callback-ref target. When a `useState` setter is passed straight to a JSX `ref` attribute (`ref={setNode}`), the paired state holds a DOM element / component instance, so `node.dataset.x = ...` or `node.style.x = ...` is deliberate imperative DOM work, not a lost state update. The wangeditor `useState(null)` + effect-mutation bug (whose ref comes from a separate `useRef`) stays flagged.
diff --git a/.changeset/no-initialize-state-cleanup-resource.md b/.changeset/no-initialize-state-cleanup-resource.md
deleted file mode 100644
index d973bf5d10..0000000000
--- a/.changeset/no-initialize-state-cleanup-resource.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-initialize-state: stop flagging mount effects that seed state from a resource their cleanup disposes. When the setter argument derives from an effect-local binding referenced by the returned cleanup (`const audioContext = new AudioContext(); setGainNode(audioContext.createGain()); return () => audioContext.close();` — same shape for WebSockets, editors, observers), the effect owns a resource lifecycle and the value cannot be hoisted into `useState(initial)` because render has no matching dispose slot. Deterministic inits beside an unrelated cleanup (`setCount(42)` next to a `clearInterval` cleanup) keep firing.
diff --git a/.changeset/no-initialize-state-new-date.md b/.changeset/no-initialize-state-new-date.md
deleted file mode 100644
index 13252e0952..0000000000
--- a/.changeset/no-initialize-state-new-date.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-initialize-state: stop flagging mount effects that seed state from a zero-arg `new Date()` (e.g. an SSR-safe live clock's `setNow(new Date().toLocaleTimeString())`) — it captures the current instant like `Date.now()`, which was already exempt; `new Date(value)` stays flagged.
diff --git a/.changeset/no-initialize-state-observer-callback.md b/.changeset/no-initialize-state-observer-callback.md
deleted file mode 100644
index ac2cb82e73..0000000000
--- a/.changeset/no-initialize-state-observer-callback.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-initialize-state: stop flagging setters that only fire from a callback argument of an effect-local instance (`const observer = new MutationObserver((m) => setEntryCount(m.length)); observer.observe(...)`). The eventual-call resolver treated a callback passed to a constructor or factory as the binding's own call graph, so a method call on the instance counted as a synchronous setter call. Function-expression arguments of a binding's initializer call are now excluded from the resolver (hook wrappers like `useCallback(fn, deps)` still count, since calling the binding runs the wrapped function). Bare identifier arguments (`debounce(setN)`) are unaffected.
diff --git a/.changeset/no-reset-all-state-subscription-callback.md b/.changeset/no-reset-all-state-subscription-callback.md
deleted file mode 100644
index 286302bd04..0000000000
--- a/.changeset/no-reset-all-state-subscription-callback.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-no-reset-all-state-on-prop-change: stop flagging effects whose state setters only run inside listener / observer / subscription callbacks — those reset on the external event, not on the prop change.
diff --git a/.changeset/no-secrets-author-name-fp.md b/.changeset/no-secrets-author-name-fp.md
deleted file mode 100644
index 46936cdf2c..0000000000
--- a/.changeset/no-secrets-author-name-fp.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-fix(security): `no-secrets-in-client-code`'s variable-name heuristic no longer
-matches `auth` inside `author`/`authors`/`authority` — a component identifier
-like `TOP_PR_AUTHORS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER = "<uuid>"` is not a
-credential. The credential words that contain "author"
-(`authorization`, `authorised`) still match. Found by the fuzz FP oracle over
-the real-world corpus.
diff --git a/.changeset/only-export-components-nested-scope-fp.md b/.changeset/only-export-components-nested-scope-fp.md
deleted file mode 100644
index f94ca05aa8..0000000000
--- a/.changeset/only-export-components-nested-scope-fp.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-fix(react-builtins): `only-export-components` no longer flags components
-declared inside another function — a test callback (`test("x", () => { const
-Harness = () => ... })`), a factory (`function setup() { const Row = () =>
-... }`), or an object-literal `render` method. Those are never Fast Refresh
-boundaries, so the "not exported" / "file exports nothing" messages told
-users to export values that can't be exported. The local-component walk now
-stays at module scope, matching the origin rule in
-eslint-plugin-react-refresh. Found by the fuzz FP oracle.
diff --git a/.changeset/perf-closure-captures-memo.md b/.changeset/perf-closure-captures-memo.md
deleted file mode 100644
index e77766ae83..0000000000
--- a/.changeset/perf-closure-captures-memo.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: memoize `closureCaptures` per (ScopeAnalysis, function node) so nested callbacks compute once and every calling rule reuses the result, and drop the redundant per-reference containment re-filter
diff --git a/.changeset/perf-compile-glob-cache.md b/.changeset/perf-compile-glob-cache.md
deleted file mode 100644
index c4c412024b..0000000000
--- a/.changeset/perf-compile-glob-cache.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: cache compiled glob RegExps in `compileGlob` so rules matching user-configured patterns per node stop recompiling the same pattern on every call
diff --git a/.changeset/perf-get-element-type-memo.md b/.changeset/perf-get-element-type-memo.md
deleted file mode 100644
index 1029d29c3c..0000000000
--- a/.changeset/perf-get-element-type-memo.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: memoize getElementType per JSX opening element (with a settings-identity guard) so the ~30 a11y rules resolve each element once instead of once per rule
diff --git a/.changeset/perf-render-output-walk-cache.md b/.changeset/perf-render-output-walk-cache.md
deleted file mode 100644
index ab0dead7ce..0000000000
--- a/.changeset/perf-render-output-walk-cache.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: memoize `functionContainsReactRenderOutput` per function node so the ~5 rules sharing it walk each function subtree once per file instead of once per query
diff --git a/.changeset/perf-security-scan-line-index.md b/.changeset/perf-security-scan-line-index.md
deleted file mode 100644
index a8e5975688..0000000000
--- a/.changeset/perf-security-scan-line-index.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: replace the security scan's per-match O(content) slice+split in `getLocationAtIndex` with a memoized per-content line-start index answered by binary search
diff --git a/.changeset/perf-sweep-early-exit.md b/.changeset/perf-sweep-early-exit.md
deleted file mode 100644
index c2cbc5c016..0000000000
--- a/.changeset/perf-sweep-early-exit.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: early-exit sweep — cheap discriminators now run before walks, scope lookups, and parent climbs across ~23 rules (raw-name bails before getElementType, whole-file import gates for the zod and recycler-list rules, substring gates before regex-heavy className analysis, filename gates hoisted to Program, and first-match pruning in containsFetchCall)
diff --git a/.changeset/perf-sweep-fused-walks.md b/.changeset/perf-sweep-fused-walks.md
deleted file mode 100644
index 6f6f15d742..0000000000
--- a/.changeset/perf-sweep-fused-walks.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: fused-walk sweep — ~13 repeated subtree traversals collapse into single passes or per-node memos (async-await-in-loop's triple walk and fixpoint pre-pass, js-cache/js-index-maps loop walks, rendering-usetransition's three detectors, display-name's per-candidate program scans, per-binding setter walks in the state/effect rules, and WeakMap memos for prop-name/bound-name/effect-count analyses)
diff --git a/.changeset/perf-sweep-memo.md b/.changeset/perf-sweep-memo.md
deleted file mode 100644
index 3b54756355..0000000000
--- a/.changeset/perf-sweep-memo.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: memoization sweep — per-file/per-Program analyses stop recomputing per node and per rule (security-scan path classification cached per pattern+path, layout export scans cached per file with mtime invalidation, effect scope/reference/upstream-ref lookups memoized per analysis, the duplicated outer-scope scan converged onto getScopeForNode, zod import classification memoized per identifier, and normalizeFilename skips the no-op allocation)
diff --git a/.changeset/perf-sweep-regex-hoist.md b/.changeset/perf-sweep-regex-hoist.md
deleted file mode 100644
index 66e4e0c45b..0000000000
--- a/.changeset/perf-sweep-regex-hoist.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: regex-hoist sweep — ~8 per-call RegExp constructions move to module scope or behind cheap gates (public-env secret-name global pattern hoisted, supabase RLS enables collected in one pass instead of per-table compile+slice, dangerous-html-sink inert-target and serializer exemptions gated/lazy, design color/duration parsers get first-char and substring discriminators)
diff --git a/.changeset/perf-sweep-set-membership.md b/.changeset/perf-sweep-set-membership.md
deleted file mode 100644
index ac7a73aeb9..0000000000
--- a/.changeset/perf-sweep-set-membership.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf: set-membership sweep — ~13 linear array scans on per-element hot paths now use Sets/Maps (ARIA element-role tables become O(1) lookup maps, event-handler presence checks collapse to one lowercased-Set pass per element, a11y settings lists and tanstack order tables convert to Sets/index Maps)
diff --git a/.changeset/perf-tanstack-in-project-dir-hoist.md b/.changeset/perf-tanstack-in-project-dir-hoist.md
deleted file mode 100644
index dd83c1ab12..0000000000
--- a/.changeset/perf-tanstack-in-project-dir-hoist.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-perf(rules): hoist per-file directory classification out of per-node visitors — the TanStack Start and Next.js rules that called `isInProjectDirectory` (or tested the root-route filename pattern) on every JSX element / call expression now compute it once in `create()` and skip non-matching files entirely
diff --git a/.changeset/rn-no-raw-text-preview-whitespace.md b/.changeset/rn-no-raw-text-preview-whitespace.md
deleted file mode 100644
index 43bb6fed65..0000000000
--- a/.changeset/rn-no-raw-text-preview-whitespace.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-rn-no-raw-text: collapse internal whitespace in the quoted raw-text preview so multi-line JSX text produces a single-line message and CRLF vs LF sources report identically (found by the new metamorphic CRLF fuzz oracle).
diff --git a/.changeset/secscan-overlap-starvation.md b/.changeset/secscan-overlap-starvation.md
deleted file mode 100644
index 6561396d04..0000000000
--- a/.changeset/secscan-overlap-starvation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"react-doctor": patch
----
-
-Stop lint's pre-spawn setup from starving the overlapped security-scan and supply-chain passes.
-
-The security scan already runs on a cooperative background fiber that overlaps the lint pass, but a forked fiber only advances when the main thread yields — and lint's synchronous pre-spawn prefix (full-scan file discovery plus the per-file cache's content-hash partition over every candidate file) held the event loop until the first oxlint subprocess spawned. The overlapped passes now start immediately: the lint runner hands the loop back once before discovery and yields on the shared cooperative time budget while hashing, and the security scan's own directory walk (previously one unyielding readdir+classify burst before its first budget checkpoint) yields walk-progress markers so large trees can't stall lint subprocess draining or concurrently-scanning sibling projects. Diagnostics are byte-identical and the report order is unchanged.
diff --git a/.changeset/six-messages-stop-overclaiming.md b/.changeset/six-messages-stop-overclaiming.md
deleted file mode 100644
index 650f6b8883..0000000000
--- a/.changeset/six-messages-stop-overclaiming.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"oxlint-plugin-react-doctor": patch
----
-
-Reword six diagnostic messages that asserted concrete runtime harm on trigger shapes where the harm does not occur: no-render-in-render (plain render-helper calls do not remount or lose state), no-direct-state-mutation (a setter call after the mutation still redraws), no-direct-mutation-state (setState after the mutation still redraws), server-no-mutable-module-state (a never-written module `let` leaks nothing), query-mutation-missing-invalidation (invalidation can happen at the mutate() call site), and rn-no-dimensions-get (a Dimensions.get() read inside an event handler is fresh, not stale).
diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md
index c6a5c82352..f35474c083 100644
--- a/packages/api/CHANGELOG.md
+++ b/packages/api/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/api
 
+## 0.6.3
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @react-doctor/core@0.6.3
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/api/package.json b/packages/api/package.json
index b3117d1b4a..efe9e81adb 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/api",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "private": true,
   "description": "Programmatic API for React Doctor.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index 28b8aadafe..ad718b2b78 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @react-doctor/core
 
+## 0.6.3
+
+### Patch Changes
+
+- Updated dependencies [[`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`072d37e`](https://github.com/millionco/react-doctor/commit/072d37e8e4f82454d2e187114d0194f26efc1bf0), [`2980d0f`](https://github.com/millionco/react-doctor/commit/2980d0f4ed6abfee061ac02f3a0820806f942b95), [`5fec491`](https://github.com/millionco/react-doctor/commit/5fec491e6844d73f658f355ae2cbe86285068f0e), [`05f6399`](https://github.com/millionco/react-doctor/commit/05f639910abf2b3bfc0802e9ad568ecd2b7ce13d), [`a1c8ee1`](https://github.com/millionco/react-doctor/commit/a1c8ee110e137bbc8771c8a471c20287cccd2b38), [`fa61c20`](https://github.com/millionco/react-doctor/commit/fa61c2056951df2429e79d888e5f7334aaf61cfd), [`ac71a3b`](https://github.com/millionco/react-doctor/commit/ac71a3b8cfc8bdd157f0f1bcd242b61ec69f9c17), [`d8628d7`](https://github.com/millionco/react-doctor/commit/d8628d7f21e60b0e6dfd98d76c9f24e03f7afe24), [`ebeee56`](https://github.com/millionco/react-doctor/commit/ebeee568abf9a7ed37ed9fe0bba695e4f2a11c9f), [`da3b19c`](https://github.com/millionco/react-doctor/commit/da3b19c79c27945d873eb24e34431cbefa8f9938), [`6a9a73b`](https://github.com/millionco/react-doctor/commit/6a9a73b14908272535aabab6742258b61bc2ee5c), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b)]:
+  - oxlint-plugin-react-doctor@0.6.3
+  - deslop-js@0.6.3
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/core/package.json b/packages/core/package.json
index 5374f9c866..48fd9b7bf8 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/core",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "private": true,
   "description": "Diagnostic engine for React Doctor.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/deslop-cli/CHANGELOG.md b/packages/deslop-cli/CHANGELOG.md
index 71fd3d3cd5..090aedcb65 100644
--- a/packages/deslop-cli/CHANGELOG.md
+++ b/packages/deslop-cli/CHANGELOG.md
@@ -1,5 +1,12 @@
 # deslop-cli
 
+## 0.6.3
+
+### Patch Changes
+
+- Updated dependencies []:
+  - deslop-js@0.6.3
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/deslop-cli/package.json b/packages/deslop-cli/package.json
index 18eef2fe8d..87496cb5b1 100644
--- a/packages/deslop-cli/package.json
+++ b/packages/deslop-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deslop-cli",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "CLI to remove AI slop from JavaScript codebases.",
   "keywords": [
     "cli",
diff --git a/packages/deslop-js/CHANGELOG.md b/packages/deslop-js/CHANGELOG.md
index 7ca218bd73..ee3b53c6fd 100644
--- a/packages/deslop-js/CHANGELOG.md
+++ b/packages/deslop-js/CHANGELOG.md
@@ -1,5 +1,7 @@
 # deslop-js
 
+## 0.6.3
+
 ## 0.6.2
 
 ## 0.6.1
diff --git a/packages/deslop-js/package.json b/packages/deslop-js/package.json
index 18fe0484ae..58f6dfacc5 100644
--- a/packages/deslop-js/package.json
+++ b/packages/deslop-js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deslop-js",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Remove AI slop from JavaScript code.",
   "keywords": [
     "dead-code",
diff --git a/packages/eslint-plugin-react-doctor/CHANGELOG.md b/packages/eslint-plugin-react-doctor/CHANGELOG.md
index 1d82e7d1f6..79f7efc811 100644
--- a/packages/eslint-plugin-react-doctor/CHANGELOG.md
+++ b/packages/eslint-plugin-react-doctor/CHANGELOG.md
@@ -1,5 +1,12 @@
 # eslint-plugin-react-doctor
 
+## 0.6.3
+
+### Patch Changes
+
+- Updated dependencies [[`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`072d37e`](https://github.com/millionco/react-doctor/commit/072d37e8e4f82454d2e187114d0194f26efc1bf0), [`2980d0f`](https://github.com/millionco/react-doctor/commit/2980d0f4ed6abfee061ac02f3a0820806f942b95), [`5fec491`](https://github.com/millionco/react-doctor/commit/5fec491e6844d73f658f355ae2cbe86285068f0e), [`05f6399`](https://github.com/millionco/react-doctor/commit/05f639910abf2b3bfc0802e9ad568ecd2b7ce13d), [`a1c8ee1`](https://github.com/millionco/react-doctor/commit/a1c8ee110e137bbc8771c8a471c20287cccd2b38), [`fa61c20`](https://github.com/millionco/react-doctor/commit/fa61c2056951df2429e79d888e5f7334aaf61cfd), [`ac71a3b`](https://github.com/millionco/react-doctor/commit/ac71a3b8cfc8bdd157f0f1bcd242b61ec69f9c17), [`d8628d7`](https://github.com/millionco/react-doctor/commit/d8628d7f21e60b0e6dfd98d76c9f24e03f7afe24), [`ebeee56`](https://github.com/millionco/react-doctor/commit/ebeee568abf9a7ed37ed9fe0bba695e4f2a11c9f), [`da3b19c`](https://github.com/millionco/react-doctor/commit/da3b19c79c27945d873eb24e34431cbefa8f9938), [`6a9a73b`](https://github.com/millionco/react-doctor/commit/6a9a73b14908272535aabab6742258b61bc2ee5c), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b)]:
+  - oxlint-plugin-react-doctor@0.6.3
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/eslint-plugin-react-doctor/package.json b/packages/eslint-plugin-react-doctor/package.json
index 9a56892783..b3a3df3ade 100644
--- a/packages/eslint-plugin-react-doctor/package.json
+++ b/packages/eslint-plugin-react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-doctor",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "React Doctor rules for ESLint.",
   "keywords": [
     "accessibility",
diff --git a/packages/fuzz/CHANGELOG.md b/packages/fuzz/CHANGELOG.md
index e947c7d3a2..aaadb05190 100644
--- a/packages/fuzz/CHANGELOG.md
+++ b/packages/fuzz/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/fuzz
 
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [[`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`072d37e`](https://github.com/millionco/react-doctor/commit/072d37e8e4f82454d2e187114d0194f26efc1bf0), [`2980d0f`](https://github.com/millionco/react-doctor/commit/2980d0f4ed6abfee061ac02f3a0820806f942b95), [`5fec491`](https://github.com/millionco/react-doctor/commit/5fec491e6844d73f658f355ae2cbe86285068f0e), [`05f6399`](https://github.com/millionco/react-doctor/commit/05f639910abf2b3bfc0802e9ad568ecd2b7ce13d), [`a1c8ee1`](https://github.com/millionco/react-doctor/commit/a1c8ee110e137bbc8771c8a471c20287cccd2b38), [`fa61c20`](https://github.com/millionco/react-doctor/commit/fa61c2056951df2429e79d888e5f7334aaf61cfd), [`ac71a3b`](https://github.com/millionco/react-doctor/commit/ac71a3b8cfc8bdd157f0f1bcd242b61ec69f9c17), [`d8628d7`](https://github.com/millionco/react-doctor/commit/d8628d7f21e60b0e6dfd98d76c9f24e03f7afe24), [`ebeee56`](https://github.com/millionco/react-doctor/commit/ebeee568abf9a7ed37ed9fe0bba695e4f2a11c9f), [`da3b19c`](https://github.com/millionco/react-doctor/commit/da3b19c79c27945d873eb24e34431cbefa8f9938), [`6a9a73b`](https://github.com/millionco/react-doctor/commit/6a9a73b14908272535aabab6742258b61bc2ee5c), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b)]:
+  - oxlint-plugin-react-doctor@0.6.3
+
 ## 0.0.2
 
 ### Patch Changes
diff --git a/packages/fuzz/package.json b/packages/fuzz/package.json
index cceb57c340..e3a75799e9 100644
--- a/packages/fuzz/package.json
+++ b/packages/fuzz/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/fuzz",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "private": true,
   "description": "Adversarial fuzzing harness for React Doctor rules.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/language-server/CHANGELOG.md b/packages/language-server/CHANGELOG.md
index 21b0896b81..e457efd3fb 100644
--- a/packages/language-server/CHANGELOG.md
+++ b/packages/language-server/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/language-server
 
+## 0.6.3
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @react-doctor/core@0.6.3
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/language-server/package.json b/packages/language-server/package.json
index f7128f7218..3161b515ab 100644
--- a/packages/language-server/package.json
+++ b/packages/language-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/language-server",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "private": true,
   "description": "Language server for React Doctor editor integrations.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/oxlint-plugin-react-doctor/CHANGELOG.md b/packages/oxlint-plugin-react-doctor/CHANGELOG.md
index 5336219e19..9e2adc9b19 100644
--- a/packages/oxlint-plugin-react-doctor/CHANGELOG.md
+++ b/packages/oxlint-plugin-react-doctor/CHANGELOG.md
@@ -1,5 +1,124 @@
 # oxlint-plugin-react-doctor
 
+## 0.6.3
+
+### Patch Changes
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-array-index-as-key: stop flagging index keys when the mapped receiver is a variable holding a static placeholder array (`const list = Array.from({ length: 3 }); list.map(...)`) — the binding is now resolved to its initializer, matching the existing inline `Array.from({ length: N })` exemption.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - button-has-type: stop flagging `type` values wrapped in TS assertion expressions (`"submit" as const`, `satisfies`) — the wrapper is stripped before proving validity, so a local `const kind = "submit" as const` now resolves like the bare literal; invalid values under a wrapper stay flagged.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - fix(react-builtins): `checked-requires-onchange-or-readonly` no longer flags
+  statically disabled checkboxes (`<input type="checkbox" checked={x} disabled />`).
+  Users can't toggle a disabled input, so no `onChange` is needed — React's own
+  controlled-checkbox runtime warning exempts `disabled` the same way. A dynamic
+  `disabled={cond}` still reports, since the input can be enabled at runtime.
+  Found by corpus census triage.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - fix: six false-positive classes found by differential testing against the
+  upstream ESLint plugins over an OSS corpus:
+
+  - `exhaustive-deps`: cleanup `ref.current` reads no longer warn when the ref
+    is assigned via a callback anywhere in the component, and an explicit
+    `undefined` deps argument is treated like an omitted one for effect hooks
+    (upstream parity; `null` still reports as a non-array deps list).
+  - `no-static-element-interactions`: a string-literal role wrapped in a JSX
+    expression container (`role={'link'}`) now counts as a role, and `<svg>`
+    is skipped — it has the implicit `graphics-document` role, so it isn't
+    static (upstream parity).
+  - `no-aria-hidden-on-focusable`: dynamic `aria-hidden` expressions
+    (`aria-hidden={!interactive || undefined}`) are no longer treated as
+    literal `true`.
+  - `img-redundant-alt`: hyphens and underscores are word-continuation
+    characters, so `alt="image-left-top"` and `alt="my_image_1"` no longer
+    match the redundant word "image".
+  - `no-noninteractive-tabindex`: the roving-tabindex pattern
+    (`tabIndex={active ? 0 : -1}`) is no longer flagged.
+  - `rules-of-hooks`: hooks in anonymous callbacks with no resolved name are
+    skipped (upstream's conservative approach), and a hook call in a ternary
+    test position is no longer treated as conditional.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - display-name: a curried component factory now reports consistently whether the outer arrow uses an expression body (`(order) => (props) => <X />`) or a block body with an explicit return — the block-body shape was silently skipped (found by the metamorphic arrow-body fuzz oracle).
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - fix(react-builtins): `exhaustive-deps` now truncates captured member chains at
+  `.current` (e.g. `textareaRef.current.style.height` → `textareaRef`), matching
+  upstream eslint-plugin-react-hooks. Previously an effect reading a prop-passed
+  ref reported mutable `.current` paths as "stale" dependencies and effectively
+  told users to add `ref.current.*` values to the deps array, which is never
+  valid. Found by corpus census triage.
+
+- [#1030](https://github.com/millionco/react-doctor/pull/1030) [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566) Thanks [@aidenybai](https://github.com/aidenybai)! - fix(react-builtins): `jsx-no-jsx-as-prop` recognises more conventional JSX
+  slot props mined from the real-world corpus — the `*Avatar`, `*Text`,
+  `*State`, and `*Zone` suffixes (material-ui `ListItem
+leftAvatar`/`primaryText`, supabase `ChartContent loadingState`, leemons
+  `leftZone`/`rightZone`), the `config` slot, and capitalised exact forms of
+  known slot names (`Footer={<PageFooter />}`). Inline JSX in these slots is the
+  component's designed API, so flagging it was unactionable noise. Found by the
+  fuzz FP oracle.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - Fix false positives found on a fresh React 19 / RSC / Next.js 15 corpus:
+
+  - `server-sequential-independent-await` no longer flags awaits of Next.js request-scoped APIs (`headers()`, `cookies()`, `draftMode()`, `connection()`, next-intl server helpers) or awaits of already-existing promises such as Next.js 15 `props.params` / `props.searchParams`.
+  - `server-fetch-without-revalidate` no longer flags the documented `next/og` static-asset fetch (`fetch(new URL(..., import.meta.url))`) or Remix / React Router `app/` route files, where the Next.js data cache never applies.
+  - `rendering-hydration-mismatch-time` no longer flags time/random values in JSX rasterized by `ImageResponse` / satori (og images never hydrate).
+  - `nextjs-missing-metadata` no longer flags `"use client"` pages, which cannot export `metadata` / `generateMetadata`.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-array-index-as-key: recognize composite keys whose per-item identity comes from a destructured callback field (`({ message }, index) => key={`${message} ${index}`}`) or a method call on the item (`key={`${index}-${color.toHexString()}`}`) — the index is just a uniqueness fallback there; composite keys with no item-derived part stay flagged. Also extend the static-placeholder exemption to `Array.from({length: values.length}, …)` and to numeric `for (let i = 0; …)` loop counters — both imperative twins of the already-exempt `Array(N)` placeholder; a manually incremented index over real items stays flagged.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-derived-state (and the shared post-mount-read detector): recognize layout measurements read through a local alias of a ref's `.current` (`const el = contentRef.current; setX(el.scrollHeight > max)`) as deferred DOM measurements, not derived state.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-direct-state-mutation: stop flagging in-place writes to a callback-ref target. When a `useState` setter is passed straight to a JSX `ref` attribute (`ref={setNode}`), the paired state holds a DOM element / component instance, so `node.dataset.x = ...` or `node.style.x = ...` is deliberate imperative DOM work, not a lost state update. The wangeditor `useState(null)` + effect-mutation bug (whose ref comes from a separate `useRef`) stays flagged.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-initialize-state: stop flagging mount effects that seed state from a resource their cleanup disposes. When the setter argument derives from an effect-local binding referenced by the returned cleanup (`const audioContext = new AudioContext(); setGainNode(audioContext.createGain()); return () => audioContext.close();` — same shape for WebSockets, editors, observers), the effect owns a resource lifecycle and the value cannot be hoisted into `useState(initial)` because render has no matching dispose slot. Deterministic inits beside an unrelated cleanup (`setCount(42)` next to a `clearInterval` cleanup) keep firing.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-initialize-state: stop flagging mount effects that seed state from a zero-arg `new Date()` (e.g. an SSR-safe live clock's `setNow(new Date().toLocaleTimeString())`) — it captures the current instant like `Date.now()`, which was already exempt; `new Date(value)` stays flagged.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-initialize-state: stop flagging setters that only fire from a callback argument of an effect-local instance (`const observer = new MutationObserver((m) => setEntryCount(m.length)); observer.observe(...)`). The eventual-call resolver treated a callback passed to a constructor or factory as the binding's own call graph, so a method call on the instance counted as a synchronous setter call. Function-expression arguments of a binding's initializer call are now excluded from the resolver (hook wrappers like `useCallback(fn, deps)` still count, since calling the binding runs the wrapped function). Bare identifier arguments (`debounce(setN)`) are unaffected.
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - no-reset-all-state-on-prop-change: stop flagging effects whose state setters only run inside listener / observer / subscription callbacks — those reset on the external event, not on the prop change.
+
+- [#1030](https://github.com/millionco/react-doctor/pull/1030) [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566) Thanks [@aidenybai](https://github.com/aidenybai)! - fix(security): `no-secrets-in-client-code`'s variable-name heuristic no longer
+  matches `auth` inside `author`/`authors`/`authority` — a component identifier
+  like `TOP_PR_AUTHORS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER = "<uuid>"` is not a
+  credential. The credential words that contain "author"
+  (`authorization`, `authorised`) still match. Found by the fuzz FP oracle over
+  the real-world corpus.
+
+- [#1030](https://github.com/millionco/react-doctor/pull/1030) [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566) Thanks [@aidenybai](https://github.com/aidenybai)! - fix(react-builtins): `only-export-components` no longer flags components
+  declared inside another function — a test callback (`test("x", () => { const
+Harness = () => ... })`), a factory (`function setup() { const Row = () =>
+... }`), or an object-literal `render` method. Those are never Fast Refresh
+  boundaries, so the "not exported" / "file exports nothing" messages told
+  users to export values that can't be exported. The local-component walk now
+  stays at module scope, matching the origin rule in
+  eslint-plugin-react-refresh. Found by the fuzz FP oracle.
+
+- [#1039](https://github.com/millionco/react-doctor/pull/1039) [`072d37e`](https://github.com/millionco/react-doctor/commit/072d37e8e4f82454d2e187114d0194f26efc1bf0) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: memoize `closureCaptures` per (ScopeAnalysis, function node) so nested callbacks compute once and every calling rule reuses the result, and drop the redundant per-reference containment re-filter
+
+- [#1044](https://github.com/millionco/react-doctor/pull/1044) [`2980d0f`](https://github.com/millionco/react-doctor/commit/2980d0f4ed6abfee061ac02f3a0820806f942b95) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: cache compiled glob RegExps in `compileGlob` so rules matching user-configured patterns per node stop recompiling the same pattern on every call
+
+- [#1041](https://github.com/millionco/react-doctor/pull/1041) [`5fec491`](https://github.com/millionco/react-doctor/commit/5fec491e6844d73f658f355ae2cbe86285068f0e) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: memoize getElementType per JSX opening element (with a settings-identity guard) so the ~30 a11y rules resolve each element once instead of once per rule
+
+- [#1042](https://github.com/millionco/react-doctor/pull/1042) [`05f6399`](https://github.com/millionco/react-doctor/commit/05f639910abf2b3bfc0802e9ad568ecd2b7ce13d) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: memoize `functionContainsReactRenderOutput` per function node so the ~5 rules sharing it walk each function subtree once per file instead of once per query
+
+- [#1040](https://github.com/millionco/react-doctor/pull/1040) [`a1c8ee1`](https://github.com/millionco/react-doctor/commit/a1c8ee110e137bbc8771c8a471c20287cccd2b38) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: replace the security scan's per-match O(content) slice+split in `getLocationAtIndex` with a memoized per-content line-start index answered by binary search
+
+- [#1047](https://github.com/millionco/react-doctor/pull/1047) [`fa61c20`](https://github.com/millionco/react-doctor/commit/fa61c2056951df2429e79d888e5f7334aaf61cfd) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: early-exit sweep — cheap discriminators now run before walks, scope lookups, and parent climbs across ~23 rules (raw-name bails before getElementType, whole-file import gates for the zod and recycler-list rules, substring gates before regex-heavy className analysis, filename gates hoisted to Program, and first-match pruning in containsFetchCall)
+
+- [#1050](https://github.com/millionco/react-doctor/pull/1050) [`ac71a3b`](https://github.com/millionco/react-doctor/commit/ac71a3b8cfc8bdd157f0f1bcd242b61ec69f9c17) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: fused-walk sweep — ~13 repeated subtree traversals collapse into single passes or per-node memos (async-await-in-loop's triple walk and fixpoint pre-pass, js-cache/js-index-maps loop walks, rendering-usetransition's three detectors, display-name's per-candidate program scans, per-binding setter walks in the state/effect rules, and WeakMap memos for prop-name/bound-name/effect-count analyses)
+
+- [#1051](https://github.com/millionco/react-doctor/pull/1051) [`d8628d7`](https://github.com/millionco/react-doctor/commit/d8628d7f21e60b0e6dfd98d76c9f24e03f7afe24) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: memoization sweep — per-file/per-Program analyses stop recomputing per node and per rule (security-scan path classification cached per pattern+path, layout export scans cached per file with mtime invalidation, effect scope/reference/upstream-ref lookups memoized per analysis, the duplicated outer-scope scan converged onto getScopeForNode, zod import classification memoized per identifier, and normalizeFilename skips the no-op allocation)
+
+- [#1049](https://github.com/millionco/react-doctor/pull/1049) [`ebeee56`](https://github.com/millionco/react-doctor/commit/ebeee568abf9a7ed37ed9fe0bba695e4f2a11c9f) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: regex-hoist sweep — ~8 per-call RegExp constructions move to module scope or behind cheap gates (public-env secret-name global pattern hoisted, supabase RLS enables collected in one pass instead of per-table compile+slice, dangerous-html-sink inert-target and serializer exemptions gated/lazy, design color/duration parsers get first-char and substring discriminators)
+
+- [#1048](https://github.com/millionco/react-doctor/pull/1048) [`da3b19c`](https://github.com/millionco/react-doctor/commit/da3b19c79c27945d873eb24e34431cbefa8f9938) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf: set-membership sweep — ~13 linear array scans on per-element hot paths now use Sets/Maps (ARIA element-role tables become O(1) lookup maps, event-handler presence checks collapse to one lowercased-Set pass per element, a11y settings lists and tanstack order tables convert to Sets/index Maps)
+
+- [#1043](https://github.com/millionco/react-doctor/pull/1043) [`6a9a73b`](https://github.com/millionco/react-doctor/commit/6a9a73b14908272535aabab6742258b61bc2ee5c) Thanks [@rayhanadev](https://github.com/rayhanadev)! - perf(rules): hoist per-file directory classification out of per-node visitors — the TanStack Start and Next.js rules that called `isInProjectDirectory` (or tested the root-route filename pattern) on every JSX element / call expression now compute it once in `create()` and skip non-matching files entirely
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - rn-no-raw-text: collapse internal whitespace in the quoted raw-text preview so multi-line JSX text produces a single-line message and CRLF vs LF sources report identically (found by the new metamorphic CRLF fuzz oracle).
+
+- [#1032](https://github.com/millionco/react-doctor/pull/1032) [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - Reword six diagnostic messages that asserted concrete runtime harm on trigger shapes where the harm does not occur: no-render-in-render (plain render-helper calls do not remount or lose state), no-direct-state-mutation (a setter call after the mutation still redraws), no-direct-mutation-state (setState after the mutation still redraws), server-no-mutable-module-state (a never-written module `let` leaks nothing), query-mutation-missing-invalidation (invalidation can happen at the mutate() call site), and rn-no-dimensions-get (a Dimensions.get() read inside an event handler is fresh, not stale).
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/oxlint-plugin-react-doctor/package.json b/packages/oxlint-plugin-react-doctor/package.json
index fd0fe532dd..0438116480 100644
--- a/packages/oxlint-plugin-react-doctor/package.json
+++ b/packages/oxlint-plugin-react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",
diff --git a/packages/react-doctor/CHANGELOG.md b/packages/react-doctor/CHANGELOG.md
index acaf2d9b73..3f6fde87bc 100644
--- a/packages/react-doctor/CHANGELOG.md
+++ b/packages/react-doctor/CHANGELOG.md
@@ -1,5 +1,19 @@
 # react-doctor
 
+## 0.6.3
+
+### Patch Changes
+
+- [#1045](https://github.com/millionco/react-doctor/pull/1045) [`fc75a3e`](https://github.com/millionco/react-doctor/commit/fc75a3e361251885c7325324f2ab6812255b0c18) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Balance lint batches by file size (LPT) so one oversized batch no longer sets the whole scan's wall clock. The full-scan batcher greedily filled 100-file chunks in discovery order, so a directory of large files (generated modules, vendored bundles, big test fixtures — adjacent in `git ls-files` order) all landed in ONE batch: on a 619-file corpus with six ~240 KB files that straggler batch ran ~7.5 s while the other six workers finished in ~1 s and idled — and a big enough cluster can trip the 60 s per-batch timeout and drop files. The planner now keeps the same batch count (and therefore the same subprocess count and CPU) but assigns files largest-first to the least-loaded batch, so every batch carries an even share of files and bytes: 2.2× faster wall clock on the skewed corpus (9.7 s → 4.3 s), no measurable change on uniform repos, and diagnostics verified byte-identical on both. Splitting into MORE batches to feed idle workers was measured to regress (each extra concurrent subprocess pays a contended cold start that outweighs its smaller file share) and is deliberately not done. `REACT_DOCTOR_LINT_BATCH_ORDERING=arrival` rolls back to the old greedy chunking; the previous opt-in `cost` mode (sort-descending-then-chunk, which concentrated the heavy files instead of spreading them) is superseded by the balanced plan.
+
+- [#1046](https://github.com/millionco/react-doctor/pull/1046) [`59e8178`](https://github.com/millionco/react-doctor/commit/59e817858240d4a4986ff03b8bb4f7d3355e22c6) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Stop lint's pre-spawn setup from starving the overlapped security-scan and supply-chain passes.
+
+  The security scan already runs on a cooperative background fiber that overlaps the lint pass, but a forked fiber only advances when the main thread yields — and lint's synchronous pre-spawn prefix (full-scan file discovery plus the per-file cache's content-hash partition over every candidate file) held the event loop until the first oxlint subprocess spawned. The overlapped passes now start immediately: the lint runner hands the loop back once before discovery and yields on the shared cooperative time budget while hashing, and the security scan's own directory walk (previously one unyielding readdir+classify burst before its first budget checkpoint) yields walk-progress markers so large trees can't stall lint subprocess draining or concurrently-scanning sibling projects. Diagnostics are byte-identical and the report order is unchanged.
+
+- Updated dependencies [[`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`b4faf74`](https://github.com/millionco/react-doctor/commit/b4faf74744c730d0836235854b0233ce59a42566), [`072d37e`](https://github.com/millionco/react-doctor/commit/072d37e8e4f82454d2e187114d0194f26efc1bf0), [`2980d0f`](https://github.com/millionco/react-doctor/commit/2980d0f4ed6abfee061ac02f3a0820806f942b95), [`5fec491`](https://github.com/millionco/react-doctor/commit/5fec491e6844d73f658f355ae2cbe86285068f0e), [`05f6399`](https://github.com/millionco/react-doctor/commit/05f639910abf2b3bfc0802e9ad568ecd2b7ce13d), [`a1c8ee1`](https://github.com/millionco/react-doctor/commit/a1c8ee110e137bbc8771c8a471c20287cccd2b38), [`fa61c20`](https://github.com/millionco/react-doctor/commit/fa61c2056951df2429e79d888e5f7334aaf61cfd), [`ac71a3b`](https://github.com/millionco/react-doctor/commit/ac71a3b8cfc8bdd157f0f1bcd242b61ec69f9c17), [`d8628d7`](https://github.com/millionco/react-doctor/commit/d8628d7f21e60b0e6dfd98d76c9f24e03f7afe24), [`ebeee56`](https://github.com/millionco/react-doctor/commit/ebeee568abf9a7ed37ed9fe0bba695e4f2a11c9f), [`da3b19c`](https://github.com/millionco/react-doctor/commit/da3b19c79c27945d873eb24e34431cbefa8f9938), [`6a9a73b`](https://github.com/millionco/react-doctor/commit/6a9a73b14908272535aabab6742258b61bc2ee5c), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b), [`173cc0a`](https://github.com/millionco/react-doctor/commit/173cc0a8ba5578229e3832b2167d3f7a5386c91b)]:
+  - oxlint-plugin-react-doctor@0.6.3
+  - deslop-js@0.6.3
+
 ## 0.6.2
 
 ### Patch Changes
diff --git a/packages/react-doctor/package.json b/packages/react-doctor/package.json
index 9518313c36..d296f33670 100644
--- a/packages/react-doctor/package.json
+++ b/packages/react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-doctor",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Your agent writes bad React. This catches it",
   "keywords": [
     "accessibility",

From 157111917d2e4d4834c70cfdd18ed7858f33b632 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 19:54:16 -0500
Subject: [PATCH 16/33] fix(cli): raise runGit maxBuffer so the scan cache
 works on large repos (#1052)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-scan-cache-maxbuffer.md       |  7 ++++++
 .../react-doctor/src/cli/utils/constants.ts   |  9 ++++++++
 .../src/cli/utils/git-hook-shared.ts          |  2 ++
 .../tests/scan-result-cache.test.ts           | 23 +++++++++++++++++++
 4 files changed, 41 insertions(+)
 create mode 100644 .changeset/perf-scan-cache-maxbuffer.md

diff --git a/.changeset/perf-scan-cache-maxbuffer.md b/.changeset/perf-scan-cache-maxbuffer.md
new file mode 100644
index 0000000000..99ab18a163
--- /dev/null
+++ b/.changeset/perf-scan-cache-maxbuffer.md
@@ -0,0 +1,7 @@
+---
+"react-doctor": patch
+---
+
+Restore instant reruns on large repos: raise `runGit`'s output cap so the whole-repo scan-result cache works past ~15k tracked files.
+
+The cache's clean-worktree gates shell out to git through a helper that used Node's default 1 MiB `maxBuffer`. On repos with roughly 15-25k tracked files (getsentry/sentry: 20,343), `git ls-files -v` alone exceeds that, `execFileSync` throws ENOBUFS, the helper swallows it into `null`, and the gates read `null` as "hidden tracked state" — so the cache silently never stored or served a scan on exactly the repos where the instant-rerun path saves the most time. The helper now runs with an explicit 64 MiB cap, which clears monorepos with hundreds of thousands of files while still bounding a pathological child process.
diff --git a/packages/react-doctor/src/cli/utils/constants.ts b/packages/react-doctor/src/cli/utils/constants.ts
index 7807694be5..ff9084a630 100644
--- a/packages/react-doctor/src/cli/utils/constants.ts
+++ b/packages/react-doctor/src/cli/utils/constants.ts
@@ -31,6 +31,15 @@ export const SCAN_RESULT_CACHE_SCHEMA_VERSION = 3;
 export const SCAN_RESULT_CACHE_MAX_ENTRY_COUNT = 20;
 export const CACHE_FILENAME_HASH_LENGTH_CHARS = 16;
 
+// Stdout cap for `runGit` (git-hook-shared.ts). Node's default `maxBuffer`
+// is 1 MiB, and `git ls-files -v` alone exceeds that on repos with ~15-25k
+// tracked files (getsentry/sentry: 1.25 MB) — execFileSync then throws
+// ENOBUFS, runGit swallows it into `null`, and the whole-repo scan-result
+// cache silently never stores or serves on exactly the large repos it helps
+// most. 64 MiB clears monorepos with hundreds of thousands of files while
+// still bounding a pathological child.
+export const RUN_GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+
 export const GIT_HOOK_EXECUTABLE_MODE = 0o755;
 
 export const AGENT_HOOK_TIMEOUT_SECONDS = 120;
diff --git a/packages/react-doctor/src/cli/utils/git-hook-shared.ts b/packages/react-doctor/src/cli/utils/git-hook-shared.ts
index 9bee5bfffa..74271fd9d0 100644
--- a/packages/react-doctor/src/cli/utils/git-hook-shared.ts
+++ b/packages/react-doctor/src/cli/utils/git-hook-shared.ts
@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { RUN_GIT_MAX_BUFFER_BYTES } from "./constants.js";
 
 export const HOOK_FILE_NAME = "pre-commit";
 export const HOOK_RELATIVE_PATH = "hooks/pre-commit";
@@ -33,6 +34,7 @@ export const runGit = (projectRoot: string, args: ReadonlyArray<string>): string
       cwd: projectRoot,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
+      maxBuffer: RUN_GIT_MAX_BUFFER_BYTES,
     }).trim();
   } catch {
     return null;
diff --git a/packages/react-doctor/tests/scan-result-cache.test.ts b/packages/react-doctor/tests/scan-result-cache.test.ts
index 8877a72a8c..bd8cef37e4 100644
--- a/packages/react-doctor/tests/scan-result-cache.test.ts
+++ b/packages/react-doctor/tests/scan-result-cache.test.ts
@@ -11,6 +11,7 @@ import {
   shouldStoreScanPayload,
   type CachedScanPayload,
 } from "../src/cli/utils/scan-result-cache.js";
+import { runGit } from "../src/cli/utils/git-hook-shared.js";
 import { VERSION } from "../src/cli/utils/version.js";
 import { commitAll, initGitRepo, setupReactProject } from "./regressions/_helpers.js";
 
@@ -257,6 +258,28 @@ describe("scan result cache", () => {
     expect(cacheKey(projectDirectory, baseOptions())).toBeNull();
   });
 
+  it("handles git output larger than Node's default maxBuffer", () => {
+    // `git ls-files -v` exceeds execFileSync's 1 MiB default on repos with
+    // ~15-25k tracked files (getsentry/sentry: 1.25 MB); the resulting ENOBUFS
+    // surfaced as `null`, which the cache gates read as hidden tracked state —
+    // silently disabling the whole-repo cache on exactly the largest repos.
+    // A shell alias emits 2 MiB through the production helper without needing
+    // a giant fixture repo.
+    const projectDirectory = setupReactProject(tempDirectory, "large-output", {
+      files: { "src/App.tsx": "export const App = () => <div />;\n" },
+    });
+    initGitRepo(projectDirectory, { commit: true });
+
+    const outputSizeChars = 2 * 1024 * 1024;
+    const nodeBinaryForShell = process.execPath.replaceAll("\\", "/");
+    const output = runGit(projectDirectory, [
+      "-c",
+      `alias.emit-large-output=!"${nodeBinaryForShell}" -e "process.stdout.write('x'.repeat(${outputSizeChars}))"`,
+      "emit-large-output",
+    ]);
+    expect(output?.length).toBe(outputSizeChars);
+  });
+
   it("reuses diagnostics when rerendering with verbose enabled", async () => {
     const projectDirectory = setupReactProject(tempDirectory, "verbose", {
       files: { "src/App.tsx": "export const App = () => <div />;\n" },

From e257a5ed3fb17286a9f55dfec0772ab8a91574b1 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 19:54:22 -0500
Subject: [PATCH 17/33] perf(core): cache dead-code results so unchanged
 rescans skip the analysis (#1053)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-dead-code-cache.md            |   5 +
 packages/core/src/check-dead-code.ts          |  58 +++-
 packages/core/src/constants.ts                |   7 +
 .../src/dead-code/dead-code-result-cache.ts   | 197 +++++++++++
 packages/core/src/refs.ts                     |  25 ++
 packages/core/src/run-inspect.ts              |  17 +
 packages/core/src/services/dead-code.ts       |  11 +
 packages/core/src/types/inspect.ts            |   8 +
 .../core/tests/dead-code-result-cache.test.ts | 315 ++++++++++++++++++
 .../src/cli/utils/build-run-event.ts          |   3 +
 packages/react-doctor/src/inspect.ts          |  12 +
 11 files changed, 656 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/perf-dead-code-cache.md
 create mode 100644 packages/core/src/dead-code/dead-code-result-cache.ts
 create mode 100644 packages/core/tests/dead-code-result-cache.test.ts

diff --git a/.changeset/perf-dead-code-cache.md b/.changeset/perf-dead-code-cache.md
new file mode 100644
index 0000000000..2cc3d4b2e7
--- /dev/null
+++ b/.changeset/perf-dead-code-cache.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": patch
+---
+
+Rescans now skip the dead-code analysis entirely when nothing it reads has changed. The pass persists its diagnostics keyed by a fingerprint over the analyzed source tree (stat-based, so additions, deletions, and edits all invalidate), the project's manifests, tsconfigs, lockfiles, knip/entry/ignore configuration, and the analyzer version — on an unchanged-input rerun the stored result replays instead of re-walking the whole import graph, cutting several seconds off warm rescans of large repos. Only complete, successful passes are stored; `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
diff --git a/packages/core/src/check-dead-code.ts b/packages/core/src/check-dead-code.ts
index 8c3bd76513..63db54fea6 100644
--- a/packages/core/src/check-dead-code.ts
+++ b/packages/core/src/check-dead-code.ts
@@ -6,6 +6,11 @@ import {
   collectDeadCodeEntryPatterns,
   collectDeadCodeIgnorePatterns,
 } from "./dead-code/collect-dead-code-patterns.js";
+import {
+  computeDeadCodeCacheKey,
+  lookupDeadCodeResultCache,
+  storeDeadCodeResultCache,
+} from "./dead-code/dead-code-result-cache.js";
 import { withDeadCodeWorkerSlot } from "./dead-code/dead-code-worker-slots.js";
 import {
   DEAD_CODE_WORKER_MAX_OLD_SPACE_MB,
@@ -14,6 +19,7 @@ import {
   TSCONFIG_FILENAMES,
 } from "./constants.js";
 import { isRecord } from "./utils/is-record.js";
+import { resolveReactDoctorCacheDir } from "./utils/resolve-react-doctor-cache-dir.js";
 import { toCanonicalPath } from "./utils/to-canonical-path.js";
 import { toRelativePath } from "./utils/to-relative-path.js";
 
@@ -57,6 +63,21 @@ interface CheckDeadCodeOptions {
    * `DEAD_CODE_WORKER_TIMEOUT_MS`.
    */
   readonly abortSignal?: AbortSignal;
+  /**
+   * Whether to consult the whole-project dead-code result cache. Defaults
+   * OFF so direct callers (and existing tests) keep their fresh-analysis
+   * semantics; the `DeadCode` service passes the `DeadCodeResultCacheEnabled`
+   * Reference here. A hit replays the stored diagnostics without spawning
+   * the analysis worker; a fresh COMPLETE pass is stored on success (a
+   * crashed, timed-out, or aborted worker rejects before the store).
+   */
+  readonly cacheEnabled?: boolean;
+  /**
+   * Reports the cache outcome (`true` = hit, `false` = miss) once per call.
+   * Not invoked when `cacheEnabled` is off, so the orchestrator's telemetry
+   * distinguishes "no cache" from a miss.
+   */
+  readonly onCacheOutcome?: (didHitCache: boolean) => void;
 }
 
 interface DeadCodeWorkerInput {
@@ -498,6 +519,32 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
 
   const entryPatterns = collectDeadCodeEntryPatterns(rootDirectory);
   const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory);
+  const tsConfigPath = resolveTsConfigPath(rootDirectory);
+  const deslopJsModuleSpecifier =
+    options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js");
+
+  // Result cache: replay the last complete pass when nothing the analysis
+  // reads changed. The key snapshot is taken BEFORE the (long) analysis so a
+  // stored result is keyed by the tree it started from — an edit racing the
+  // analysis lands a stale key that the next run's fresh snapshot misses.
+  const cacheKey = options.cacheEnabled
+    ? computeDeadCodeCacheKey({
+        rootDirectory,
+        entryPatterns,
+        ignorePatterns,
+        tsConfigPath,
+        deslopJsModuleSpecifier,
+      })
+    : null;
+  if (cacheKey !== null) {
+    const cachedDiagnostics = lookupDeadCodeResultCache(
+      resolveReactDoctorCacheDir(rootDirectory),
+      cacheKey,
+    );
+    options.onCacheOutcome?.(cachedDiagnostics !== null);
+    if (cachedDiagnostics !== null) return [...cachedDiagnostics];
+  }
+
   // `runDeadCodeWorkerWithTimeout` owns the abort wiring: when the surrounding
   // Effect fiber is interrupted (lint failed / dead-code phase timeout / scan
   // cancelled), `Effect.tryPromise` aborts `options.abortSignal`, which its
@@ -507,9 +554,9 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
     const workerHandle = (options.createWorker ?? createDeadCodeWorker)({
       rootDirectory,
       entryPatterns,
-      tsConfigPath: resolveTsConfigPath(rootDirectory),
+      tsConfigPath,
       ignorePatterns,
-      deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js"),
+      deslopJsModuleSpecifier,
       parseConcurrency: options.parseConcurrency,
     });
     return runDeadCodeWorkerWithTimeout(
@@ -600,5 +647,12 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
     });
   }
 
+  // Only a COMPLETE successful pass reaches this line — a crashed, timed-out,
+  // or aborted worker rejects above — so a stored entry never replays a
+  // truncated result (mirroring `shouldStoreScanPayload`).
+  if (cacheKey !== null) {
+    storeDeadCodeResultCache(resolveReactDoctorCacheDir(rootDirectory), cacheKey, diagnostics);
+  }
+
   return diagnostics;
 };
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index c2ac71ee60..5b94f085c9 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -631,6 +631,13 @@ export const FILE_LINT_CACHE_MAX_FILE_COUNT = 50_000;
 // fallback when a project has no `node_modules` to host `.cache/react-doctor`.
 export const CACHE_FILENAME_HASH_LENGTH_CHARS = 16;
 
+// Whole-project dead-code result cache (`dead-code/dead-code-result-cache.ts`).
+// Replays deslop's diagnostics — skipping the analysis worker entirely — when
+// nothing the analysis reads has changed since the stored run.
+export const DEAD_CODE_CACHE_SCHEMA_VERSION = 1;
+
+export const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
+
 // Plugin / rule / category identity for the diagnostics the supply-chain
 // check emits. `plugin: "socket"` keeps Socket findings visually distinct
 // from the `react-doctor` lint surface in the printed list and JSON report.
diff --git a/packages/core/src/dead-code/dead-code-result-cache.ts b/packages/core/src/dead-code/dead-code-result-cache.ts
new file mode 100644
index 0000000000..63340f787f
--- /dev/null
+++ b/packages/core/src/dead-code/dead-code-result-cache.ts
@@ -0,0 +1,197 @@
+import crypto from "node:crypto";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import * as Schema from "effect/Schema";
+import type { Diagnostic } from "../types/index.js";
+import { DEAD_CODE_CACHE_FILENAME, DEAD_CODE_CACHE_SCHEMA_VERSION } from "../constants.js";
+import { Diagnostic as DiagnosticSchema } from "../schemas.js";
+import { atomicWriteJson } from "../utils/atomic-write-json.js";
+import { failOpenReadJson } from "../utils/fail-open-read-json.js";
+import { isRecord } from "../utils/is-record.js";
+import { walkSourceTreeFiles } from "../utils/walk-source-tree-files.js";
+
+/**
+ * Whole-project dead-code result cache. Dead-code reachability is a
+ * whole-project property, so the cache holds ONE entry: the diagnostics of the
+ * last complete, successful pass, keyed by a fingerprint over everything the
+ * analysis reads. Any input change mints a new key, which makes the stored
+ * entry unreachable — so there is nothing to gain from keeping history.
+ *
+ * The key fingerprints files by (path, mtime, size) — the same stat-based
+ * invalidation the plugin's `parse-source-file` cache uses — rather than
+ * content-hashing the whole tree, because statting ~9k files costs
+ * ~100-200 ms while hashing them costs seconds. The accepted tradeoff, shared
+ * with that precedent: an edit that preserves BOTH a file's byte size and its
+ * mtime is invisible to the fingerprint. Additions and deletions always
+ * invalidate — the sorted path list itself is part of the hash.
+ *
+ * Every operation fails open: a missing or corrupt cache degrades to a fresh
+ * analysis, never to a wrong result.
+ */
+
+interface DeadCodeCacheKeyInput {
+  /** Canonicalized project root (`checkDeadCode` realpaths it first). */
+  readonly rootDirectory: string;
+  readonly entryPatterns: ReadonlyArray<string>;
+  readonly ignorePatterns: ReadonlyArray<string>;
+  readonly tsConfigPath: string | undefined;
+  readonly deslopJsModuleSpecifier: string;
+}
+
+interface PersistedDeadCodeResultCache {
+  readonly version: number;
+  readonly key: string;
+  readonly diagnostics: ReadonlyArray<unknown>;
+}
+
+// The extensions deslop's import-graph walk parses (its DEFAULT_EXTENSIONS),
+// so an edit to any file the graph can reach changes the key.
+const ANALYZED_FILE_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mts",
+  ".mjs",
+  ".cts",
+  ".cjs",
+  ".mdx",
+  ".astro",
+  ".graphql",
+  ".gql",
+  ".css",
+  ".scss",
+  ".vue",
+  ".svelte",
+]);
+
+// Non-source files deslop's entry/workspace/dependency analysis reads:
+// manifests (workspace layout, dependency declarations, knip/expo config),
+// lockfiles (the proxy for installed `node_modules` metadata — deslop reads
+// installed packages' bin/peer fields, which only change through an install
+// that rewrites the lockfile), and `.gitignore` files at every level (deslop
+// consults git's ignore state for its walk).
+const ANALYZED_MANIFEST_NAMES = new Set([
+  "package.json",
+  "knip.json",
+  "app.json",
+  "pnpm-workspace.yaml",
+  "lerna.json",
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "deno.lock",
+  ".gitignore",
+]);
+
+// tsconfig/jsconfig files anywhere in the tree — path-alias resolution reads
+// the root config, and `extends` chains reach the rest.
+const isTsConfigLikeFile = (fileName: string): boolean =>
+  (fileName.startsWith("tsconfig") || fileName.startsWith("jsconfig")) &&
+  fileName.endsWith(".json");
+
+const isFingerprintedFile = (fileName: string): boolean =>
+  ANALYZED_FILE_EXTENSIONS.has(path.extname(fileName).toLowerCase()) ||
+  ANALYZED_MANIFEST_NAMES.has(fileName) ||
+  isTsConfigLikeFile(fileName);
+
+const collectAnalyzedFileFingerprints = (rootDirectory: string): string[] => {
+  const fingerprints: string[] = [];
+  for (const { absolutePath, name } of walkSourceTreeFiles(rootDirectory)) {
+    if (!isFingerprintedFile(name)) continue;
+    try {
+      const fileStat = fs.statSync(absolutePath);
+      const relativePath = path.relative(rootDirectory, absolutePath).replace(/\\/g, "/");
+      fingerprints.push(`${relativePath}:${fileStat.mtimeMs}:${fileStat.size}`);
+    } catch {
+      // Vanished between walk and stat — same key contribution as deleted.
+    }
+  }
+  return fingerprints.sort();
+};
+
+const bundledRequire = createRequire(import.meta.url);
+
+const resolveDeslopVersion = (): string => {
+  try {
+    const packageJson = JSON.parse(
+      fs.readFileSync(bundledRequire.resolve("deslop-js/package.json"), "utf8"),
+    );
+    return isRecord(packageJson) && typeof packageJson.version === "string"
+      ? packageJson.version
+      : "unknown";
+  } catch {
+    return "unknown";
+  }
+};
+
+export const computeDeadCodeCacheKey = (input: DeadCodeCacheKeyInput): string =>
+  crypto
+    .createHash("sha1")
+    .update(
+      JSON.stringify({
+        schemaVersion: DEAD_CODE_CACHE_SCHEMA_VERSION,
+        deslopVersion: resolveDeslopVersion(),
+        deslopJsModuleSpecifier: input.deslopJsModuleSpecifier,
+        entryPatterns: input.entryPatterns,
+        ignorePatterns: input.ignorePatterns,
+        // Which tsconfig filename resolved (its CONTENT rides in the file
+        // fingerprints below; existence/choice is what this captures).
+        tsConfigFile:
+          input.tsConfigPath === undefined
+            ? null
+            : path.relative(input.rootDirectory, input.tsConfigPath).replace(/\\/g, "/"),
+        files: collectAnalyzedFileFingerprints(input.rootDirectory),
+      }),
+    )
+    .digest("hex");
+
+const validateDiagnostic = Schema.decodeUnknownSync(DiagnosticSchema);
+
+// Returns `null` if ANY stored entry is malformed, so a corrupt file degrades
+// to a whole-pass miss rather than a partial diagnostic set. The records were
+// serialized straight from `checkDeadCode`'s `Diagnostic[]`, so the validated
+// array replays as-is in its original (deterministic) order.
+const decodeCachedDiagnostics = (raw: ReadonlyArray<unknown>): ReadonlyArray<Diagnostic> | null => {
+  try {
+    for (const entry of raw) validateDiagnostic(entry);
+    return raw as ReadonlyArray<Diagnostic>;
+  } catch {
+    return null;
+  }
+};
+
+export const lookupDeadCodeResultCache = (
+  cacheDirectory: string,
+  cacheKey: string,
+): ReadonlyArray<Diagnostic> | null => {
+  const persisted = failOpenReadJson<PersistedDeadCodeResultCache | null>(
+    path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME),
+    null,
+  );
+  if (
+    persisted === null ||
+    !isRecord(persisted) ||
+    persisted.version !== DEAD_CODE_CACHE_SCHEMA_VERSION ||
+    persisted.key !== cacheKey ||
+    !Array.isArray(persisted.diagnostics)
+  ) {
+    return null;
+  }
+  return decodeCachedDiagnostics(persisted.diagnostics);
+};
+
+export const storeDeadCodeResultCache = (
+  cacheDirectory: string,
+  cacheKey: string,
+  diagnostics: ReadonlyArray<Diagnostic>,
+): void => {
+  atomicWriteJson(path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME), {
+    version: DEAD_CODE_CACHE_SCHEMA_VERSION,
+    key: cacheKey,
+    diagnostics,
+  });
+};
diff --git a/packages/core/src/refs.ts b/packages/core/src/refs.ts
index 9c535c88b0..b265f6aa2f 100644
--- a/packages/core/src/refs.ts
+++ b/packages/core/src/refs.ts
@@ -207,3 +207,28 @@ export class PerFileLintCacheEnabled extends Context.Reference<boolean>(
     },
   },
 ) {}
+
+/**
+ * Whether the whole-project dead-code result cache
+ * (`dead-code/dead-code-result-cache.ts`) is active. Defaults ON — a rescan
+ * whose inputs (source tree, manifests, configs, analyzer version) are
+ * unchanged replays the stored diagnostics instead of re-running the
+ * analysis worker. Opt-OUT, two knobs (matching the per-file lint cache):
+ *
+ *   - `REACT_DOCTOR_NO_CACHE` — the global off-switch.
+ *   - `REACT_DOCTOR_NO_DEAD_CODE_CACHE` — granular: bust only this cache.
+ *
+ * Tests override via `Layer.succeed(DeadCodeResultCacheEnabled, false)`.
+ */
+export class DeadCodeResultCacheEnabled extends Context.Reference<boolean>(
+  "react-doctor/DeadCodeResultCacheEnabled",
+  {
+    defaultValue: () => {
+      const noCache = process.env["REACT_DOCTOR_NO_CACHE"]?.toLowerCase() ?? "";
+      const noDeadCodeCache = process.env["REACT_DOCTOR_NO_DEAD_CODE_CACHE"]?.toLowerCase() ?? "";
+      if (CACHE_DISABLED_VALUES.has(noCache)) return false;
+      if (CACHE_DISABLED_VALUES.has(noDeadCodeCache)) return false;
+      return true;
+    },
+  },
+) {}
diff --git a/packages/core/src/run-inspect.ts b/packages/core/src/run-inspect.ts
index 3bb66f0659..8477d1d64c 100644
--- a/packages/core/src/run-inspect.ts
+++ b/packages/core/src/run-inspect.ts
@@ -238,6 +238,16 @@ export interface InspectOutput {
    */
   readonly lintCacheHitFileCount: number | null;
   readonly lintCacheTotalFileCount: number | null;
+  /**
+   * Dead-code result cache outcome for this scan's dead-code pass: `true`
+   * when the cached result was replayed (the analysis worker never spawned),
+   * `false` on a miss (fresh analysis). `null` when the pass never consulted
+   * the cache — dead-code skipped/disabled, the cache off
+   * (`REACT_DOCTOR_NO_CACHE` / `REACT_DOCTOR_NO_DEAD_CODE_CACHE`), or the
+   * pass discarded by a lint failure. Fed to the Sentry wide event as
+   * `deadCode.cacheHit`.
+   */
+  readonly deadCodeCacheHit: boolean | null;
   /**
    * Per-rule tallies of diagnostics the pipeline dropped because the user
    * explicitly silenced the rule (config off switches, per-path overrides,
@@ -673,6 +683,9 @@ export const runInspect = <HooksR = never>(
               rootDirectory: scanDirectory,
               parseConcurrency: deadCodeParseConcurrency,
               workerTimeoutMs: deadCodeTimeout.workerTimeoutMs,
+              onCacheOutcome: (didHitCache) => {
+                deadCodeCacheHit = didHitCache;
+              },
             })
             .pipe(
               Stream.catchTag("ReactDoctorError", (error: ReactDoctorError) =>
@@ -736,6 +749,7 @@ export const runInspect = <HooksR = never>(
     // or bypassed so the wide event can tell "no cache" from "0% hit".
     let lintCacheHitFileCount: number | null = null;
     let lintCacheTotalFileCount: number | null = null;
+    let deadCodeCacheHit: boolean | null = null;
 
     const baseLintStream = linterService
       .run({
@@ -985,6 +999,9 @@ export const runInspect = <HooksR = never>(
       securityScanFailed,
       lintCacheHitFileCount,
       lintCacheTotalFileCount,
+      // Lint failure discards the dead-code pass entirely (see
+      // `deadCodeFailureState` above), so its cache outcome must not leak.
+      deadCodeCacheHit: lintFailureState.didFail ? null : deadCodeCacheHit,
       suppressedRuleCounts: transform.summarizeSuppressions(),
     };
   }).pipe(
diff --git a/packages/core/src/services/dead-code.ts b/packages/core/src/services/dead-code.ts
index 1b7d71dc69..bc11366987 100644
--- a/packages/core/src/services/dead-code.ts
+++ b/packages/core/src/services/dead-code.ts
@@ -5,6 +5,7 @@ import * as Stream from "effect/Stream";
 import type { Diagnostic } from "../types/index.js";
 import { checkDeadCode } from "../check-dead-code.js";
 import { DeadCodeAnalysisFailed, ReactDoctorError } from "../errors.js";
+import { DeadCodeResultCacheEnabled } from "../refs.js";
 
 interface DeadCodeInput {
   readonly rootDirectory: string;
@@ -20,6 +21,13 @@ interface DeadCodeInput {
    * `DEAD_CODE_WORKER_TIMEOUT_MS` floor.
    */
   readonly workerTimeoutMs?: number;
+  /**
+   * Reports the dead-code result cache outcome (`true` = hit, `false` =
+   * miss). Not invoked when the cache is disabled
+   * (`DeadCodeResultCacheEnabled` off), so the orchestrator's telemetry
+   * distinguishes "no cache" from a miss.
+   */
+  readonly onCacheOutcome?: (didHitCache: boolean) => void;
 }
 
 /**
@@ -47,6 +55,7 @@ export class DeadCode extends Context.Service<
           // surfaces as a single named span in OTel traces (parent
           // of the per-call `Effect.tryPromise`).
           Effect.fn("DeadCode.run")(function* () {
+            const cacheEnabled = yield* DeadCodeResultCacheEnabled;
             return yield* Effect.tryPromise({
               // The signal is wired to fiber interruption: when the
               // orchestrator interrupts this fiber (lint failed / scan
@@ -58,6 +67,8 @@ export class DeadCode extends Context.Service<
                   parseConcurrency: input.parseConcurrency,
                   workerTimeoutMs: input.workerTimeoutMs,
                   abortSignal: signal,
+                  cacheEnabled,
+                  onCacheOutcome: input.onCacheOutcome,
                 }),
               catch: (cause) =>
                 new ReactDoctorError({ reason: new DeadCodeAnalysisFailed({ cause }) }),
diff --git a/packages/core/src/types/inspect.ts b/packages/core/src/types/inspect.ts
index 1ce3f085e0..aa59d09896 100644
--- a/packages/core/src/types/inspect.ts
+++ b/packages/core/src/types/inspect.ts
@@ -48,6 +48,14 @@ export interface InspectResult {
    */
   lintCacheHitFileCount?: number | null;
   lintCacheTotalFileCount?: number | null;
+  /**
+   * Dead-code result cache outcome: `true` when the pass replayed a cached
+   * result (the analysis never ran), `false` on a fresh analysis. Absent when
+   * the pass never consulted the cache — dead-code skipped, the cache
+   * disabled, or a whole-repo cache replay where no analysis ran. The CLI
+   * projects it onto the Sentry wide event as `deadCode.cacheHit`.
+   */
+  deadCodeCacheHit?: boolean | null;
   /**
    * Present only for a baseline run (`InspectOptions.baseline` set). The
    * `diagnostics` above are then the *introduced* findings only; this
diff --git a/packages/core/tests/dead-code-result-cache.test.ts b/packages/core/tests/dead-code-result-cache.test.ts
new file mode 100644
index 0000000000..74c4b9bc05
--- /dev/null
+++ b/packages/core/tests/dead-code-result-cache.test.ts
@@ -0,0 +1,315 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import * as Effect from "effect/Effect";
+import { afterAll, beforeAll, describe, expect, it } from "vite-plus/test";
+import type { Diagnostic } from "../src/types/index.js";
+import { checkDeadCode } from "../src/check-dead-code.js";
+import { computeDeadCodeCacheKey } from "../src/dead-code/dead-code-result-cache.js";
+import { DeadCodeResultCacheEnabled } from "../src/refs.js";
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dead-code-cache-"));
+const originalCacheDirEnv = process.env["REACT_DOCTOR_CACHE_DIR"];
+
+beforeAll(() => {
+  // The cache resolves through `REACT_DOCTOR_CACHE_DIR` first; clear it so
+  // every fixture's cache deterministically lands in its own
+  // `node_modules/.cache/react-doctor` (created by `setupProject`).
+  delete process.env["REACT_DOCTOR_CACHE_DIR"];
+});
+
+afterAll(() => {
+  if (originalCacheDirEnv === undefined) delete process.env["REACT_DOCTOR_CACHE_DIR"];
+  else process.env["REACT_DOCTOR_CACHE_DIR"] = originalCacheDirEnv;
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+const setupProject = (caseId: string, files: Record<string, string>): string => {
+  const projectDirectory = path.join(tempRoot, caseId);
+  fs.mkdirSync(projectDirectory, { recursive: true });
+  // An (empty) node_modules pins `resolveReactDoctorCacheDir` to the fixture
+  // so the cache file is cleaned up with `tempRoot`.
+  fs.mkdirSync(path.join(projectDirectory, "node_modules"), { recursive: true });
+  fs.writeFileSync(
+    path.join(projectDirectory, "package.json"),
+    JSON.stringify({ name: caseId, type: "module", dependencies: { react: "^19.0.0" } }),
+  );
+  for (const [relativePath, contents] of Object.entries(files)) {
+    const fullPath = path.join(projectDirectory, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, contents);
+  }
+  // Match `checkDeadCode`'s canonicalized root (os.tmpdir() is a symlink into
+  // /private on macOS) so key inputs built from this path line up.
+  return fs.realpathSync(projectDirectory);
+};
+
+const cacheFilePath = (projectDirectory: string): string =>
+  path.join(projectDirectory, "node_modules", ".cache", "react-doctor", "dead-code-cache.json");
+
+const keyInput = (projectDirectory: string) => ({
+  rootDirectory: projectDirectory,
+  entryPatterns: [],
+  ignorePatterns: [],
+  tsConfigPath: undefined,
+  deslopJsModuleSpecifier: "deslop-js",
+});
+
+interface SpyWorker {
+  readonly factory: (input: unknown) => { result: Promise<unknown> };
+  readonly callCount: () => number;
+}
+
+const createSpyWorker = (unusedFilePath: string): SpyWorker => {
+  let calls = 0;
+  return {
+    factory: () => {
+      calls += 1;
+      return {
+        result: Promise.resolve({
+          unusedFiles: [{ path: unusedFilePath }],
+          unusedExports: [],
+          unusedDependencies: [],
+          circularDependencies: [],
+        }),
+      };
+    },
+    callCount: () => calls,
+  };
+};
+
+describe("computeDeadCodeCacheKey", () => {
+  it("is stable for identical inputs", () => {
+    const directory = setupProject("key-stable", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    expect(computeDeadCodeCacheKey(keyInput(directory))).toBe(
+      computeDeadCodeCacheKey(keyInput(directory)),
+    );
+  });
+
+  it("changes when a source file is touched (mtime)", () => {
+    const directory = setupProject("key-touch", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    const later = new Date(Date.now() + 5_000);
+    fs.utimesSync(path.join(directory, "src", "index.ts"), later, later);
+    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
+  });
+
+  it("changes when a source file is added", () => {
+    const directory = setupProject("key-add", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    fs.writeFileSync(path.join(directory, "src", "added.ts"), "export const added = 1;\n");
+    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
+  });
+
+  it("changes when a source file is deleted", () => {
+    const directory = setupProject("key-delete", {
+      "src/index.ts": "export const used = 1;\n",
+      "src/doomed.ts": "export const doomed = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    fs.rmSync(path.join(directory, "src", "doomed.ts"));
+    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
+  });
+
+  it("changes when a manifest (package.json) changes", () => {
+    const directory = setupProject("key-manifest", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    fs.writeFileSync(
+      path.join(directory, "package.json"),
+      JSON.stringify({
+        name: "key-manifest",
+        type: "module",
+        dependencies: { react: "^19.0.0", "left-pad": "^1.0.0" },
+      }),
+    );
+    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
+  });
+
+  it("changes with entry / ignore patterns and the resolved tsconfig", () => {
+    const directory = setupProject("key-config", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const baseKey = computeDeadCodeCacheKey(keyInput(directory));
+    expect(
+      computeDeadCodeCacheKey({ ...keyInput(directory), entryPatterns: ["src/cli.ts"] }),
+    ).not.toBe(baseKey);
+    expect(
+      computeDeadCodeCacheKey({ ...keyInput(directory), ignorePatterns: ["src/generated/**"] }),
+    ).not.toBe(baseKey);
+    expect(
+      computeDeadCodeCacheKey({
+        ...keyInput(directory),
+        tsConfigPath: path.join(directory, "tsconfig.json"),
+      }),
+    ).not.toBe(baseKey);
+  });
+
+  it("ignores files the analysis never reads (scratch text files)", () => {
+    const directory = setupProject("key-scratch", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    fs.writeFileSync(path.join(directory, "scratch.txt"), "not part of the graph\n");
+    expect(computeDeadCodeCacheKey(keyInput(directory))).toBe(keyBefore);
+  });
+});
+
+describe("checkDeadCode result cache", () => {
+  it("replays a stored pass without spawning the worker, and reports the outcome", async () => {
+    const directory = setupProject("hit-skips-analysis", {
+      "src/index.ts": "export const used = 1;\n",
+      "src/orphan.ts": "export const orphan = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "orphan.ts"));
+    const cacheOutcomes: boolean[] = [];
+    const onCacheOutcome = (didHitCache: boolean): void => {
+      cacheOutcomes.push(didHitCache);
+    };
+
+    const firstRun = await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome,
+    });
+    expect(spyWorker.callCount()).toBe(1);
+    expect(cacheOutcomes).toEqual([false]);
+    expect(fs.existsSync(cacheFilePath(directory))).toBe(true);
+
+    const secondRun = await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome,
+    });
+    expect(spyWorker.callCount()).toBe(1);
+    expect(cacheOutcomes).toEqual([false, true]);
+    expect(secondRun).toEqual(firstRun);
+  });
+
+  it("misses after a source file changes, and re-analyzes", async () => {
+    const directory = setupProject("miss-on-change", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "index.ts"));
+    const cacheOutcomes: boolean[] = [];
+    const onCacheOutcome = (didHitCache: boolean): void => {
+      cacheOutcomes.push(didHitCache);
+    };
+
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome,
+    });
+    const later = new Date(Date.now() + 5_000);
+    fs.utimesSync(path.join(directory, "src", "index.ts"), later, later);
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome,
+    });
+    expect(spyWorker.callCount()).toBe(2);
+    expect(cacheOutcomes).toEqual([false, false]);
+  });
+
+  it("never stores a failed pass", async () => {
+    const directory = setupProject("store-barred-on-failure", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    await expect(
+      checkDeadCode({
+        rootDirectory: directory,
+        createWorker: () => ({ result: Promise.reject(new Error("analysis crashed")) }),
+        cacheEnabled: true,
+      }),
+    ).rejects.toThrow("analysis crashed");
+    expect(fs.existsSync(cacheFilePath(directory))).toBe(false);
+
+    // The next (successful) run must be a genuine miss that re-analyzes.
+    const spyWorker = createSpyWorker(path.join(directory, "src", "index.ts"));
+    const cacheOutcomes: boolean[] = [];
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome: (didHitCache) => {
+        cacheOutcomes.push(didHitCache);
+      },
+    });
+    expect(spyWorker.callCount()).toBe(1);
+    expect(cacheOutcomes).toEqual([false]);
+  });
+
+  it("bypasses the cache entirely when disabled (default)", async () => {
+    const directory = setupProject("cache-disabled", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "index.ts"));
+    const cacheOutcomes: boolean[] = [];
+    const runOnce = (): Promise<Diagnostic[]> =>
+      checkDeadCode({
+        rootDirectory: directory,
+        createWorker: spyWorker.factory,
+        onCacheOutcome: (didHitCache) => {
+          cacheOutcomes.push(didHitCache);
+        },
+      });
+
+    await runOnce();
+    await runOnce();
+    expect(spyWorker.callCount()).toBe(2);
+    expect(cacheOutcomes).toEqual([]);
+    expect(fs.existsSync(cacheFilePath(directory))).toBe(false);
+  });
+
+  it("ignores an existing stored entry when the cache is disabled", async () => {
+    const directory = setupProject("cache-disabled-after-store", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "index.ts"));
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+    });
+    expect(fs.existsSync(cacheFilePath(directory))).toBe(true);
+
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: false,
+    });
+    expect(spyWorker.callCount()).toBe(2);
+  });
+});
+
+describe("DeadCodeResultCacheEnabled", () => {
+  // One read only: a Reference's `defaultValue` is memoized per process, so
+  // this test owns the file's single unprovided read of the ref.
+  it("defaults off when REACT_DOCTOR_NO_CACHE is set", () => {
+    const originalNoCacheEnv = process.env["REACT_DOCTOR_NO_CACHE"];
+    process.env["REACT_DOCTOR_NO_CACHE"] = "1";
+    try {
+      const enabled = Effect.runSync(
+        Effect.gen(function* () {
+          return yield* DeadCodeResultCacheEnabled;
+        }),
+      );
+      expect(enabled).toBe(false);
+    } finally {
+      if (originalNoCacheEnv === undefined) delete process.env["REACT_DOCTOR_NO_CACHE"];
+      else process.env["REACT_DOCTOR_NO_CACHE"] = originalNoCacheEnv;
+    }
+  });
+});
diff --git a/packages/react-doctor/src/cli/utils/build-run-event.ts b/packages/react-doctor/src/cli/utils/build-run-event.ts
index 0c3b292583..b3b7727f87 100644
--- a/packages/react-doctor/src/cli/utils/build-run-event.ts
+++ b/packages/react-doctor/src/cli/utils/build-run-event.ts
@@ -284,6 +284,9 @@ const buildOutcomeAttributes = (input: RunEventInput): RunEventAttributes => {
     ...withNamespace("deadCode", {
       failed: input.didDeadCodeFail ?? null,
       overlapped: input.deadCodeOverlapped ?? null,
+      // Dead-code result cache outcome; `null` when the pass never consulted
+      // the cache, so "no cache" reads distinctly from a miss.
+      cacheHit: result.deadCodeCacheHit ?? null,
     }),
     ...withNamespace("supplyChain", {
       overlapTimedOut: input.supplyChainOverlapTimedOut ?? null,
diff --git a/packages/react-doctor/src/inspect.ts b/packages/react-doctor/src/inspect.ts
index 7f5c5c20bb..092a424fec 100644
--- a/packages/react-doctor/src/inspect.ts
+++ b/packages/react-doctor/src/inspect.ts
@@ -792,6 +792,7 @@ const runInspectWithRuntime = async (
     baselineDegraded,
     lintCacheHitFileCount: output.lintCacheHitFileCount,
     lintCacheTotalFileCount: output.lintCacheTotalFileCount,
+    deadCodeCacheHit: output.deadCodeCacheHit,
   });
   recordOnboardingCompletion(options);
   return result;
@@ -815,6 +816,7 @@ interface FinalizeInput {
   scanElapsedMilliseconds: number;
   lintCacheHitFileCount: number | null;
   lintCacheTotalFileCount: number | null;
+  deadCodeCacheHit: boolean | null;
   baselineDelta: InspectResult["baselineDelta"];
 }
 
@@ -842,6 +844,13 @@ interface RenderAndRecordScanInput {
    */
   readonly lintCacheHitFileCount?: number | null;
   readonly lintCacheTotalFileCount?: number | null;
+  /**
+   * Dead-code result cache outcome for THIS scan's dead-code pass. Threaded
+   * outside `CachedScanPayload` for the same reason as the lint cache stats
+   * above: a whole-repo cache replay (where no analysis ran) correctly
+   * leaves it absent.
+   */
+  readonly deadCodeCacheHit?: boolean | null;
 }
 
 const runMaybeSilent = <A, E, R>(
@@ -887,6 +896,7 @@ const renderAndRecordScan = async (input: RenderAndRecordScanInput): Promise<Ins
     scanElapsedMilliseconds: input.payload.scanElapsedMilliseconds,
     lintCacheHitFileCount: input.lintCacheHitFileCount ?? null,
     lintCacheTotalFileCount: input.lintCacheTotalFileCount ?? null,
+    deadCodeCacheHit: input.deadCodeCacheHit ?? null,
     baselineDelta: input.payload.baselineDelta,
   };
   const result = await Effect.runPromise(
@@ -959,6 +969,7 @@ const finalizeAndRender = (input: FinalizeInput): Effect.Effect<InspectResult> =
       scanElapsedMilliseconds,
       lintCacheHitFileCount,
       lintCacheTotalFileCount,
+      deadCodeCacheHit,
       baselineDelta,
     } = input;
 
@@ -986,6 +997,7 @@ const finalizeAndRender = (input: FinalizeInput): Effect.Effect<InspectResult> =
       ...(lintCacheTotalFileCount !== null
         ? { lintCacheHitFileCount, lintCacheTotalFileCount }
         : {}),
+      ...(deadCodeCacheHit !== null ? { deadCodeCacheHit } : {}),
       ...(baselineDelta ? { baselineDelta } : {}),
     });
 

From 8c004f07fa69fdbed5f2f2ad19cfabfbf9d670e3 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 20:58:15 -0500
Subject: [PATCH 18/33] perf(cli): key the scan-result cache on dirty worktree
 content instead of bailing (#1054)

The instant-rerun cache required a perfectly clean tree, so it never fired
during development. Every divergence from HEAD is now fingerprinted into
the key (status code + path + content hash, bounded at 300 entries with
bail-to-null beyond), so identical dirty states hit and any edit misses;
root dotenv files are stat-keyed since the security scan reads them even
when gitignored.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-dirty-tree-cache-key.md       |   5 +
 packages/core/src/index.ts                    |   1 +
 .../react-doctor/src/cli/utils/constants.ts   |   9 ++
 .../src/cli/utils/scan-result-cache.ts        | 152 +++++++++++++++++-
 .../tests/scan-result-cache.test.ts           | 127 ++++++++++++++-
 5 files changed, 288 insertions(+), 6 deletions(-)
 create mode 100644 .changeset/perf-dirty-tree-cache-key.md

diff --git a/.changeset/perf-dirty-tree-cache-key.md b/.changeset/perf-dirty-tree-cache-key.md
new file mode 100644
index 0000000000..836618ea37
--- /dev/null
+++ b/.changeset/perf-dirty-tree-cache-key.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": patch
+---
+
+Instant reruns now also work with uncommitted changes: the whole-repo scan-result cache no longer requires a clean worktree — it keys on the exact dirty state (every modified, staged, renamed, deleted, and untracked path plus a hash of its content), so rescanning the same work-in-progress tree hits the cache while any edit still invalidates it.
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index b36eced076..ee613d5181 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -87,6 +87,7 @@ export * from "./utils/dedupe-diagnostics.js";
 export * from "./utils/define-config.js";
 export * from "./utils/detect-ai-training-environment.js";
 export * from "./utils/group-by.js";
+export * from "./utils/hash-file-contents.js";
 export * from "./utils/has-published-fix-recipe.js";
 export * from "./utils/is-errno-exception.js";
 export * from "./utils/is-large-minified-file.js";
diff --git a/packages/react-doctor/src/cli/utils/constants.ts b/packages/react-doctor/src/cli/utils/constants.ts
index ff9084a630..66f8263c40 100644
--- a/packages/react-doctor/src/cli/utils/constants.ts
+++ b/packages/react-doctor/src/cli/utils/constants.ts
@@ -30,6 +30,15 @@ export const BASELINE_FILES_TEMP_DIR_PREFIX = "react-doctor-baseline-";
 export const SCAN_RESULT_CACHE_SCHEMA_VERSION = 3;
 export const SCAN_RESULT_CACHE_MAX_ENTRY_COUNT = 20;
 export const CACHE_FILENAME_HASH_LENGTH_CHARS = 16;
+// The dirty-worktree cache-key fingerprint content-hashes every path `git
+// status` reports; past this many entries the hashing could cost more than a
+// cache hit saves, so the key builder bails to null (cache off) — the same
+// worst case as the old clean-tree-only gate.
+export const SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT = 300;
+// Dirty files larger than this are fingerprinted by `mtimeMs:size` (the same
+// stat identity `computeConfigFingerprint` trusts for config files) instead of
+// a content hash, bounding the key builder's read cost and memory.
+export const SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 
 // Stdout cap for `runGit` (git-hook-shared.ts). Node's default `maxBuffer`
 // is 1 MiB, and `git ls-files -v` alone exceeds that on repos with ~15-25k
diff --git a/packages/react-doctor/src/cli/utils/scan-result-cache.ts b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
index 9fdeb42a77..4d416d8799 100644
--- a/packages/react-doctor/src/cli/utils/scan-result-cache.ts
+++ b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
@@ -3,7 +3,11 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
-import { computeConfigFingerprint, resolveLintBatchOrdering } from "@react-doctor/core";
+import {
+  computeConfigFingerprint,
+  hashFileContents,
+  resolveLintBatchOrdering,
+} from "@react-doctor/core";
 import type {
   Diagnostic,
   InspectOutput,
@@ -14,7 +18,9 @@ import type {
 } from "@react-doctor/core";
 import {
   CACHE_FILENAME_HASH_LENGTH_CHARS,
+  SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT,
   SCAN_RESULT_CACHE_MAX_ENTRY_COUNT,
+  SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES,
   SCAN_RESULT_CACHE_SCHEMA_VERSION,
 } from "./constants.js";
 import { isRecord, runGit } from "./git-hook-shared.js";
@@ -135,9 +141,140 @@ const hashString = (value: string): string => crypto.createHash("sha1").update(v
 const readHeadSha = (projectDirectory: string): string | null =>
   runGit(projectDirectory, ["rev-parse", "HEAD"]);
 
-const isWorktreeClean = (projectDirectory: string): boolean => {
-  const status = runGit(projectDirectory, ["status", "--porcelain=v1", "--untracked-files=normal"]);
-  return status !== null && status.length === 0;
+interface WorktreeStatusEntry {
+  readonly statusCode: string;
+  readonly path: string;
+  readonly originPath?: string;
+}
+
+interface WorktreeDirtyEntry extends WorktreeStatusEntry {
+  readonly contentFingerprint: string;
+}
+
+const parseWorktreeStatusRecords = (statusOutput: string): WorktreeStatusEntry[] | null => {
+  const entries: WorktreeStatusEntry[] = [];
+  const tokens = statusOutput.split("\0");
+  for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
+    let record = tokens[tokenIndex];
+    if (record.length === 0) continue;
+    // HACK: `runGit` trims subprocess output, which strips the leading space
+    // of the FIRST record's two-character status code (e.g. " M"). A valid
+    // porcelain v1 record always has the separator space at index 2, and X/Y
+    // are never both spaces, so a first record missing that separator lost
+    // exactly one leading space — restore it. Any later malformed record
+    // means the parse desynced: bail rather than fingerprint garbage.
+    if (record.length < 3 || record[2] !== " ") {
+      if (tokenIndex !== 0) return null;
+      record = ` ${record}`;
+    }
+    if (record.length < 4 || record[2] !== " ") return null;
+    const statusCode = record.slice(0, 2);
+    const recordPath = record.slice(3);
+    if (statusCode.includes("R") || statusCode.includes("C")) {
+      // Rename/copy records carry a second NUL-terminated field: the origin
+      // path (`XY to NUL from NUL`).
+      tokenIndex += 1;
+      const originPath: string | undefined = tokens[tokenIndex];
+      if (originPath === undefined || originPath.length === 0) return null;
+      entries.push({ statusCode, path: recordPath, originPath });
+      continue;
+    }
+    entries.push({ statusCode, path: recordPath });
+  }
+  return entries;
+};
+
+const buildDirtyPathContentFingerprint = (
+  absolutePath: string,
+  statusCode: string,
+): string | null => {
+  let stats: fs.Stats;
+  try {
+    stats = fs.lstatSync(absolutePath);
+  } catch {
+    // A deleted path has no content to hash; the status code in the entry
+    // already distinguishes a deletion from every other state at that path.
+    return statusCode.includes("D") ? "deleted" : null;
+  }
+  if (stats.isSymbolicLink()) {
+    try {
+      return `link:${fs.readlinkSync(absolutePath)}`;
+    } catch {
+      return null;
+    }
+  }
+  // A non-regular file (a dirty submodule shows as a directory) has no
+  // cheaply-hashable content — bail so the cache stays off rather than risk
+  // serving a stale payload for an unfingerprintable state.
+  if (!stats.isFile()) return null;
+  if (stats.size > SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES) {
+    return `stat:${stats.mtimeMs}:${stats.size}`;
+  }
+  return hashFileContents(absolutePath);
+};
+
+// Fingerprints every divergence of the worktree from HEAD as
+// (status code, path[, origin path], content fingerprint), so identical dirty
+// states key identically and any content or index change shifts the key.
+// Returns [] for a clean tree and null when the state cannot be fingerprinted
+// (git failure, oversized dirty set, unfingerprintable path) — the caller
+// treats null exactly like the old dirty-tree bail: cache off.
+const buildWorktreeFingerprint = (
+  projectDirectory: string,
+): ReadonlyArray<WorktreeDirtyEntry> | null => {
+  const statusOutput = runGit(projectDirectory, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    // `all` expands untracked directories into their contained files so each
+    // one is content-fingerprinted; the entry-count bound below caps the cost.
+    "--untracked-files=all",
+  ]);
+  if (statusOutput === null) return null;
+  if (statusOutput.length === 0) return [];
+  const statusEntries = parseWorktreeStatusRecords(statusOutput);
+  if (statusEntries === null) return null;
+  if (statusEntries.length > SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT) return null;
+  // Porcelain paths are relative to the repository root, not the (possibly
+  // nested workspace-member) project directory.
+  const repositoryRoot = runGit(projectDirectory, ["rev-parse", "--show-toplevel"]);
+  if (repositoryRoot === null) return null;
+  const dirtyEntries: WorktreeDirtyEntry[] = [];
+  for (const statusEntry of statusEntries) {
+    const contentFingerprint = buildDirtyPathContentFingerprint(
+      path.join(repositoryRoot, statusEntry.path),
+      statusEntry.statusCode,
+    );
+    if (contentFingerprint === null) return null;
+    dirtyEntries.push({ ...statusEntry, contentFingerprint });
+  }
+  // Codepoint compare (not localeCompare) so the ordering — and therefore the
+  // key — never varies with the process locale or ICU version.
+  return dirtyEntries.sort((firstEntry, secondEntry) => {
+    const firstSortKey = `${firstEntry.path}
${firstEntry.statusCode}`;
+    const secondSortKey = `${secondEntry.path}
${secondEntry.statusCode}`;
+    return firstSortKey < secondSortKey ? -1 : firstSortKey > secondSortKey ? 1 : 0;
+  });
+};
+
+const DOTENV_FILE_NAME_PATTERN = /^\.env(\.|$)/;
+
+// The security scan reads dotenv files even when they're gitignored — a state
+// `git status` can never surface — so their stat identity is keyed explicitly,
+// the same coverage `computeConfigFingerprint` gives gitignored config files.
+const resolveDotenvFingerprint = (projectDirectory: string): ReadonlyArray<string> => {
+  try {
+    return fs
+      .readdirSync(projectDirectory)
+      .filter((entryName) => DOTENV_FILE_NAME_PATTERN.test(entryName))
+      .sort()
+      .map(
+        (entryName) =>
+          `${entryName}=${fileFingerprint(path.join(projectDirectory, entryName)) ?? "unreadable"}`,
+      );
+  } catch {
+    return [];
+  }
 };
 
 const hasHiddenTrackedFileState = (projectDirectory: string): boolean => {
@@ -233,8 +370,11 @@ const resolveToolchainFingerprint = (nodeBinaryPath: string | null): ReadonlyArr
 
 export const buildScanResultCacheKey = (input: ScanResultCacheKeyInput): string | null => {
   if (isScanResultCacheDisabled()) return null;
-  if (!isWorktreeClean(input.projectDirectory)) return null;
+  // Assume-unchanged / skip-worktree hide tracked-file state from `git
+  // status`, so no fingerprint built from it can see those changes.
   if (hasHiddenTrackedFileState(input.projectDirectory)) return null;
+  const worktreeFingerprint = buildWorktreeFingerprint(input.projectDirectory);
+  if (worktreeFingerprint === null) return null;
   const headSha = readHeadSha(input.projectDirectory);
   if (headSha === null) return null;
   const userConfigJson = stringifyStableJson(input.userConfig);
@@ -243,6 +383,8 @@ export const buildScanResultCacheKey = (input: ScanResultCacheKeyInput): string
     schemaVersion: SCAN_RESULT_CACHE_SCHEMA_VERSION,
     projectIdentity: resolveProjectIdentity(input.projectDirectory),
     headSha,
+    worktreeFingerprint,
+    dotenvFingerprint: resolveDotenvFingerprint(input.projectDirectory),
     reactDoctorVersion: input.version,
     nodeVersion: process.version,
     toolchainFingerprint: resolveToolchainFingerprint(input.nodeBinaryPath),
diff --git a/packages/react-doctor/tests/scan-result-cache.test.ts b/packages/react-doctor/tests/scan-result-cache.test.ts
index bd8cef37e4..bb03a5c6e7 100644
--- a/packages/react-doctor/tests/scan-result-cache.test.ts
+++ b/packages/react-doctor/tests/scan-result-cache.test.ts
@@ -11,6 +11,7 @@ import {
   shouldStoreScanPayload,
   type CachedScanPayload,
 } from "../src/cli/utils/scan-result-cache.js";
+import { SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT } from "../src/cli/utils/constants.js";
 import { runGit } from "../src/cli/utils/git-hook-shared.js";
 import { VERSION } from "../src/cli/utils/version.js";
 import { commitAll, initGitRepo, setupReactProject } from "./regressions/_helpers.js";
@@ -187,7 +188,10 @@ describe("scan result cache", () => {
       path.join(projectDirectory, "doctor.config.json"),
       JSON.stringify({ rules: {} }),
     );
-    expect(cacheKey(projectDirectory, options)).toBeNull();
+    // An uncommitted config no longer bails the key — the dirty-worktree
+    // fingerprint folds it in, so the key exists but differs from clean.
+    expect(cacheKey(projectDirectory, options)).not.toBeNull();
+    expect(cacheKey(projectDirectory, options)).not.toBe(originalKey);
 
     commitAll(projectDirectory, "config");
     const configCommitKey = cacheKey(projectDirectory, options);
@@ -280,6 +284,127 @@ describe("scan result cache", () => {
     expect(output?.length).toBe(outputSizeChars);
   });
 
+  describe("dirty worktree fingerprint", () => {
+    const setupCleanProject = (caseId: string): string => {
+      const projectDirectory = setupReactProject(tempDirectory, caseId, {
+        files: { "src/App.tsx": "export const App = () => <div />;\n" },
+      });
+      initGitRepo(projectDirectory, { commit: true });
+      return projectDirectory;
+    };
+
+    it("keys a clean tree identically across runs", () => {
+      const projectDirectory = setupCleanProject("clean-stable");
+      const firstKey = cacheKey(projectDirectory, baseOptions());
+      expect(firstKey).not.toBeNull();
+      expect(cacheKey(projectDirectory, baseOptions())).toBe(firstKey);
+    });
+
+    it("keys an untracked file distinctly from clean, stably across identical states", () => {
+      const projectDirectory = setupCleanProject("untracked");
+      const cleanKey = cacheKey(projectDirectory, baseOptions());
+      fs.writeFileSync(path.join(projectDirectory, "scratch.txt"), "x\n");
+      const dirtyKey = cacheKey(projectDirectory, baseOptions());
+      expect(dirtyKey).not.toBeNull();
+      expect(dirtyKey).not.toBe(cleanKey);
+      expect(cacheKey(projectDirectory, baseOptions())).toBe(dirtyKey);
+    });
+
+    it("misses when dirty content is edited, and rejoins the clean key when reverted", () => {
+      const projectDirectory = setupCleanProject("edited");
+      const cleanKey = cacheKey(projectDirectory, baseOptions());
+      const appPath = path.join(projectDirectory, "src", "App.tsx");
+      const committedSource = fs.readFileSync(appPath, "utf8");
+      fs.writeFileSync(appPath, "export const App = () => <main />;\n");
+      const firstDirtyKey = cacheKey(projectDirectory, baseOptions());
+      expect(firstDirtyKey).not.toBeNull();
+      expect(firstDirtyKey).not.toBe(cleanKey);
+      fs.writeFileSync(appPath, "export const App = () => <section />;\n");
+      const secondDirtyKey = cacheKey(projectDirectory, baseOptions());
+      expect(secondDirtyKey).not.toBe(firstDirtyKey);
+      expect(secondDirtyKey).not.toBe(cleanKey);
+      fs.writeFileSync(appPath, committedSource);
+      expect(cacheKey(projectDirectory, baseOptions())).toBe(cleanKey);
+    });
+
+    it("keys staged and unstaged states of the same content differently", () => {
+      const projectDirectory = setupCleanProject("staged");
+      fs.writeFileSync(
+        path.join(projectDirectory, "src", "App.tsx"),
+        "export const App = () => <main />;\n",
+      );
+      const unstagedKey = cacheKey(projectDirectory, baseOptions());
+      spawnSync("git", ["add", "src/App.tsx"], { cwd: projectDirectory });
+      const stagedKey = cacheKey(projectDirectory, baseOptions());
+      expect(unstagedKey).not.toBeNull();
+      expect(stagedKey).not.toBeNull();
+      expect(stagedKey).not.toBe(unstagedKey);
+    });
+
+    it("keys a deleted file distinctly from clean and from a modified one", () => {
+      const projectDirectory = setupCleanProject("deleted");
+      const cleanKey = cacheKey(projectDirectory, baseOptions());
+      const appPath = path.join(projectDirectory, "src", "App.tsx");
+      fs.writeFileSync(appPath, "export const App = () => <main />;\n");
+      const modifiedKey = cacheKey(projectDirectory, baseOptions());
+      fs.rmSync(appPath);
+      const deletedKey = cacheKey(projectDirectory, baseOptions());
+      expect(deletedKey).not.toBeNull();
+      expect(deletedKey).not.toBe(cleanKey);
+      expect(deletedKey).not.toBe(modifiedKey);
+      expect(cacheKey(projectDirectory, baseOptions())).toBe(deletedKey);
+    });
+
+    it("parses rename records (including paths with spaces) into a stable key", () => {
+      const projectDirectory = setupCleanProject("renamed");
+      const cleanKey = cacheKey(projectDirectory, baseOptions());
+      spawnSync("git", ["mv", "src/App.tsx", "src/My App.tsx"], { cwd: projectDirectory });
+      const renamedKey = cacheKey(projectDirectory, baseOptions());
+      expect(renamedKey).not.toBeNull();
+      expect(renamedKey).not.toBe(cleanKey);
+      expect(cacheKey(projectDirectory, baseOptions())).toBe(renamedKey);
+    });
+
+    it("fingerprints files inside untracked directories individually", () => {
+      const projectDirectory = setupCleanProject("untracked-dir");
+      fs.mkdirSync(path.join(projectDirectory, "notes"));
+      fs.writeFileSync(path.join(projectDirectory, "notes", "todo.txt"), "a\n");
+      const firstKey = cacheKey(projectDirectory, baseOptions());
+      expect(firstKey).not.toBeNull();
+      fs.writeFileSync(path.join(projectDirectory, "notes", "todo.txt"), "b\n");
+      expect(cacheKey(projectDirectory, baseOptions())).not.toBe(firstKey);
+    });
+
+    it("bails to null when the dirty set exceeds the entry bound", () => {
+      const projectDirectory = setupCleanProject("oversized");
+      const scratchDirectory = path.join(projectDirectory, "scratch");
+      fs.mkdirSync(scratchDirectory);
+      for (
+        let fileIndex = 0;
+        fileIndex <= SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT;
+        fileIndex += 1
+      ) {
+        fs.writeFileSync(path.join(scratchDirectory, `file-${fileIndex}.txt`), String(fileIndex));
+      }
+      expect(cacheKey(projectDirectory, baseOptions())).toBeNull();
+    });
+
+    it("keys gitignored dotenv files the security scan reads", () => {
+      const projectDirectory = setupReactProject(tempDirectory, "dotenv", {
+        files: {
+          "src/App.tsx": "export const App = () => <div />;\n",
+          ".gitignore": ".env\n",
+          ".env": "API_KEY=first\n",
+        },
+      });
+      initGitRepo(projectDirectory, { commit: true });
+      const firstKey = cacheKey(projectDirectory, baseOptions());
+      expect(firstKey).not.toBeNull();
+      fs.writeFileSync(path.join(projectDirectory, ".env"), "API_KEY=second-value\n");
+      expect(cacheKey(projectDirectory, baseOptions())).not.toBe(firstKey);
+    });
+  });
+
   it("reuses diagnostics when rerendering with verbose enabled", async () => {
     const projectDirectory = setupReactProject(tempDirectory, "verbose", {
       files: { "src/App.tsx": "export const App = () => <div />;\n" },

From 20d81f6f26dc8f0562118076f835da2468591d5f Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Fri, 3 Jul 2026 20:58:27 -0500
Subject: [PATCH 19/33] fix(core): harden the dead-code cache key against
 version and input-list drift (#1056)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Addresses the two review findings on #1053: the fingerprint's extension and
manifest lists are now imported from a new dependency-free
deslop-js/analyzed-inputs subpath (single source of truth with the analyzer's
own readers — the hand-copies were already missing ng-package.json and
pnpm-workspace.yml), and the core package version joins the key so an
upgrade invalidates post-processed cached diagnostics.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .../perf-dead-code-cache-key-hardening.md     |  6 ++
 packages/core/src/check-dead-code.ts          |  2 +
 packages/core/src/constants.ts                |  7 ++
 .../src/dead-code/dead-code-result-cache.ts   | 63 ++++++--------
 .../core/tests/dead-code-result-cache.test.ts | 82 +++++++++++++++++++
 packages/core/vite.config.ts                  | 12 +++
 packages/deslop-js/package.json               | 10 +++
 packages/deslop-js/src/analyzed-inputs.ts     |  7 ++
 packages/deslop-js/src/collect/workspaces.ts  |  8 +-
 packages/deslop-js/src/constants.ts           | 46 +++++++++++
 .../deslop-js/src/utils/find-monorepo-root.ts | 18 +---
 packages/deslop-js/vite.config.ts             |  2 +-
 12 files changed, 200 insertions(+), 63 deletions(-)
 create mode 100644 .changeset/perf-dead-code-cache-key-hardening.md
 create mode 100644 packages/deslop-js/src/analyzed-inputs.ts

diff --git a/.changeset/perf-dead-code-cache-key-hardening.md b/.changeset/perf-dead-code-cache-key-hardening.md
new file mode 100644
index 0000000000..5b16d7a4e1
--- /dev/null
+++ b/.changeset/perf-dead-code-cache-key-hardening.md
@@ -0,0 +1,6 @@
+---
+"react-doctor": patch
+"deslop-js": patch
+---
+
+Hardened the dead-code result cache key against two silent-staleness classes. The fingerprinted extension and manifest name lists are now imported from `deslop-js/analyzed-inputs` — a new dependency-free subpath export assembled from the same constants deslop's own readers consume — so a deslop upgrade that widens its walk can never under-invalidate the cache. And the key now includes `@react-doctor/core`'s own version, so upgrading react-doctor re-analyzes instead of replaying cached diagnostics shaped by an older core's post-processing. The cache schema-version constant remains for cache-format changes only.
diff --git a/packages/core/src/check-dead-code.ts b/packages/core/src/check-dead-code.ts
index 63db54fea6..827b945ab4 100644
--- a/packages/core/src/check-dead-code.ts
+++ b/packages/core/src/check-dead-code.ts
@@ -13,6 +13,7 @@ import {
 } from "./dead-code/dead-code-result-cache.js";
 import { withDeadCodeWorkerSlot } from "./dead-code/dead-code-worker-slots.js";
 import {
+  CORE_PACKAGE_VERSION,
   DEAD_CODE_WORKER_MAX_OLD_SPACE_MB,
   DEAD_CODE_WORKER_TIMEOUT_MS,
   MILLISECONDS_PER_SECOND,
@@ -534,6 +535,7 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
         ignorePatterns,
         tsConfigPath,
         deslopJsModuleSpecifier,
+        coreVersion: CORE_PACKAGE_VERSION,
       })
     : null;
   if (cacheKey !== null) {
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index 5b94f085c9..92fb8e693e 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -631,6 +631,13 @@ export const FILE_LINT_CACHE_MAX_FILE_COUNT = 50_000;
 // fallback when a project has no `node_modules` to host `.cache/react-doctor`.
 export const CACHE_FILENAME_HASH_LENGTH_CHARS = 16;
 
+// This package's own version, inlined at build time (`vite.config.ts` `env`)
+// the same way the CLI inlines `VERSION`; running from source (tests, dev)
+// falls back to "0.0.0". Cache keys include it because cached diagnostics
+// carry core's POST-PROCESSING (message text, toolchain-dependency filtering),
+// so an upgrade must never replay entries shaped by an older core.
+export const CORE_PACKAGE_VERSION = process.env.REACT_DOCTOR_CORE_VERSION ?? "0.0.0";
+
 // Whole-project dead-code result cache (`dead-code/dead-code-result-cache.ts`).
 // Replays deslop's diagnostics — skipping the analysis worker entirely — when
 // nothing the analysis reads has changed since the stored run.
diff --git a/packages/core/src/dead-code/dead-code-result-cache.ts b/packages/core/src/dead-code/dead-code-result-cache.ts
index 63340f787f..bba528edc9 100644
--- a/packages/core/src/dead-code/dead-code-result-cache.ts
+++ b/packages/core/src/dead-code/dead-code-result-cache.ts
@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import * as Schema from "effect/Schema";
+import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analyzed-inputs";
 import type { Diagnostic } from "../types/index.js";
 import { DEAD_CODE_CACHE_FILENAME, DEAD_CODE_CACHE_SCHEMA_VERSION } from "../constants.js";
 import { Diagnostic as DiagnosticSchema } from "../schemas.js";
@@ -37,6 +38,13 @@ interface DeadCodeCacheKeyInput {
   readonly ignorePatterns: ReadonlyArray<string>;
   readonly tsConfigPath: string | undefined;
   readonly deslopJsModuleSpecifier: string;
+  /**
+   * `@react-doctor/core`'s own version (`CORE_PACKAGE_VERSION`). Cached
+   * entries store diagnostics AFTER `checkDeadCode`'s post-processing
+   * (message text, toolchain-dependency filtering), so a core upgrade must
+   * invalidate them even when the analyzed tree is unchanged.
+   */
+  readonly coreVersion: string;
 }
 
 interface PersistedDeadCodeResultCache {
@@ -45,46 +53,24 @@ interface PersistedDeadCodeResultCache {
   readonly diagnostics: ReadonlyArray<unknown>;
 }
 
-// The extensions deslop's import-graph walk parses (its DEFAULT_EXTENSIONS),
-// so an edit to any file the graph can reach changes the key.
-const ANALYZED_FILE_EXTENSIONS = new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mts",
-  ".mjs",
-  ".cts",
-  ".cjs",
-  ".mdx",
-  ".astro",
-  ".graphql",
-  ".gql",
-  ".css",
-  ".scss",
-  ".vue",
-  ".svelte",
-]);
+// The fingerprinted file sets come straight from the analyzer package
+// (`deslop-js/analyzed-inputs`): the extensions its import-graph walk parses
+// and every manifest/lockfile/.gitignore name its analysis reads. The worker
+// resolves deslop-js from the same install, so these constants are exactly
+// what the analysis will use — and a deslop version bump also rotates the key
+// via the `deslopVersion` field (belt and suspenders).
+const ANALYZED_FILE_EXTENSIONS = new Set(DEFAULT_EXTENSIONS);
+
+// Beyond what deslop itself reads, the dead-code PASS also depends on:
+// `knip.json` (read core-side by `collect-dead-code-patterns.ts` to derive
+// the entry/ignore patterns) and `deno.lock` (an extra proxy for installed
+// `node_modules` metadata — deslop reads installed packages' bin/peer fields,
+// which only change through an install that rewrites a lockfile).
+const CORE_SIDE_MANIFEST_NAMES = ["knip.json", "deno.lock"];
 
-// Non-source files deslop's entry/workspace/dependency analysis reads:
-// manifests (workspace layout, dependency declarations, knip/expo config),
-// lockfiles (the proxy for installed `node_modules` metadata — deslop reads
-// installed packages' bin/peer fields, which only change through an install
-// that rewrites the lockfile), and `.gitignore` files at every level (deslop
-// consults git's ignore state for its walk).
 const ANALYZED_MANIFEST_NAMES = new Set([
-  "package.json",
-  "knip.json",
-  "app.json",
-  "pnpm-workspace.yaml",
-  "lerna.json",
-  "pnpm-lock.yaml",
-  "package-lock.json",
-  "yarn.lock",
-  "bun.lock",
-  "bun.lockb",
-  "deno.lock",
-  ".gitignore",
+  ...ANALYZED_MANIFEST_FILENAMES,
+  ...CORE_SIDE_MANIFEST_NAMES,
 ]);
 
 // tsconfig/jsconfig files anywhere in the tree — path-alias resolution reads
@@ -134,6 +120,7 @@ export const computeDeadCodeCacheKey = (input: DeadCodeCacheKeyInput): string =>
     .update(
       JSON.stringify({
         schemaVersion: DEAD_CODE_CACHE_SCHEMA_VERSION,
+        coreVersion: input.coreVersion,
         deslopVersion: resolveDeslopVersion(),
         deslopJsModuleSpecifier: input.deslopJsModuleSpecifier,
         entryPatterns: input.entryPatterns,
diff --git a/packages/core/tests/dead-code-result-cache.test.ts b/packages/core/tests/dead-code-result-cache.test.ts
index 74c4b9bc05..561aad42b8 100644
--- a/packages/core/tests/dead-code-result-cache.test.ts
+++ b/packages/core/tests/dead-code-result-cache.test.ts
@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
 import * as Effect from "effect/Effect";
+import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analyzed-inputs";
 import { afterAll, beforeAll, describe, expect, it } from "vite-plus/test";
 import type { Diagnostic } from "../src/types/index.js";
 import { checkDeadCode } from "../src/check-dead-code.js";
@@ -53,6 +54,7 @@ const keyInput = (projectDirectory: string) => ({
   ignorePatterns: [],
   tsConfigPath: undefined,
   deslopJsModuleSpecifier: "deslop-js",
+  coreVersion: "0.0.0",
 });
 
 interface SpyWorker {
@@ -160,6 +162,86 @@ describe("computeDeadCodeCacheKey", () => {
     fs.writeFileSync(path.join(directory, "scratch.txt"), "not part of the graph\n");
     expect(computeDeadCodeCacheKey(keyInput(directory))).toBe(keyBefore);
   });
+
+  it("changes when the core package version changes", () => {
+    const directory = setupProject("key-core-version", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    expect(computeDeadCodeCacheKey({ ...keyInput(directory), coreVersion: "99.0.0" })).not.toBe(
+      computeDeadCodeCacheKey(keyInput(directory)),
+    );
+  });
+});
+
+describe("fingerprinted file sets (imported from deslop-js/analyzed-inputs)", () => {
+  it("fingerprints a file for every extension deslop's walk parses", () => {
+    const directory = setupProject("key-extension-coverage", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    for (const extension of DEFAULT_EXTENSIONS) {
+      const probePath = path.join(directory, "probe", `probe${extension}`);
+      fs.mkdirSync(path.dirname(probePath), { recursive: true });
+      fs.writeFileSync(probePath, "probe\n");
+      expect(computeDeadCodeCacheKey(keyInput(directory)), extension).not.toBe(keyBefore);
+      fs.rmSync(probePath);
+    }
+  });
+
+  it("fingerprints every manifest name deslop's analysis reads", () => {
+    const directory = setupProject("key-manifest-coverage", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
+    for (const manifestName of ANALYZED_MANIFEST_FILENAMES) {
+      const probePath = path.join(directory, "probe", manifestName);
+      fs.mkdirSync(path.dirname(probePath), { recursive: true });
+      fs.writeFileSync(probePath, "probe\n");
+      expect(computeDeadCodeCacheKey(keyInput(directory)), manifestName).not.toBe(keyBefore);
+      fs.rmSync(probePath);
+    }
+  });
+
+  // Not a redundant copy: a NEW extension or manifest in a deslop-js upgrade
+  // widens what the cache fingerprints, so it must land here as a conscious,
+  // reviewed choice rather than silently.
+  it("matches the reviewed set snapshots", () => {
+    expect([...DEFAULT_EXTENSIONS].sort()).toEqual([
+      ".astro",
+      ".cjs",
+      ".css",
+      ".cts",
+      ".gql",
+      ".graphql",
+      ".js",
+      ".jsx",
+      ".mdx",
+      ".mjs",
+      ".mts",
+      ".scss",
+      ".svelte",
+      ".ts",
+      ".tsx",
+      ".vue",
+    ]);
+    expect([...ANALYZED_MANIFEST_FILENAMES].sort()).toEqual([
+      ".gitignore",
+      "app.json",
+      "bun.lock",
+      "bun.lockb",
+      "lerna.json",
+      "ng-package.json",
+      "nx.json",
+      "package-lock.json",
+      "package.json",
+      "pnpm-lock.yaml",
+      "pnpm-workspace.yaml",
+      "pnpm-workspace.yml",
+      "rush.json",
+      "turbo.json",
+      "yarn.lock",
+    ]);
+  });
 });
 
 describe("checkDeadCode result cache", () => {
diff --git a/packages/core/vite.config.ts b/packages/core/vite.config.ts
index fcbee2ca9b..d887fdbf31 100644
--- a/packages/core/vite.config.ts
+++ b/packages/core/vite.config.ts
@@ -1,5 +1,14 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import { defineConfig } from "vite-plus";
 
+const packageRoot = path.dirname(fileURLToPath(import.meta.url));
+
+const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")) as {
+  version: string;
+};
+
 export default defineConfig({
   pack: [
     {
@@ -20,6 +29,9 @@ export default defineConfig({
       target: "node20",
       platform: "node",
       fixedExtension: false,
+      env: {
+        REACT_DOCTOR_CORE_VERSION: packageJson.version,
+      },
     },
   ],
   test: {
diff --git a/packages/deslop-js/package.json b/packages/deslop-js/package.json
index 58f6dfacc5..031ac61100 100644
--- a/packages/deslop-js/package.json
+++ b/packages/deslop-js/package.json
@@ -47,6 +47,16 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./analyzed-inputs": {
+      "import": {
+        "types": "./dist/analyzed-inputs.d.mts",
+        "default": "./dist/analyzed-inputs.mjs"
+      },
+      "require": {
+        "types": "./dist/analyzed-inputs.d.cts",
+        "default": "./dist/analyzed-inputs.cjs"
+      }
     }
   },
   "publishConfig": {
diff --git a/packages/deslop-js/src/analyzed-inputs.ts b/packages/deslop-js/src/analyzed-inputs.ts
new file mode 100644
index 0000000000..882ad34249
--- /dev/null
+++ b/packages/deslop-js/src/analyzed-inputs.ts
@@ -0,0 +1,7 @@
+// The canonical "what does an analysis pass read?" contract, published as the
+// `deslop-js/analyzed-inputs` subpath so external result caches (react-doctor's
+// dead-code cache) can fingerprint exactly the files a pass depends on. Kept
+// as a dedicated dependency-free entry: the package root eagerly loads
+// `typescript` and the native oxc bindings, which a fingerprinting caller must
+// never pay for.
+export { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "./constants.js";
diff --git a/packages/deslop-js/src/collect/workspaces.ts b/packages/deslop-js/src/collect/workspaces.ts
index 553812643e..bccc5d788b 100644
--- a/packages/deslop-js/src/collect/workspaces.ts
+++ b/packages/deslop-js/src/collect/workspaces.ts
@@ -1,6 +1,7 @@
 import { resolve, join, relative, dirname } from "node:path";
 import { readFileSync, existsSync, statSync } from "node:fs";
 import fg from "fast-glob";
+import { STANDALONE_PROJECT_LOCKFILES } from "../constants.js";
 import { extractReactRouterRouteModuleEntries } from "./parse.js";
 
 export interface WorkspacePackage {
@@ -70,13 +71,6 @@ export const resolveWorkspaces = (rootDir: string): WorkspaceDiscoveryResult =>
 
 const IMPLICIT_SUB_PROJECT_SEARCH_DEPTH = 3;
 
-const STANDALONE_PROJECT_LOCKFILES = [
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  "bun.lockb",
-];
-
 const isStandaloneProject = (directory: string): boolean =>
   STANDALONE_PROJECT_LOCKFILES.some((lockfile) => existsSync(join(directory, lockfile)));
 
diff --git a/packages/deslop-js/src/constants.ts b/packages/deslop-js/src/constants.ts
index 15bf0419e4..f58f4b277c 100644
--- a/packages/deslop-js/src/constants.ts
+++ b/packages/deslop-js/src/constants.ts
@@ -17,6 +17,52 @@ export const DEFAULT_EXTENSIONS = [
   ".svelte",
 ];
 
+export const STANDALONE_PROJECT_LOCKFILES = [
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+];
+
+export const MONOREPO_ROOT_MARKERS = [
+  "pnpm-workspace.yaml",
+  "pnpm-workspace.yml",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "rush.json",
+];
+
+export const LOCKFILE_MARKERS = [
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "package-lock.json",
+  "bun.lockb",
+  "bun.lock",
+];
+
+// Every non-source file name the analysis reads, assembled from the same
+// constants the readers consume (plus the names read individually by
+// `collect/workspaces.ts`, `collect/entries.ts`,
+// `collect/expo-config-plugin-entries.ts`, and — via `git check-ignore` —
+// `utils/collect-git-ignored-paths.ts`). Exported through
+// `deslop-js/analyzed-inputs` so external result caches can fingerprint
+// exactly the files a pass depends on; extend this list whenever a reader
+// starts consuming a new manifest name.
+export const ANALYZED_MANIFEST_FILENAMES = [
+  ...new Set([
+    "package.json",
+    "pnpm-workspace.yaml",
+    "lerna.json",
+    "app.json",
+    "ng-package.json",
+    ".gitignore",
+    ...STANDALONE_PROJECT_LOCKFILES,
+    ...MONOREPO_ROOT_MARKERS,
+    ...LOCKFILE_MARKERS,
+  ]),
+];
+
 export const HIDDEN_DIRECTORY_ALLOWLIST = [
   ".storybook",
   ".vitepress",
diff --git a/packages/deslop-js/src/utils/find-monorepo-root.ts b/packages/deslop-js/src/utils/find-monorepo-root.ts
index 28249d9131..9556f33ff3 100644
--- a/packages/deslop-js/src/utils/find-monorepo-root.ts
+++ b/packages/deslop-js/src/utils/find-monorepo-root.ts
@@ -1,22 +1,6 @@
 import { resolve, join, dirname } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
-
-const MONOREPO_ROOT_MARKERS = [
-  "pnpm-workspace.yaml",
-  "pnpm-workspace.yml",
-  "lerna.json",
-  "nx.json",
-  "turbo.json",
-  "rush.json",
-];
-
-const LOCKFILE_MARKERS = [
-  "pnpm-lock.yaml",
-  "yarn.lock",
-  "package-lock.json",
-  "bun.lockb",
-  "bun.lock",
-];
+import { LOCKFILE_MARKERS, MONOREPO_ROOT_MARKERS } from "../constants.js";
 
 const MAX_MONOREPO_WALK_DEPTH = 5;
 
diff --git a/packages/deslop-js/vite.config.ts b/packages/deslop-js/vite.config.ts
index a48e2cacd9..2f6ee062dd 100644
--- a/packages/deslop-js/vite.config.ts
+++ b/packages/deslop-js/vite.config.ts
@@ -3,7 +3,7 @@ import { defineConfig } from "vite-plus";
 export default defineConfig({
   pack: [
     {
-      entry: ["./src/index.ts"],
+      entry: ["./src/index.ts", "./src/analyzed-inputs.ts"],
       format: ["cjs", "esm"],
       dts: true,
       clean: true,

From ce4925008d37d7c86a234e6b9c7c2c3afe873405 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 00:16:06 -0500
Subject: [PATCH 20/33] perf(core): incremental dead-code analysis via a
 per-file summary cache (#1057)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Four cache layers validated by one stat walk (parse summaries, package
facts, file list, resolution map keyed on the file set) make changed-file
rescans re-parse only what changed; entries stay live every run (caching
them was proven unsound — bundler configs feed entry strings by content),
resolved on a worker thread so warm runs are entries-bound. Dead-code on
a 9k-file repo: ~8s full -> ~3.1-3.4s warm with byte-identical output.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .../perf-dead-code-incremental-cache.md       |   8 +
 packages/core/src/check-dead-code.ts          |  83 ++-
 packages/core/src/constants.ts                |   6 +
 packages/core/src/run-inspect.ts              |  21 +-
 packages/core/src/services/dead-code.ts       |  12 +
 packages/core/src/types/inspect.ts            |  10 +
 packages/core/tests/check-dead-code.test.ts   |  53 ++
 .../dead-code-discarded-passes-parity.test.ts |  11 +-
 .../core/tests/dead-code-result-cache.test.ts |  95 +++
 .../src/collect/entries-in-worker.ts          |  81 +++
 .../deslop-js/src/collect/entries-worker.ts   |  39 +
 .../deslop-js/src/collect/launch-worker.ts    |  20 +
 .../deslop-js/src/collect/parallel-parse.ts   |  22 +-
 packages/deslop-js/src/constants.ts           |   4 +
 packages/deslop-js/src/index.ts               | 130 +++-
 packages/deslop-js/src/report/exports.ts      |  18 +-
 packages/deslop-js/src/report/generate.ts     |   9 +-
 packages/deslop-js/src/report/packages.ts     | 234 ++++--
 packages/deslop-js/src/summary-cache.ts       | 688 ++++++++++++++++++
 packages/deslop-js/src/types.ts               |  23 +
 .../tests/helpers/analyze-in-subprocess.ts    |  10 +
 .../deslop-js/tests/summary-cache.test.ts     | 670 +++++++++++++++++
 packages/deslop-js/vite.config.ts             |   2 +-
 .../src/cli/utils/build-run-event.ts          |   7 +
 packages/react-doctor/src/inspect.ts          |  18 +
 .../tests/build-run-event.test.ts             |  15 +
 26 files changed, 2138 insertions(+), 151 deletions(-)
 create mode 100644 .changeset/perf-dead-code-incremental-cache.md
 create mode 100644 packages/deslop-js/src/collect/entries-in-worker.ts
 create mode 100644 packages/deslop-js/src/collect/entries-worker.ts
 create mode 100644 packages/deslop-js/src/collect/launch-worker.ts
 create mode 100644 packages/deslop-js/src/summary-cache.ts
 create mode 100644 packages/deslop-js/tests/helpers/analyze-in-subprocess.ts
 create mode 100644 packages/deslop-js/tests/summary-cache.test.ts

diff --git a/.changeset/perf-dead-code-incremental-cache.md b/.changeset/perf-dead-code-incremental-cache.md
new file mode 100644
index 0000000000..6f9e0e6c24
--- /dev/null
+++ b/.changeset/perf-dead-code-incremental-cache.md
@@ -0,0 +1,8 @@
+---
+"deslop-js": minor
+"react-doctor": patch
+---
+
+Dead-code analysis is now incremental across scans. deslop-js gains an opt-in `incrementalCachePath` config field: one stat walk per run (following directory symlinks, like the glob scans it stands in for) validates four independently keyed layers — per-file parse summaries (mtime+size), the collected file list, the module-resolution map (dropped whenever the file set or a bundler/tsconfig-like config changes, since resolution is file-set-dependent), and the per-file package-reference facts behind the unused-dependency content scans. The same walk also answers the stale-package file-discovery globs (config/docs/rescue/package.json/nx/tsconfig scans, verified byte-identical against fast-glob), so a cached run never re-walks the tree for them. Entry resolution deliberately stays live every run (it reads config/doc/sibling-source content no fingerprint can validate); on cached runs it moves to a dedicated worker thread so its filesystem work overlaps the main-thread analysis instead of serializing after it. Every layer fails open — corrupt, truncated, or version/config-mismatched stores degrade to a fresh computation, never a wrong result — writes are atomic and skipped when clean, and results are byte-identical to an uncached run. Unused-export detection also indexes re-export edges by source module, dropping an O(entry points × edges) scan that dominated the detector on large repos.
+
+react-doctor points the analysis worker at a per-project summary store next to the existing whole-result dead-code cache, so a changed-files rescan of a large repo re-parses only what changed (sentry, 9k files: ~8.0s → ~3.2s with 0-10 files edited; ~4.0s after adding a file; the cache-fill run costs the same as an uncached scan). The worker also stops running the discarded DRY-pattern redundancy detectors (`reportRedundancy: false`), which shrinks the summary store by dropping fields only those detectors read, and reports the cache outcome as `deadCode.summaryCacheHits` / `deadCode.summaryCacheMisses` in anonymized telemetry (absent whenever no analysis consulted the store). `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
diff --git a/packages/core/src/check-dead-code.ts b/packages/core/src/check-dead-code.ts
index 827b945ab4..9f643f971e 100644
--- a/packages/core/src/check-dead-code.ts
+++ b/packages/core/src/check-dead-code.ts
@@ -14,6 +14,7 @@ import {
 import { withDeadCodeWorkerSlot } from "./dead-code/dead-code-worker-slots.js";
 import {
   CORE_PACKAGE_VERSION,
+  DEAD_CODE_SUMMARY_CACHE_FILENAME,
   DEAD_CODE_WORKER_MAX_OLD_SPACE_MB,
   DEAD_CODE_WORKER_TIMEOUT_MS,
   MILLISECONDS_PER_SECOND,
@@ -65,12 +66,15 @@ interface CheckDeadCodeOptions {
    */
   readonly abortSignal?: AbortSignal;
   /**
-   * Whether to consult the whole-project dead-code result cache. Defaults
-   * OFF so direct callers (and existing tests) keep their fresh-analysis
-   * semantics; the `DeadCode` service passes the `DeadCodeResultCacheEnabled`
-   * Reference here. A hit replays the stored diagnostics without spawning
-   * the analysis worker; a fresh COMPLETE pass is stored on success (a
-   * crashed, timed-out, or aborted worker rejects before the store).
+   * Whether to consult the dead-code caches. Defaults OFF so direct callers
+   * (and existing tests) keep their fresh-analysis semantics; the `DeadCode`
+   * service passes the `DeadCodeResultCacheEnabled` Reference here. Gates
+   * both layers: the whole-project result cache (a hit replays the stored
+   * diagnostics without spawning the analysis worker; a fresh COMPLETE pass
+   * is stored on success — a crashed, timed-out, or aborted worker rejects
+   * before the store) and, on a miss, deslop's incremental summary cache
+   * inside the worker (per-file parse summaries so a changed-files re-analysis
+   * only re-parses what changed).
    */
   readonly cacheEnabled?: boolean;
   /**
@@ -79,6 +83,19 @@ interface CheckDeadCodeOptions {
    * distinguishes "no cache" from a miss.
    */
   readonly onCacheOutcome?: (didHitCache: boolean) => void;
+  /**
+   * Reports deslop's incremental summary-cache outcome (files served from
+   * cached parse summaries vs freshly parsed) once per ANALYSIS run. Not
+   * invoked on a whole-result cache hit (no analysis ran) or when caching is
+   * off (the worker analyzes without the incremental store), so the
+   * orchestrator's telemetry distinguishes "no cache" from a 0% hit rate.
+   */
+  readonly onSummaryCacheStats?: (stats: DeadCodeSummaryCacheStats) => void;
+}
+
+interface DeadCodeSummaryCacheStats {
+  readonly hits: number;
+  readonly misses: number;
 }
 
 interface DeadCodeWorkerInput {
@@ -89,6 +106,11 @@ interface DeadCodeWorkerInput {
   readonly deslopJsModuleSpecifier: string;
   /** Caps deslop's parse pool via `DESLOP_PARSE_CONCURRENCY` on the child env. */
   readonly parseConcurrency?: number;
+  /**
+   * `DeslopConfig.incrementalCachePath` for the worker's `analyze()` call.
+   * Omitted when caching is off — deslop then analyzes from scratch.
+   */
+  readonly incrementalCachePath?: string;
 }
 
 interface DeadCodeWorkerHandle {
@@ -126,6 +148,7 @@ interface DeadCodeWorkerResult {
   readonly unusedExports: ReadonlyArray<DeadCodeWorkerUnusedExport>;
   readonly unusedDependencies: ReadonlyArray<DeadCodeWorkerUnusedDependency>;
   readonly circularDependencies: ReadonlyArray<DeadCodeWorkerCircularDependency>;
+  readonly summaryCacheStats?: DeadCodeSummaryCacheStats;
 }
 
 interface DeadCodeWorkerError {
@@ -172,6 +195,14 @@ process.stdin.on("end", () => {
     circularDependencies: result.circularDependencies.map((cycle) => ({
       files: cycle.files,
     })),
+    ...(result.incrementalCacheStats
+      ? {
+          summaryCacheStats: {
+            hits: result.incrementalCacheStats.summaryHits,
+            misses: result.incrementalCacheStats.summaryMisses,
+          },
+        }
+      : {}),
   });
 
   const serializeError = (error) =>
@@ -195,6 +226,9 @@ process.stdin.on("end", () => {
         ...(workerInput.ignorePatterns.length > 0
           ? { ignorePatterns: workerInput.ignorePatterns }
           : {}),
+        ...(workerInput.incrementalCachePath
+          ? { incrementalCachePath: workerInput.incrementalCachePath }
+          : {}),
         // We consume only deslop's GRAPH-based findings (unusedFiles, unusedExports,
         // unusedDependencies, circularDependencies). Everything else deslop can compute
         // is pure wasted work for us, and it's the bulk of the runtime:
@@ -205,12 +239,18 @@ process.stdin.on("end", () => {
         //     are the single most expensive pass — duplicate-block detection alone was
         //     ~83s of a ~130s Sentry scan — so skipping them is an ~8.5x dead-code
         //     speedup on a large repo.
-        // Both are provably safe: the consumed graph findings are computed by their own
+        //   - reportRedundancy: the DRY-pattern detectors (duplicate types/constants,
+        //     simplifiable functions, identity wrappers, …) — ~120 ms of discarded
+        //     output per scan, and skipping them lets the incremental cache drop the
+        //     DRY-pattern summary fields (the largest slice of the cache file).
+        // All are provably safe: the consumed graph findings are computed by their own
         // detectors, independent of these passes (confirmed byte-identical on
-        // excalidraw + mui-material + sentry). tsConfigPath stays — the module resolver
-        // needs it for path-alias resolution in the import graph.
+        // excalidraw + mui-material + sentry; re-verified on sentry after the
+        // reportRedundancy flip). tsConfigPath stays — the module resolver needs it
+        // for path-alias resolution in the import graph.
         semantic: { enabled: false },
         reportCodeQuality: false,
+        reportRedundancy: false,
       };
       const result = await analyze(defineConfig(config));
       emit({ ok: true, result: normalizeResult(result) });
@@ -335,15 +375,25 @@ const parseCircularDependencies = (value: unknown): DeadCodeWorkerCircularDepend
   return circularDependencies;
 };
 
+// Telemetry-only, so malformed stats degrade to `undefined` instead of
+// rejecting the scan like the diagnostic fields above do.
+const parseSummaryCacheStats = (value: unknown): DeadCodeSummaryCacheStats | undefined => {
+  if (!isRecord(value)) return undefined;
+  if (typeof value.hits !== "number" || typeof value.misses !== "number") return undefined;
+  return { hits: value.hits, misses: value.misses };
+};
+
 const parseDeadCodeWorkerResult = (value: unknown): DeadCodeWorkerResult => {
   if (!isRecord(value)) {
     throw new Error("Dead-code worker returned an invalid result.");
   }
+  const summaryCacheStats = parseSummaryCacheStats(value.summaryCacheStats);
   return {
     unusedFiles: parseUnusedFiles(value.unusedFiles),
     unusedExports: parseUnusedExports(value.unusedExports),
     unusedDependencies: parseUnusedDependencies(value.unusedDependencies),
     circularDependencies: parseCircularDependencies(value.circularDependencies),
+    ...(summaryCacheStats ? { summaryCacheStats } : {}),
   };
 };
 
@@ -552,6 +602,17 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
   // cancelled), `Effect.tryPromise` aborts `options.abortSignal`, which its
   // `settle()` path turns into an immediate worker SIGKILL — rather than
   // orphaning the child until the in-worker timer expires.
+  // The incremental summary cache serves the case the whole-result cache just
+  // missed on: something changed, and the worker should only re-parse what
+  // changed. Same per-project cache directory, same `cacheEnabled` switch
+  // (`REACT_DOCTOR_NO_CACHE` / `REACT_DOCTOR_NO_DEAD_CODE_CACHE`); a
+  // whole-result hit above returns before this line, so it never touches the
+  // incremental store.
+  const incrementalCachePath =
+    options.cacheEnabled === true
+      ? path.join(resolveReactDoctorCacheDir(rootDirectory), DEAD_CODE_SUMMARY_CACHE_FILENAME)
+      : undefined;
+
   const spawnAndRun = (): Promise<unknown> => {
     const workerHandle = (options.createWorker ?? createDeadCodeWorker)({
       rootDirectory,
@@ -560,6 +621,7 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
       ignorePatterns,
       deslopJsModuleSpecifier,
       parseConcurrency: options.parseConcurrency,
+      incrementalCachePath,
     });
     return runDeadCodeWorkerWithTimeout(
       workerHandle,
@@ -577,6 +639,9 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
       ? await withDeadCodeWorkerSlot(spawnAndRun, options.abortSignal)
       : await spawnAndRun();
   const result = parseDeadCodeWorkerResult(rawResult);
+  if (result.summaryCacheStats !== undefined) {
+    options.onSummaryCacheStats?.(result.summaryCacheStats);
+  }
   const toRelative = (filePath: string): string => toRelativeFilePath(rootDirectory, filePath);
   const diagnostics: Diagnostic[] = [];
 
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index 92fb8e693e..a67785e85e 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -645,6 +645,12 @@ export const DEAD_CODE_CACHE_SCHEMA_VERSION = 1;
 
 export const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 
+// deslop's incremental analysis store (`DeslopConfig.incrementalCachePath`) —
+// per-file parse summaries + collect/resolution/package-fact layers, written
+// by the analysis WORKER for the changed-files case the whole-result cache
+// above can't serve. Lives in the same per-project cache directory.
+export const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
+
 // Plugin / rule / category identity for the diagnostics the supply-chain
 // check emits. `plugin: "socket"` keeps Socket findings visually distinct
 // from the `react-doctor` lint surface in the printed list and JSON report.
diff --git a/packages/core/src/run-inspect.ts b/packages/core/src/run-inspect.ts
index 8477d1d64c..5e07e34b18 100644
--- a/packages/core/src/run-inspect.ts
+++ b/packages/core/src/run-inspect.ts
@@ -248,6 +248,17 @@ export interface InspectOutput {
    * `deadCode.cacheHit`.
    */
   readonly deadCodeCacheHit: boolean | null;
+  /**
+   * deslop's incremental summary-cache outcome for this scan's dead-code
+   * ANALYSIS: collected files served from cached parse summaries vs freshly
+   * parsed. Both `null` whenever no analysis consulted the incremental store —
+   * a whole-result cache hit (no analysis ran), the cache off, dead-code
+   * skipped/disabled, or the pass discarded by a lint failure. Fed to the
+   * Sentry wide event as `deadCode.summaryCacheHits` /
+   * `deadCode.summaryCacheMisses`.
+   */
+  readonly deadCodeSummaryCacheHits: number | null;
+  readonly deadCodeSummaryCacheMisses: number | null;
   /**
    * Per-rule tallies of diagnostics the pipeline dropped because the user
    * explicitly silenced the rule (config off switches, per-path overrides,
@@ -686,6 +697,10 @@ export const runInspect = <HooksR = never>(
               onCacheOutcome: (didHitCache) => {
                 deadCodeCacheHit = didHitCache;
               },
+              onSummaryCacheStats: (stats) => {
+                deadCodeSummaryCacheHits = stats.hits;
+                deadCodeSummaryCacheMisses = stats.misses;
+              },
             })
             .pipe(
               Stream.catchTag("ReactDoctorError", (error: ReactDoctorError) =>
@@ -750,6 +765,8 @@ export const runInspect = <HooksR = never>(
     let lintCacheHitFileCount: number | null = null;
     let lintCacheTotalFileCount: number | null = null;
     let deadCodeCacheHit: boolean | null = null;
+    let deadCodeSummaryCacheHits: number | null = null;
+    let deadCodeSummaryCacheMisses: number | null = null;
 
     const baseLintStream = linterService
       .run({
@@ -1000,8 +1017,10 @@ export const runInspect = <HooksR = never>(
       lintCacheHitFileCount,
       lintCacheTotalFileCount,
       // Lint failure discards the dead-code pass entirely (see
-      // `deadCodeFailureState` above), so its cache outcome must not leak.
+      // `deadCodeFailureState` above), so its cache outcomes must not leak.
       deadCodeCacheHit: lintFailureState.didFail ? null : deadCodeCacheHit,
+      deadCodeSummaryCacheHits: lintFailureState.didFail ? null : deadCodeSummaryCacheHits,
+      deadCodeSummaryCacheMisses: lintFailureState.didFail ? null : deadCodeSummaryCacheMisses,
       suppressedRuleCounts: transform.summarizeSuppressions(),
     };
   }).pipe(
diff --git a/packages/core/src/services/dead-code.ts b/packages/core/src/services/dead-code.ts
index bc11366987..0ab7fe31b7 100644
--- a/packages/core/src/services/dead-code.ts
+++ b/packages/core/src/services/dead-code.ts
@@ -28,6 +28,17 @@ interface DeadCodeInput {
    * distinguishes "no cache" from a miss.
    */
   readonly onCacheOutcome?: (didHitCache: boolean) => void;
+  /**
+   * Reports deslop's incremental summary-cache outcome (cached vs freshly
+   * parsed file counts) when the analysis ran with the incremental store.
+   * Not invoked on a whole-result cache hit or when caching is off.
+   */
+  readonly onSummaryCacheStats?: (stats: DeadCodeSummaryCacheStatsInput) => void;
+}
+
+interface DeadCodeSummaryCacheStatsInput {
+  readonly hits: number;
+  readonly misses: number;
 }
 
 /**
@@ -69,6 +80,7 @@ export class DeadCode extends Context.Service<
                   abortSignal: signal,
                   cacheEnabled,
                   onCacheOutcome: input.onCacheOutcome,
+                  onSummaryCacheStats: input.onSummaryCacheStats,
                 }),
               catch: (cause) =>
                 new ReactDoctorError({ reason: new DeadCodeAnalysisFailed({ cause }) }),
diff --git a/packages/core/src/types/inspect.ts b/packages/core/src/types/inspect.ts
index aa59d09896..8247e50e43 100644
--- a/packages/core/src/types/inspect.ts
+++ b/packages/core/src/types/inspect.ts
@@ -56,6 +56,16 @@ export interface InspectResult {
    * projects it onto the Sentry wide event as `deadCode.cacheHit`.
    */
   deadCodeCacheHit?: boolean | null;
+  /**
+   * deslop's incremental summary-cache outcome for the dead-code analysis:
+   * collected files served from cached parse summaries vs freshly parsed.
+   * Both absent whenever no analysis consulted the incremental store — a
+   * whole-result cache hit, the cache disabled, or dead-code skipped. The CLI
+   * projects them onto the Sentry wide event as `deadCode.summaryCacheHits` /
+   * `deadCode.summaryCacheMisses`.
+   */
+  deadCodeSummaryCacheHits?: number | null;
+  deadCodeSummaryCacheMisses?: number | null;
   /**
    * Present only for a baseline run (`InspectOptions.baseline` set). The
    * `diagnostics` above are then the *introduced* findings only; this
diff --git a/packages/core/tests/check-dead-code.test.ts b/packages/core/tests/check-dead-code.test.ts
index 35101b5845..943ee6852e 100644
--- a/packages/core/tests/check-dead-code.test.ts
+++ b/packages/core/tests/check-dead-code.test.ts
@@ -3,6 +3,7 @@ import os from "node:os";
 import * as path from "node:path";
 import { afterAll, describe, expect, it } from "vite-plus/test";
 import { checkDeadCode } from "../src/check-dead-code.js";
+import { resolveReactDoctorCacheDir } from "../src/utils/resolve-react-doctor-cache-dir.js";
 
 const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rd-check-dead-code-"));
 
@@ -289,6 +290,58 @@ describe("checkDeadCode", () => {
     expect(flaggedDevDeps).toEqual(["Unused devDependency: `genuinely-unused`"]);
   });
 
+  it(
+    "reuses deslop's incremental summary cache across real worker runs and reflects edits",
+    { timeout: 120_000 },
+    async () => {
+      const directory = setupProject("incremental-cache-e2e", {
+        "src/index.ts": 'import { keep } from "./lib.js";\nexport const entry = keep;\n',
+        "src/lib.ts": "export const keep = 1;\n",
+        "src/orphan.ts": "export const orphan = 1;\n",
+      });
+      // Pins `resolveReactDoctorCacheDir` to the fixture so both cache files
+      // live (and are cleaned up) with it.
+      fs.mkdirSync(path.join(directory, "node_modules"), { recursive: true });
+      const summariesPath = path.join(
+        resolveReactDoctorCacheDir(directory),
+        "dead-code-summaries.json",
+      );
+
+      const firstRun = await checkDeadCode({ rootDirectory: directory, cacheEnabled: true });
+      expect(fs.existsSync(summariesPath)).toBe(true);
+      expect(firstRun.some((diagnostic) => diagnostic.rule === "unused-file")).toBe(true);
+      expect(firstRun.some((diagnostic) => diagnostic.message.includes("newlyUnused"))).toBe(false);
+
+      // Invalidate the whole-result layer so the worker actually re-runs and
+      // serves the changed-files case from the incremental summary store.
+      fs.appendFileSync(path.join(directory, "src", "lib.ts"), "export const newlyUnused = 2;\n");
+
+      let reportedStats: { hits: number; misses: number } | null = null;
+      const secondRun = await checkDeadCode({
+        rootDirectory: directory,
+        cacheEnabled: true,
+        onSummaryCacheStats: (stats) => {
+          reportedStats = stats;
+        },
+      });
+      expect(secondRun.some((diagnostic) => diagnostic.message.includes("newlyUnused"))).toBe(true);
+      // Only the edited file re-parses; the other two summaries replay.
+      expect(reportedStats).toEqual({ hits: 2, misses: 1 });
+
+      // Byte-identical to an uncached full analysis at the same tree state —
+      // and the uncached control reports no summary-cache stats.
+      let didControlReportStats = false;
+      const controlRun = await checkDeadCode({
+        rootDirectory: directory,
+        onSummaryCacheStats: () => {
+          didControlReportStats = true;
+        },
+      });
+      expect(secondRun).toEqual(controlRun);
+      expect(didControlReportStats).toBe(false);
+    },
+  );
+
   it("rejects malformed worker results instead of silently dropping diagnostics", async () => {
     const directory = setupProject("malformed-worker-result", {
       "src/index.ts": "export const used = 1;\n",
diff --git a/packages/core/tests/dead-code-discarded-passes-parity.test.ts b/packages/core/tests/dead-code-discarded-passes-parity.test.ts
index 195f0ef690..5bb98e8f8f 100644
--- a/packages/core/tests/dead-code-discarded-passes-parity.test.ts
+++ b/packages/core/tests/dead-code-discarded-passes-parity.test.ts
@@ -77,15 +77,15 @@ const consumedFindingSignature = (result: {
   });
 
 describe("deslop discarded-passes parity", () => {
-  it("produces identical graph-based findings with semantic + code-quality on vs off", async () => {
+  it("produces identical graph-based findings with semantic + code-quality + redundancy on vs off", async () => {
     const projectDirectory = buildFixture();
     const tsConfigPath = path.join(projectDirectory, "tsconfig.json");
 
-    // Full deslop (every detector) vs react-doctor's actual config — BOTH the
-    // semantic TS-Program pass AND the expensive code-quality detectors
+    // Full deslop (every detector) vs react-doctor's actual config — the
+    // semantic TS-Program pass, the expensive code-quality detectors
     // (duplicate blocks, complexity, feature flags, TS smells, private-type
-    // leaks, re-export cycles) disabled, since react-doctor discards their
-    // output and they are the bulk of the runtime.
+    // leaks, re-export cycles), AND the DRY-pattern redundancy detectors all
+    // disabled, since react-doctor discards their output.
     const full = await analyze(defineConfig({ rootDir: projectDirectory, tsConfigPath }));
     const deadCodeOnly = await analyze(
       defineConfig({
@@ -93,6 +93,7 @@ describe("deslop discarded-passes parity", () => {
         tsConfigPath,
         semantic: { enabled: false },
         reportCodeQuality: false,
+        reportRedundancy: false,
       }),
     );
 
diff --git a/packages/core/tests/dead-code-result-cache.test.ts b/packages/core/tests/dead-code-result-cache.test.ts
index 561aad42b8..c37a616640 100644
--- a/packages/core/tests/dead-code-result-cache.test.ts
+++ b/packages/core/tests/dead-code-result-cache.test.ts
@@ -374,6 +374,101 @@ describe("checkDeadCode result cache", () => {
     });
     expect(spyWorker.callCount()).toBe(2);
   });
+
+  it("threads deslop's incremental cache path into the worker when caching is enabled", async () => {
+    const directory = setupProject("incremental-path-threaded", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    let capturedInput: { incrementalCachePath?: string } | null = null;
+    await checkDeadCode({
+      rootDirectory: directory,
+      cacheEnabled: true,
+      createWorker: (input) => {
+        capturedInput = input;
+        return {
+          result: Promise.resolve({
+            unusedFiles: [],
+            unusedExports: [],
+            unusedDependencies: [],
+            circularDependencies: [],
+          }),
+        };
+      },
+    });
+    // Same per-project cache directory as the whole-result cache, distinct file.
+    expect(capturedInput?.incrementalCachePath).toBe(
+      path.join(directory, "node_modules", ".cache", "react-doctor", "dead-code-summaries.json"),
+    );
+  });
+
+  it("reports the worker's summary-cache stats through onSummaryCacheStats", async () => {
+    const directory = setupProject("summary-stats-reported", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    let reportedStats: { hits: number; misses: number } | null = null;
+    await checkDeadCode({
+      rootDirectory: directory,
+      cacheEnabled: true,
+      onSummaryCacheStats: (stats) => {
+        reportedStats = stats;
+      },
+      createWorker: () => ({
+        result: Promise.resolve({
+          unusedFiles: [],
+          unusedExports: [],
+          unusedDependencies: [],
+          circularDependencies: [],
+          summaryCacheStats: { hits: 41, misses: 2 },
+        }),
+      }),
+    });
+    expect(reportedStats).toEqual({ hits: 41, misses: 2 });
+  });
+
+  it("leaves onSummaryCacheStats uninvoked when the worker reports no stats", async () => {
+    const directory = setupProject("summary-stats-absent", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    let didReportStats = false;
+    await checkDeadCode({
+      rootDirectory: directory,
+      onSummaryCacheStats: () => {
+        didReportStats = true;
+      },
+      createWorker: () => ({
+        result: Promise.resolve({
+          unusedFiles: [],
+          unusedExports: [],
+          unusedDependencies: [],
+          circularDependencies: [],
+        }),
+      }),
+    });
+    expect(didReportStats).toBe(false);
+  });
+
+  it("omits deslop's incremental cache path when caching is off (default)", async () => {
+    const directory = setupProject("incremental-path-omitted", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    let capturedInput: { incrementalCachePath?: string } | null = null;
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: (input) => {
+        capturedInput = input;
+        return {
+          result: Promise.resolve({
+            unusedFiles: [],
+            unusedExports: [],
+            unusedDependencies: [],
+            circularDependencies: [],
+          }),
+        };
+      },
+    });
+    expect(capturedInput).not.toBeNull();
+    expect(capturedInput?.incrementalCachePath).toBeUndefined();
+  });
 });
 
 describe("DeadCodeResultCacheEnabled", () => {
diff --git a/packages/deslop-js/src/collect/entries-in-worker.ts b/packages/deslop-js/src/collect/entries-in-worker.ts
new file mode 100644
index 0000000000..262064a6e6
--- /dev/null
+++ b/packages/deslop-js/src/collect/entries-in-worker.ts
@@ -0,0 +1,81 @@
+import type { Worker } from "node:worker_threads";
+import type { DeslopConfig, ResolvedEntries } from "../types.js";
+import { resolveEntries } from "./entries.js";
+import { launchSiblingWorker } from "./launch-worker.js";
+
+interface EntriesWorkerReadyMessage {
+  readonly type: "ready";
+}
+
+interface EntriesWorkerResultMessage {
+  readonly type: "result";
+  readonly entries: ResolvedEntries;
+}
+
+interface EntriesWorkerErrorMessage {
+  readonly type: "error";
+  readonly errorMessage: string;
+}
+
+type EntriesWorkerMessage =
+  | EntriesWorkerReadyMessage
+  | EntriesWorkerResultMessage
+  | EntriesWorkerErrorMessage;
+
+interface EntriesWorkerInfraFailure {
+  readonly kind: "infra-failure";
+}
+
+interface EntriesWorkerAnalysisError {
+  readonly kind: "analysis-error";
+  readonly errorMessage: string;
+}
+
+interface EntriesWorkerSuccess {
+  readonly kind: "result";
+  readonly entries: ResolvedEntries;
+}
+
+type EntriesWorkerOutcome =
+  | EntriesWorkerSuccess
+  | EntriesWorkerAnalysisError
+  | EntriesWorkerInfraFailure;
+
+/**
+ * Runs `resolveEntries` on a dedicated worker thread so its ~90%-synchronous
+ * fs work overlaps the main-thread analysis phases — the incremental-cache
+ * warm path has no long parse `await` left to hide it behind. Entry content
+ * reads stay live (fresh every run) exactly as inline. Worker infrastructure
+ * failures fall back to the inline call (same result, just serialized); an
+ * error thrown by `resolveEntries` itself rejects with the same message an
+ * inline throw would, so the caller's fallback-to-empty-entries handling is
+ * unchanged.
+ */
+export const resolveEntriesInWorker = async (config: DeslopConfig): Promise<ResolvedEntries> => {
+  let worker: Worker;
+  try {
+    worker = launchSiblingWorker(import.meta.url, "entries-worker");
+  } catch {
+    return resolveEntries(config);
+  }
+  try {
+    const outcome = await new Promise<EntriesWorkerOutcome>((resolveOutcome) => {
+      worker.on("message", (message: EntriesWorkerMessage) => {
+        if (message.type === "ready") {
+          worker.postMessage({ type: "resolve-entries", config });
+        } else if (message.type === "result") {
+          resolveOutcome({ kind: "result", entries: message.entries });
+        } else if (message.type === "error") {
+          resolveOutcome({ kind: "analysis-error", errorMessage: message.errorMessage });
+        }
+      });
+      worker.on("error", () => resolveOutcome({ kind: "infra-failure" }));
+      worker.on("exit", () => resolveOutcome({ kind: "infra-failure" }));
+    });
+    if (outcome.kind === "result") return outcome.entries;
+    if (outcome.kind === "analysis-error") throw new Error(outcome.errorMessage);
+    return resolveEntries(config);
+  } finally {
+    void worker.terminate();
+  }
+};
diff --git a/packages/deslop-js/src/collect/entries-worker.ts b/packages/deslop-js/src/collect/entries-worker.ts
new file mode 100644
index 0000000000..a59c86e222
--- /dev/null
+++ b/packages/deslop-js/src/collect/entries-worker.ts
@@ -0,0 +1,39 @@
+import { parentPort } from "node:worker_threads";
+import type { DeslopConfig, ResolvedEntries } from "../types.js";
+import { resolveEntries } from "./entries.js";
+
+interface ResolveEntriesTaskMessage {
+  readonly type: "resolve-entries";
+  readonly config: DeslopConfig;
+}
+
+interface EntriesResultMessage {
+  readonly type: "result";
+  readonly entries: ResolvedEntries;
+}
+
+interface EntriesErrorMessage {
+  readonly type: "error";
+  readonly errorMessage: string;
+}
+
+const port = parentPort!;
+
+port.on("message", (message: ResolveEntriesTaskMessage) => {
+  if (message.type !== "resolve-entries") return;
+  void resolveEntries(message.config).then(
+    (entries) => {
+      const response: EntriesResultMessage = { type: "result", entries };
+      port.postMessage(response);
+    },
+    (taskError: unknown) => {
+      const response: EntriesErrorMessage = {
+        type: "error",
+        errorMessage: taskError instanceof Error ? taskError.message : String(taskError),
+      };
+      port.postMessage(response);
+    },
+  );
+});
+
+port.postMessage({ type: "ready" });
diff --git a/packages/deslop-js/src/collect/launch-worker.ts b/packages/deslop-js/src/collect/launch-worker.ts
new file mode 100644
index 0000000000..de4b84e106
--- /dev/null
+++ b/packages/deslop-js/src/collect/launch-worker.ts
@@ -0,0 +1,20 @@
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Launches a worker module that sits next to `fromModuleUrl`: the TypeScript
+ * source (via tsx) when the caller itself runs from source — tests and direct
+ * `tsx` execution — and the built `.mjs` sibling when running from dist.
+ */
+export const launchSiblingWorker = (fromModuleUrl: string, workerBaseName: string): Worker => {
+  const isTypeScriptSource = fromModuleUrl.endsWith(".ts");
+  const workerPath = fileURLToPath(
+    new URL(
+      isTypeScriptSource ? `./${workerBaseName}.ts` : `./${workerBaseName}.mjs`,
+      fromModuleUrl,
+    ),
+  );
+  return new Worker(workerPath, {
+    ...(isTypeScriptSource ? { execArgv: ["--import", "tsx"] } : {}),
+  });
+};
diff --git a/packages/deslop-js/src/collect/parallel-parse.ts b/packages/deslop-js/src/collect/parallel-parse.ts
index ea929dabd0..facebb6c04 100644
--- a/packages/deslop-js/src/collect/parallel-parse.ts
+++ b/packages/deslop-js/src/collect/parallel-parse.ts
@@ -1,11 +1,11 @@
-import { Worker } from "node:worker_threads";
-import { fileURLToPath } from "node:url";
+import type { Worker } from "node:worker_threads";
 import type { SourceFile } from "../types.js";
 import type { ParsedSource } from "./parse.js";
 import { parseSourceFile } from "./parse.js";
 import { DeslopError, type DeslopErrorJson, ParseError } from "../errors.js";
 import { PARALLEL_PARSE_FILE_THRESHOLD } from "../constants.js";
 import { resolveAvailableConcurrency } from "../utils/resolve-available-concurrency.js";
+import { launchSiblingWorker } from "./launch-worker.js";
 
 interface ParseResultMessage {
   readonly type: "result";
@@ -68,21 +68,6 @@ const deserializeParsedSource = (serialized: ParseResultMessage["parsed"]): Pars
   errors: deserializeErrors(serialized.errors),
 });
 
-const resolveWorkerPath = (): string => {
-  const currentUrl = import.meta.url;
-  if (currentUrl.endsWith(".ts")) {
-    return fileURLToPath(new URL("./parse-worker.ts", currentUrl));
-  }
-  return fileURLToPath(new URL("./parse-worker.mjs", currentUrl));
-};
-
-const createWorker = (workerPath: string): Worker => {
-  const isTypeScript = workerPath.endsWith(".ts");
-  return new Worker(workerPath, {
-    ...(isTypeScript ? { execArgv: ["--import", "tsx"] } : {}),
-  });
-};
-
 const waitForReady = (worker: Worker): Promise<void> =>
   new Promise((resolve, reject) => {
     const onMessage = (message: WorkerResponse): void => {
@@ -105,13 +90,12 @@ const parseFilesWithWorkerPool = async (
   files: ReadonlyArray<SourceFile>,
   workerCount: number,
 ): Promise<ParsedSource[]> => {
-  const workerPath = resolveWorkerPath();
   const results: ParsedSource[] = new Array(files.length);
   const workers: Worker[] = [];
 
   try {
     for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) {
-      workers.push(createWorker(workerPath));
+      workers.push(launchSiblingWorker(import.meta.url, "parse-worker"));
     }
     await Promise.all(workers.map(waitForReady));
   } catch {
diff --git a/packages/deslop-js/src/constants.ts b/packages/deslop-js/src/constants.ts
index f58f4b277c..2f0a902cec 100644
--- a/packages/deslop-js/src/constants.ts
+++ b/packages/deslop-js/src/constants.ts
@@ -334,6 +334,10 @@ export const MAX_ANALYSIS_ERRORS = 5000;
 
 export const MAX_ERROR_DETAIL_LENGTH = 1000;
 
+export const SUMMARY_CACHE_SCHEMA_VERSION = 1;
+
+export const SUMMARY_CACHE_MAX_BYTES = 256 * 1024 * 1024;
+
 export const BINARY_DETECTION_SAMPLE_BYTES = 2048;
 
 export const BINARY_DETECTION_NULL_BYTE_THRESHOLD = 4;
diff --git a/packages/deslop-js/src/index.ts b/packages/deslop-js/src/index.ts
index 63274c25d8..9b44280a44 100644
--- a/packages/deslop-js/src/index.ts
+++ b/packages/deslop-js/src/index.ts
@@ -31,6 +31,8 @@ import { buildDependencyGraph, type ModuleLinkInput } from "./linker/build.js";
 import { traceReachability } from "./linker/reachability.js";
 import { resolveReExportChains } from "./linker/re-exports.js";
 import { generateReport } from "./report/generate.js";
+import { resolveEntriesInWorker } from "./collect/entries-in-worker.js";
+import { loadSummaryCache } from "./summary-cache.js";
 import { findMonorepoRoot } from "./utils/find-monorepo-root.js";
 import { collectGitIgnoredPaths } from "./utils/collect-git-ignored-paths.js";
 
@@ -268,6 +270,7 @@ export const defineConfig = (
   includeExtensions: options.includeExtensions ?? DEFAULT_EXTENSIONS,
   tsConfigPath: options.tsConfigPath,
   paths: options.paths,
+  incrementalCachePath: options.incrementalCachePath,
   reportTypes: options.reportTypes ?? false,
   includeEntryExports: options.includeEntryExports ?? false,
   reportRedundancy: options.reportRedundancy ?? true,
@@ -428,44 +431,52 @@ export const analyze = async (config: DeslopConfig): Promise<ScanResult> => {
         }
       : config;
 
-  let files: Awaited<ReturnType<typeof collectSourceFiles>>;
-  let discoveredEntries: Awaited<ReturnType<typeof resolveEntries>>;
-  try {
-    const [collectedFiles, resolvedEntries] = await Promise.all([
-      collectSourceFiles(configWithExclusions),
-      resolveEntries(configWithExclusions).catch((entriesError: unknown) => {
-        setupErrors.push(
-          new WorkspaceError({
-            code: "workspace-discovery-failed",
-            message: "resolveEntries failed — defaulting to empty entry set",
-            path: config.rootDir,
-            detail: describeUnknownError(entriesError),
-          }),
-        );
-        return {
-          productionEntries: [] as string[],
-          testEntries: [] as string[],
-          alwaysUsedFiles: [] as string[],
-        };
-      }),
-    ]);
-    files = collectedFiles;
-    discoveredEntries = resolvedEntries;
-  } catch (collectError) {
+  // Entry resolution always runs live — it reads config/doc/sibling-source
+  // CONTENT that no name-based fingerprint can validate — but its result is
+  // not needed until graph assembly. Uncached, it overlaps collection and the
+  // parse pool on the main thread's awaits; with the incremental cache a warm
+  // run has no parse window left to hide its mostly-synchronous work, so it
+  // moves to a dedicated worker thread (spawned before the cache's tree walk,
+  // which would otherwise serialize ahead of it).
+  const entriesPromise = (
+    configWithExclusions.incrementalCachePath
+      ? resolveEntriesInWorker(configWithExclusions)
+      : resolveEntries(configWithExclusions)
+  ).catch((entriesError: unknown): Awaited<ReturnType<typeof resolveEntries>> => {
     setupErrors.push(
       new WorkspaceError({
         code: "workspace-discovery-failed",
-        severity: "fatal",
-        message: "collectSourceFiles failed",
+        message: "resolveEntries failed — defaulting to empty entry set",
         path: config.rootDir,
-        detail: describeUnknownError(collectError),
+        detail: describeUnknownError(entriesError),
       }),
     );
-    return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
+    return { productionEntries: [], testEntries: [], alwaysUsedFiles: [] };
+  });
+
+  const summaryCache = loadSummaryCache(configWithExclusions);
+
+  let files: Awaited<ReturnType<typeof collectSourceFiles>>;
+  const cachedFileList = summaryCache?.lookupFileList() ?? null;
+  if (cachedFileList !== null) {
+    files = cachedFileList;
+  } else {
+    try {
+      files = await collectSourceFiles(configWithExclusions);
+      summaryCache?.storeFileList(files);
+    } catch (collectError) {
+      setupErrors.push(
+        new WorkspaceError({
+          code: "workspace-discovery-failed",
+          severity: "fatal",
+          message: "collectSourceFiles failed",
+          path: config.rootDir,
+          detail: describeUnknownError(collectError),
+        }),
+      );
+      return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
+    }
   }
-  const productionEntrySet = new Set(discoveredEntries.productionEntries);
-  const testEntrySet = new Set(discoveredEntries.testEntries);
-  const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
   const gitIgnoreResult = collectGitIgnoredPaths(
     resolve(config.rootDir),
     files.map((file) => file.path),
@@ -509,7 +520,47 @@ export const analyze = async (config: DeslopConfig): Promise<ScanResult> => {
     );
     return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
   }
-  const parsedModules = await parseFilesInParallel(files);
+  const resolveModuleThroughCache = (
+    specifier: string,
+    fromFile: string,
+  ): ReturnType<typeof moduleResolver.resolveModule> => {
+    if (summaryCache === null) return moduleResolver.resolveModule(specifier, fromFile);
+    const cachedResolution = summaryCache.lookupResolution(specifier, fromFile);
+    if (cachedResolution !== null) return cachedResolution;
+    const resolved = moduleResolver.resolveModule(specifier, fromFile);
+    summaryCache.storeResolution(specifier, fromFile, resolved);
+    return resolved;
+  };
+
+  let parsedModules: Awaited<ReturnType<typeof parseFilesInParallel>>;
+  let summaryMissCount = 0;
+  if (summaryCache === null) {
+    parsedModules = await parseFilesInParallel(files);
+  } else {
+    parsedModules = new Array(files.length);
+    const missedFiles: typeof files = [];
+    const missedPositions: number[] = [];
+    for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+      const cachedSummary = summaryCache.lookupSummary(files[fileIndex].path);
+      if (cachedSummary !== null) {
+        parsedModules[fileIndex] = cachedSummary;
+        continue;
+      }
+      missedFiles.push(files[fileIndex]);
+      missedPositions.push(fileIndex);
+    }
+    summaryMissCount = missedFiles.length;
+    const parsedMissedModules = await parseFilesInParallel(missedFiles);
+    for (let missIndex = 0; missIndex < missedFiles.length; missIndex++) {
+      parsedModules[missedPositions[missIndex]] = parsedMissedModules[missIndex];
+      summaryCache.storeSummary(missedFiles[missIndex].path, parsedMissedModules[missIndex]);
+    }
+  }
+
+  const discoveredEntries = await entriesPromise;
+  const productionEntrySet = new Set(discoveredEntries.productionEntries);
+  const testEntrySet = new Set(discoveredEntries.testEntries);
+  const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
 
   const graphInputs: ModuleLinkInput[] = [];
 
@@ -522,7 +573,7 @@ export const analyze = async (config: DeslopConfig): Promise<ScanResult> => {
       specifier: string,
     ): ReturnType<typeof moduleResolver.resolveModule> => {
       try {
-        return moduleResolver.resolveModule(specifier, file.path);
+        return resolveModuleThroughCache(specifier, file.path);
       } catch (resolveError) {
         setupErrors.push(
           new ResolverError({
@@ -626,7 +677,7 @@ export const analyze = async (config: DeslopConfig): Promise<ScanResult> => {
     for (const importInfo of parsedStyleModule.imports) {
       let resolvedImport: ReturnType<typeof moduleResolver.resolveModule>;
       try {
-        resolvedImport = moduleResolver.resolveModule(importInfo.specifier, styleFilePath);
+        resolvedImport = resolveModuleThroughCache(importInfo.specifier, styleFilePath);
       } catch (styleResolveError) {
         setupErrors.push(
           new ResolverError({
@@ -705,7 +756,7 @@ export const analyze = async (config: DeslopConfig): Promise<ScanResult> => {
 
   let analysisResult: ScanResult;
   try {
-    analysisResult = generateReport(moduleGraph, config);
+    analysisResult = generateReport(moduleGraph, config, summaryCache ?? undefined);
   } catch (reportError) {
     setupErrors.push(
       new DetectorError({
@@ -718,6 +769,15 @@ export const analyze = async (config: DeslopConfig): Promise<ScanResult> => {
     return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
   }
 
+  summaryCache?.save();
+
+  if (summaryCache !== null) {
+    analysisResult.incrementalCacheStats = {
+      summaryHits: files.length - summaryMissCount,
+      summaryMisses: summaryMissCount,
+    };
+  }
+
   if (setupErrors.length > 0) {
     analysisResult.analysisErrors = [...setupErrors, ...analysisResult.analysisErrors];
   }
diff --git a/packages/deslop-js/src/report/exports.ts b/packages/deslop-js/src/report/exports.ts
index b79ec63f6f..b349450cc0 100644
--- a/packages/deslop-js/src/report/exports.ts
+++ b/packages/deslop-js/src/report/exports.ts
@@ -1,5 +1,6 @@
 import type {
   DependencyGraph,
+  Edge,
   SourceModule,
   ExportReference,
   UnusedExport,
@@ -59,11 +60,24 @@ const buildUsageMap = (graph: DependencyGraph): Set<string> => {
   const usedExportKeys = new Set<string>();
   const sourceToTargetMap = buildSourceToTargetsMap(graph);
 
+  // Indexed by source so the entry-point pass is O(edges), not
+  // O(entry points × edges) — on a large repo with thousands of entry
+  // modules the unindexed scan dominated this detector.
+  const reExportEdgesBySource = new Map<number, Edge[]>();
+  for (const edge of graph.edges) {
+    if (!edge.isReExportEdge) continue;
+    const existingEdges = reExportEdgesBySource.get(edge.source);
+    if (existingEdges) {
+      existingEdges.push(edge);
+    } else {
+      reExportEdgesBySource.set(edge.source, [edge]);
+    }
+  }
+
   for (const module of graph.modules) {
     if (!module.isEntryPoint) continue;
 
-    for (const edge of graph.edges) {
-      if (edge.source !== module.fileId.index || !edge.isReExportEdge) continue;
+    for (const edge of reExportEdgesBySource.get(module.fileId.index) ?? []) {
       const targetModule = graph.modules[edge.target];
       if (!targetModule) continue;
 
diff --git a/packages/deslop-js/src/report/generate.ts b/packages/deslop-js/src/report/generate.ts
index 1e6dd48248..bdeb6e5cce 100644
--- a/packages/deslop-js/src/report/generate.ts
+++ b/packages/deslop-js/src/report/generate.ts
@@ -29,6 +29,7 @@ import { runSemanticAnalysis } from "../semantic/index.js";
 import { DetectorError, describeUnknownError } from "../errors.js";
 import { MAX_ANALYSIS_ERRORS } from "../constants.js";
 import { runSafeDetector } from "../utils/run-safe-detector.js";
+import type { SummaryCache } from "../summary-cache.js";
 
 const safeReportDetector = <ResultType>(
   detectorName: string,
@@ -45,7 +46,11 @@ const safeReportDetector = <ResultType>(
     contextDescription: "while building findings",
   });
 
-export const generateReport = (graph: DependencyGraph, config: DeslopConfig): ScanResult => {
+export const generateReport = (
+  graph: DependencyGraph,
+  config: DeslopConfig,
+  summaryCache?: SummaryCache,
+): ScanResult => {
   const analysisStartTime = performance.now();
   const errorSink: DeslopError[] = [];
 
@@ -71,7 +76,7 @@ export const generateReport = (graph: DependencyGraph, config: DeslopConfig): Sc
   );
   const unusedDependencies = safeReportDetector(
     "detectStalePackages",
-    () => detectStalePackages(graph, config),
+    () => detectStalePackages(graph, config, summaryCache),
     [],
     errorSink,
   );
diff --git a/packages/deslop-js/src/report/packages.ts b/packages/deslop-js/src/report/packages.ts
index a3ac1b493a..9275eba01f 100644
--- a/packages/deslop-js/src/report/packages.ts
+++ b/packages/deslop-js/src/report/packages.ts
@@ -10,26 +10,82 @@ import { matchesPackageImportReference } from "../utils/matches-package-import-r
 import { matchesPackageTokenReference } from "../utils/matches-package-token-reference.js";
 import { findMonorepoRoot } from "../utils/find-monorepo-root.js";
 import { extractExpoConfigPluginEntries } from "../collect/expo-config-plugin-entries.js";
+import type { PackageFactKind, SummaryCache } from "../summary-cache.js";
 
 interface OverrideMapping {
   fromPackage: string;
   toPackage: string;
 }
 
+interface PackageFileGlobOptions {
+  readonly ignore: ReadonlyArray<string>;
+  readonly deep: number;
+  readonly dot?: boolean;
+}
+
+// The stale-package file scans, answered from the summary cache's shared tree
+// walk when one is live (verified byte-identical against fg on real corpora)
+// and by a real fast-glob scan otherwise — including when the search root is
+// not the walk root (a monorepo root above the scanned project).
+const globPackageFiles = (
+  cwd: string,
+  patterns: ReadonlyArray<string>,
+  options: PackageFileGlobOptions,
+  summaryCache: SummaryCache | undefined,
+): string[] =>
+  summaryCache?.matchWalkedFiles({ cwd, patterns, ...options }) ??
+  fg.sync([...patterns], {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    ignore: [...options.ignore],
+    deep: options.deep,
+    ...(options.dot === undefined ? {} : { dot: options.dot }),
+  });
+
+const containsPackageName = (content: string, packageName: string): boolean =>
+  content.includes(packageName);
+
+// The per-file content predicates behind the config/docs/rescue scans, served
+// from the summary cache's fact layer when available (a fresh `readFileSync`
+// otherwise). Read failures throw exactly like the raw loops this replaces.
+const matchPackageNamesInFile = (
+  filePath: string,
+  kind: PackageFactKind,
+  names: ReadonlySet<string>,
+  matcher: (content: string, packageName: string) => boolean,
+  summaryCache: SummaryCache | undefined,
+): string[] => {
+  if (summaryCache !== undefined) {
+    return summaryCache.matchPackageNames(filePath, kind, names, matcher);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  const matchedNames: string[] = [];
+  for (const packageName of names) {
+    if (matcher(content, packageName)) matchedNames.push(packageName);
+  }
+  return matchedNames;
+};
+
 interface PackageJsonDependencies {
   dependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
 }
 
-const discoverAllPackageJsonPaths = (rootDir: string): string[] => {
+const discoverAllPackageJsonPaths = (
+  rootDir: string,
+  summaryCache: SummaryCache | undefined,
+): string[] => {
   const paths = [join(rootDir, "package.json")];
-  const workspacePackageJsons = fg.sync("**/package.json", {
-    cwd: rootDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
-    deep: 5,
-  });
+  const workspacePackageJsons = globPackageFiles(
+    rootDir,
+    ["**/package.json"],
+    {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+      deep: 5,
+    },
+    summaryCache,
+  );
   for (const workspacePath of workspacePackageJsons) {
     if (workspacePath !== paths[0] && !paths.includes(workspacePath)) {
       paths.push(workspacePath);
@@ -41,6 +97,7 @@ const discoverAllPackageJsonPaths = (rootDir: string): string[] => {
 export const detectStalePackages = (
   graph: DependencyGraph,
   config: DeslopConfig,
+  summaryCache?: SummaryCache,
 ): UnusedDependency[] => {
   const packageJsonPath = resolve(config.rootDir, "package.json");
   let packageJson: PackageJsonDependencies;
@@ -72,7 +129,7 @@ export const detectStalePackages = (
       ? [config.rootDir, monorepoRoot]
       : [config.rootDir];
 
-  const allPackageJsonPaths = discoverAllPackageJsonPaths(config.rootDir);
+  const allPackageJsonPaths = discoverAllPackageJsonPaths(config.rootDir, summaryCache);
   if (monorepoRoot) {
     const monorepoPackageJson = join(monorepoRoot, "package.json");
     if (!allPackageJsonPaths.includes(monorepoPackageJson) && existsSync(monorepoPackageJson)) {
@@ -108,6 +165,7 @@ export const detectStalePackages = (
     config.rootDir,
     declaredNames,
     binToPackage,
+    summaryCache,
   );
   for (const packageName of nxProjectReferenced) usedPackageNames.add(packageName);
 
@@ -120,10 +178,11 @@ export const detectStalePackages = (
       configSearchRoot,
       graph,
       declaredNames,
+      summaryCache,
     );
     for (const packageName of configReferenced) usedPackageNames.add(packageName);
 
-    const tsconfigReferenced = collectTsconfigReferencedPackages(configSearchRoot);
+    const tsconfigReferenced = collectTsconfigReferencedPackages(configSearchRoot, summaryCache);
     for (const packageName of tsconfigReferenced) usedPackageNames.add(packageName);
 
     const { packageNames: expoPluginPackageNames } = extractExpoConfigPluginEntries(
@@ -208,7 +267,11 @@ export const detectStalePackages = (
   }
 
   if (candidateUnused.size > 0) {
-    const sourceFileRescued = scanSourceFilesForPackageImports(config.rootDir, candidateUnused);
+    const sourceFileRescued = scanSourceFilesForPackageImports(
+      config.rootDir,
+      candidateUnused,
+      summaryCache,
+    );
     for (const packageName of sourceFileRescued) {
       usedPackageNames.add(packageName);
       candidateUnused.delete(packageName);
@@ -468,64 +531,58 @@ const collectConfigReferencedPackages = (
   rootDir: string,
   graph: DependencyGraph,
   declaredNames: Set<string>,
+  summaryCache: SummaryCache | undefined,
 ): Set<string> => {
   const referenced = new Set<string>();
 
-  for (const module of graph.modules) {
-    if (!module.isConfigFile) continue;
+  const addMatchesFromFile = (
+    filePath: string,
+    kind: PackageFactKind,
+    matcher: (content: string, packageName: string) => boolean,
+  ): void => {
     try {
-      const content = readFileSync(module.fileId.path, "utf-8");
-      for (const packageName of declaredNames) {
-        if (content.includes(packageName)) {
-          referenced.add(packageName);
-        }
+      for (const packageName of matchPackageNamesInFile(
+        filePath,
+        kind,
+        declaredNames,
+        matcher,
+        summaryCache,
+      )) {
+        referenced.add(packageName);
       }
     } catch {
-      continue;
+      return;
     }
+  };
+
+  for (const module of graph.modules) {
+    if (!module.isConfigFile) continue;
+    addMatchesFromFile(module.fileId.path, "substring", containsPackageName);
   }
 
-  const configFiles = fg.sync(CONFIG_FILE_GLOBS, {
-    cwd: rootDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: ["**/node_modules/**"],
-    dot: true,
-    deep: 3,
-  });
+  const configFiles = globPackageFiles(
+    rootDir,
+    CONFIG_FILE_GLOBS,
+    { ignore: ["**/node_modules/**"], dot: true, deep: 3 },
+    summaryCache,
+  );
 
   for (const configPath of configFiles) {
-    try {
-      const content = readFileSync(configPath, "utf-8");
-      for (const packageName of declaredNames) {
-        if (content.includes(packageName)) {
-          referenced.add(packageName);
-        }
-      }
-    } catch {
-      continue;
-    }
+    addMatchesFromFile(configPath, "substring", containsPackageName);
   }
 
-  const documentationFiles = fg.sync(["**/*.{mdx,md}"], {
-    cwd: rootDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/CHANGELOG.md"],
-    deep: 6,
-  });
+  const documentationFiles = globPackageFiles(
+    rootDir,
+    ["**/*.{mdx,md}"],
+    {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/CHANGELOG.md"],
+      deep: 6,
+    },
+    summaryCache,
+  );
 
   for (const documentationPath of documentationFiles) {
-    try {
-      const content = readFileSync(documentationPath, "utf-8");
-      for (const packageName of declaredNames) {
-        if (matchesPackageImportReference(content, packageName)) {
-          referenced.add(packageName);
-        }
-      }
-    } catch {
-      continue;
-    }
+    addMatchesFromFile(documentationPath, "importReference", matchesPackageImportReference);
   }
 
   return referenced;
@@ -635,16 +692,16 @@ const collectNxProjectJsonReferences = (
   rootDir: string,
   declaredNames: Set<string>,
   binToPackage: Map<string, string>,
+  summaryCache: SummaryCache | undefined,
 ): Set<string> => {
   const referenced = new Set<string>();
 
-  const projectJsonPaths = fg.sync(["project.json", "**/project.json"], {
-    cwd: rootDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
-    deep: 5,
-  });
+  const projectJsonPaths = globPackageFiles(
+    rootDir,
+    ["project.json", "**/project.json"],
+    { ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"], deep: 5 },
+    summaryCache,
+  );
 
   for (const projectJsonPath of projectJsonPaths) {
     try {
@@ -688,17 +745,18 @@ const TSCONFIG_GLOBS = [
   "**/tsconfig.*.json",
 ];
 
-const collectTsconfigReferencedPackages = (rootDir: string): Set<string> => {
+const collectTsconfigReferencedPackages = (
+  rootDir: string,
+  summaryCache: SummaryCache | undefined,
+): Set<string> => {
   const referenced = new Set<string>();
 
-  const tsconfigFiles = fg.sync(TSCONFIG_GLOBS, {
-    cwd: rootDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: ["**/node_modules/**"],
-    dot: false,
-    deep: 4,
-  });
+  const tsconfigFiles = globPackageFiles(
+    rootDir,
+    TSCONFIG_GLOBS,
+    { ignore: ["**/node_modules/**"], dot: false, deep: 4 },
+    summaryCache,
+  );
 
   for (const tsconfigPath of tsconfigFiles) {
     try {
@@ -764,17 +822,39 @@ const SOURCE_FILE_IGNORES = [
 const scanSourceFilesForPackageImports = (
   rootDir: string,
   candidatePackages: Set<string>,
+  summaryCache: SummaryCache | undefined,
 ): Set<string> => {
   const found = new Set<string>();
   if (candidatePackages.size === 0) return found;
 
-  const sourceFiles = fg.sync(SOURCE_FILE_GLOBS, {
-    cwd: rootDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: SOURCE_FILE_IGNORES,
-    deep: 15,
-  });
+  const sourceFiles = globPackageFiles(
+    rootDir,
+    SOURCE_FILE_GLOBS,
+    { ignore: SOURCE_FILE_IGNORES, deep: 15 },
+    summaryCache,
+  );
+
+  if (summaryCache !== undefined) {
+    // Cached mode queries the FULL candidate set against every file (no
+    // early-shrink) so the per-file fact key stays stable across runs. The
+    // found-set is identical — a candidate is found iff any file matches it.
+    for (const filePath of sourceFiles) {
+      try {
+        for (const packageName of summaryCache.matchPackageNames(
+          filePath,
+          "importReference",
+          candidatePackages,
+          matchesPackageImportReference,
+        )) {
+          found.add(packageName);
+        }
+      } catch {
+        continue;
+      }
+    }
+    for (const packageName of found) candidatePackages.delete(packageName);
+    return found;
+  }
 
   for (const filePath of sourceFiles) {
     if (candidatePackages.size === 0) break;
diff --git a/packages/deslop-js/src/summary-cache.ts b/packages/deslop-js/src/summary-cache.ts
new file mode 100644
index 0000000000..73c03a9e6e
--- /dev/null
+++ b/packages/deslop-js/src/summary-cache.ts
@@ -0,0 +1,688 @@
+// The incremental analysis cache behind `DeslopConfig.incrementalCachePath`.
+// One tree walk per run is the single change detector; from it four layers are
+// validated independently:
+//   1. per-file parse summaries (`ParsedSource`) keyed by (mtimeMs, size);
+//   2. the collected file LIST keyed by `collectHash` (sorted file names, with
+//      manifest-like files stat-fingerprinted). Entry RESOLUTION is
+//      deliberately NOT cached: `resolveEntries` reads an unbounded content
+//      set (bundler/test-runner config strings, workflow yml, HTML, tsconfig
+//      contents, even sibling-workspace sources), so no name-based fingerprint
+//      can validate it — it re-runs live every scan, overlapped with parsing;
+//   3. the `fromDir::specifier → ResolvedImport` map keyed by `resolutionHash`
+//      (`collectHash` ⊕ bundler-config stats — module resolution depends on the
+//      file SET, so summaries cache raw specifiers only and any add/delete/
+//      rename drops the whole resolution map);
+//   4. per-file package-reference facts for `detectStalePackages`' content
+//      scans, keyed by (mtimeMs, size, queried-name-set hash).
+// Every read fails open (corrupt / missing / version- or scope-mismatched data
+// degrades to a fresh computation, never a wrong result), saves are atomic
+// (temp file + rename) and skipped when nothing changed. The accepted blind
+// spot, shared with the stat-based caches in @react-doctor/core: an edit that
+// preserves both a file's mtime and its byte size is invisible. The walk is
+// rooted at `rootDir` (matching core's whole-result dead-code cache), so
+// manifest edits ABOVE the scanned root share that cache's accepted gap.
+import crypto from "node:crypto";
+import {
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { Minimatch } from "minimatch";
+import type { DeslopConfig, SourceFile } from "./types.js";
+import type { ParsedSource } from "./collect/parse.js";
+import type { ResolvedImport } from "./resolver/resolve.js";
+import { DeslopError, type DeslopErrorJson } from "./errors.js";
+import {
+  ANALYZED_MANIFEST_FILENAMES,
+  SUMMARY_CACHE_MAX_BYTES,
+  SUMMARY_CACHE_SCHEMA_VERSION,
+} from "./constants.js";
+import { toPosixPath } from "./utils/to-posix-path.js";
+
+export type PackageFactKind = "substring" | "importReference";
+
+/**
+ * A fast-glob-shaped query answered from the already-walked tree instead of a
+ * fresh directory scan. Mirrors the fg options the stale-package scans use:
+ * `deep` admits files at most that many path segments below `cwd`, `dot`
+ * governs whether wildcards match dot-prefixed names (fg default: false), and
+ * `ignore` patterns always match dot names (fg behavior).
+ */
+export interface WalkedFileQuery {
+  readonly cwd: string;
+  readonly patterns: ReadonlyArray<string>;
+  readonly ignore: ReadonlyArray<string>;
+  readonly deep: number;
+  readonly dot?: boolean;
+}
+
+export interface SummaryCache {
+  /** The cached collected-file list, or `null` when the tree shape changed. */
+  readonly lookupFileList: () => SourceFile[] | null;
+  readonly storeFileList: (files: SourceFile[]) => void;
+  readonly lookupSummary: (filePath: string) => ParsedSource | null;
+  readonly storeSummary: (filePath: string, parsed: ParsedSource) => void;
+  readonly lookupResolution: (specifier: string, fromFile: string) => ResolvedImport | null;
+  readonly storeResolution: (specifier: string, fromFile: string, resolved: ResolvedImport) => void;
+  /**
+   * The subset of `names` that `matcher` matches in `filePath`, served from
+   * the per-file fact layer when (mtime, size, queried-name-set) all match.
+   * Reads the file (and throws like a raw `readFileSync`) only on a miss.
+   * Callers must not mutate `names` while iterating one scan loop — the
+   * sorted/hashed form is memoized per set instance.
+   */
+  readonly matchPackageNames: (
+    filePath: string,
+    kind: PackageFactKind,
+    names: ReadonlySet<string>,
+    matcher: (content: string, packageName: string) => boolean,
+  ) => string[];
+  /**
+   * The walked files matching a fast-glob-shaped query, sorted, as absolute
+   * POSIX paths — the shared-walk replacement for the stale-package `fg.sync`
+   * scans (verified byte-identical against fg on real corpora). Returns `null`
+   * when the query's `cwd` is not the walk root (e.g. a monorepo root above
+   * the scanned project) or a pattern fails to compile; callers then fall
+   * back to a real glob scan.
+   */
+  readonly matchWalkedFiles: (query: WalkedFileQuery) => string[] | null;
+  /** Compacts and atomically persists the store; no-op when nothing changed. */
+  readonly save: () => void;
+}
+
+interface FileStatFingerprint {
+  m: number;
+  s: number;
+}
+
+interface PersistedParsedSource {
+  imports?: ParsedSource["imports"];
+  exports?: ParsedSource["exports"];
+  memberAccesses?: ParsedSource["memberAccesses"];
+  wholeObjectUses?: string[];
+  localIdentifierReferences?: string[];
+  referencedFilenames?: string[];
+  redundantTypePatterns?: ParsedSource["redundantTypePatterns"];
+  identityWrappers?: ParsedSource["identityWrappers"];
+  typeDefinitionHashes?: ParsedSource["typeDefinitionHashes"];
+  inlineTypeLiterals?: ParsedSource["inlineTypeLiterals"];
+  simplifiableFunctions?: ParsedSource["simplifiableFunctions"];
+  simplifiableExpressions?: ParsedSource["simplifiableExpressions"];
+  duplicateConstantCandidates?: ParsedSource["duplicateConstantCandidates"];
+  errors?: DeslopErrorJson[];
+}
+
+interface PersistedSummaryEntry extends FileStatFingerprint {
+  p: PersistedParsedSource;
+}
+
+interface PersistedPackageFactMatch {
+  h: string;
+  matched: string[];
+}
+
+interface PersistedPackageFactEntry extends FileStatFingerprint {
+  substring?: PersistedPackageFactMatch;
+  importReference?: PersistedPackageFactMatch;
+}
+
+interface PersistedFileList {
+  hash: string;
+  files: string[];
+}
+
+interface PersistedResolution {
+  p: string | null;
+  e: boolean;
+  n: string | null;
+}
+
+interface PersistedResolutions {
+  hash: string;
+  entries: Record<string, PersistedResolution>;
+}
+
+interface PersistedSummaryCache {
+  version: number;
+  scopeHash: string;
+  fileList: PersistedFileList | null;
+  resolutions: PersistedResolutions | null;
+  summaries: Record<string, PersistedSummaryEntry>;
+  packageFacts: Record<string, PersistedPackageFactEntry>;
+}
+
+interface SortedNameSet {
+  sortedNames: string[];
+  hash: string;
+}
+
+const WALK_SKIP_DIRECTORY_NAMES = new Set(["node_modules", ".git"]);
+
+const MANIFEST_LIKE_FILENAMES = new Set(ANALYZED_MANIFEST_FILENAMES);
+
+const isManifestLikeFileName = (fileName: string): boolean =>
+  MANIFEST_LIKE_FILENAMES.has(fileName) ||
+  ((fileName.startsWith("tsconfig") || fileName.startsWith("jsconfig")) &&
+    fileName.endsWith(".json"));
+
+// The resolver reads bundler/test-runner alias configs by CONTENT
+// (`loadBundlerAliasConfigs`), so their stats must invalidate the resolution
+// map even though the file NAME set (already in `collectHash`) is unchanged.
+const isResolverConfigFileName = (fileName: string): boolean =>
+  fileName.includes("webpack") ||
+  fileName.startsWith("vite.config.") ||
+  fileName.startsWith("vitest.config.") ||
+  fileName.startsWith("babel.config.") ||
+  fileName.startsWith(".babelrc") ||
+  fileName.startsWith("jest.config.");
+
+const sha1Hex = (text: string): string => crypto.createHash("sha1").update(text).digest("hex");
+
+const fileNameOfPosixPath = (posixPath: string): string =>
+  posixPath.slice(posixPath.lastIndexOf("/") + 1);
+
+const deslopRequire = createRequire(import.meta.url);
+
+const resolveOwnPackageVersion = (): string => {
+  try {
+    const packageJson = deslopRequire("deslop-js/package.json");
+    return typeof packageJson?.version === "string" ? packageJson.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+};
+
+const walkTreeStats = (rootDirectory: string): Map<string, FileStatFingerprint> => {
+  const collected = new Map<string, FileStatFingerprint>();
+  // fast-glob (whose scans this walk both fingerprints and answers via
+  // `matchWalkedFiles`) follows directory symlinks, so the walk must too;
+  // following each distinct link target once bounds symlink cycles.
+  const followedLinkTargets = new Set<string>();
+  const walk = (directory: string): void => {
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = `${directory}/${entry.name}`;
+      if (entry.isDirectory()) {
+        if (!WALK_SKIP_DIRECTORY_NAMES.has(entry.name)) walk(entryPath);
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        if (WALK_SKIP_DIRECTORY_NAMES.has(entry.name)) continue;
+        try {
+          const linkStat = statSync(entryPath);
+          if (linkStat.isDirectory()) {
+            const linkTarget = realpathSync(entryPath);
+            if (!followedLinkTargets.has(linkTarget)) {
+              followedLinkTargets.add(linkTarget);
+              walk(entryPath);
+            }
+          } else if (linkStat.isFile()) {
+            collected.set(entryPath, { m: linkStat.mtimeMs, s: linkStat.size });
+          }
+        } catch {
+          continue;
+        }
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      try {
+        const fileStat = statSync(entryPath);
+        collected.set(entryPath, { m: fileStat.mtimeMs, s: fileStat.size });
+      } catch {
+        continue;
+      }
+    }
+  };
+  walk(toPosixPath(resolve(rootDirectory)));
+  return collected;
+};
+
+// One alternation regex over all patterns: the walked-file matcher tests each
+// of ~20k paths once instead of once per pattern. `null` on any pattern
+// minimatch cannot compile — the caller falls back to a real glob scan.
+const compileGlobAlternation = (
+  patterns: ReadonlyArray<string>,
+  matchDotNames: boolean,
+): RegExp | null => {
+  const regexSources: string[] = [];
+  for (const pattern of patterns) {
+    const compiled = new Minimatch(pattern, { dot: matchDotNames }).makeRe();
+    if (compiled === false) return null;
+    regexSources.push(compiled.source);
+  }
+  return regexSources.length === 0 ? null : new RegExp(regexSources.join("|"));
+};
+
+const countPathSegments = (relativePath: string): number => {
+  let segmentCount = 1;
+  for (let charIndex = 0; charIndex < relativePath.length; charIndex++) {
+    if (relativePath.charCodeAt(charIndex) === 47) segmentCount++;
+  }
+  return segmentCount;
+};
+
+const computeCollectHash = (walkedStats: Map<string, FileStatFingerprint>): string => {
+  const fingerprintLines: string[] = [];
+  for (const [filePath, fileStat] of walkedStats) {
+    fingerprintLines.push(
+      isManifestLikeFileName(fileNameOfPosixPath(filePath))
+        ? `${filePath}:${fileStat.m}:${fileStat.s}`
+        : filePath,
+    );
+  }
+  fingerprintLines.sort();
+  return sha1Hex(fingerprintLines.join("\n"));
+};
+
+const computeResolutionHash = (
+  collectHash: string,
+  walkedStats: Map<string, FileStatFingerprint>,
+): string => {
+  const fingerprintLines: string[] = [];
+  for (const [filePath, fileStat] of walkedStats) {
+    if (isResolverConfigFileName(fileNameOfPosixPath(filePath))) {
+      fingerprintLines.push(`${filePath}:${fileStat.m}:${fileStat.s}`);
+    }
+  }
+  fingerprintLines.sort();
+  return sha1Hex(`${collectHash}\n${fingerprintLines.join("\n")}`);
+};
+
+// Everything that changes what a stored entry MEANS: parser behavior (the
+// deslop version), which project is scanned, what gets collected, and the
+// summary-slimming choice (`reportRedundancy`). A mismatch discards the whole
+// store rather than risking a stale-semantics hit.
+const computeScopeHash = (config: DeslopConfig): string =>
+  sha1Hex(
+    JSON.stringify({
+      deslopVersion: resolveOwnPackageVersion(),
+      rootDir: toPosixPath(resolve(config.rootDir)),
+      entryPatterns: config.entryPatterns,
+      ignorePatterns: config.ignorePatterns,
+      includeExtensions: config.includeExtensions,
+      reportTypes: config.reportTypes,
+      includeEntryExports: config.includeEntryExports,
+      reportRedundancy: config.reportRedundancy,
+      tsConfigPath: config.tsConfigPath ?? null,
+      paths: config.paths ?? null,
+    }),
+  );
+
+const isRecordValue = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isStringArray = (value: unknown): value is string[] =>
+  Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+const isOptionalArray = (value: unknown): boolean => value === undefined || Array.isArray(value);
+
+const emptyStore = (scopeHash: string): PersistedSummaryCache => ({
+  version: SUMMARY_CACHE_SCHEMA_VERSION,
+  scopeHash,
+  fileList: null,
+  resolutions: null,
+  summaries: {},
+  packageFacts: {},
+});
+
+// Top-level shape validation only; every entry is re-validated at lookup time
+// so hand-corrupted (yet JSON-valid) entries degrade to per-item misses. The
+// single boundary cast is the JSON-revival idiom shared with core's
+// `failOpenReadJson`.
+const readPersistedStore = (cachePath: string, scopeHash: string): PersistedSummaryCache => {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (
+      isRecordValue(parsed) &&
+      parsed.version === SUMMARY_CACHE_SCHEMA_VERSION &&
+      parsed.scopeHash === scopeHash &&
+      isRecordValue(parsed.summaries) &&
+      isRecordValue(parsed.packageFacts)
+    ) {
+      const persisted = parsed as unknown as PersistedSummaryCache;
+      return {
+        version: SUMMARY_CACHE_SCHEMA_VERSION,
+        scopeHash,
+        fileList: isRecordValue(persisted.fileList) ? persisted.fileList : null,
+        resolutions:
+          isRecordValue(persisted.resolutions) &&
+          typeof persisted.resolutions.hash === "string" &&
+          isRecordValue(persisted.resolutions.entries)
+            ? persisted.resolutions
+            : null,
+        summaries: persisted.summaries,
+        packageFacts: persisted.packageFacts,
+      };
+    }
+  } catch {
+    // fall through to the empty store
+  }
+  return emptyStore(scopeHash);
+};
+
+// `detectDeadExports` is the only consumer of `localIdentifierReferences`, and
+// it only ever queries names of the module's OWN parse-time exports (synthetic
+// graph-time re-exports are skipped before the local-use check), so the
+// persisted list can be intersected down to those names without changing any
+// answer it can produce.
+const intersectLocalReferencesWithOwnExports = (parsed: ParsedSource): string[] => {
+  if (parsed.localIdentifierReferences.length === 0) return [];
+  const ownExportNames = new Set(parsed.exports.map((exportInfo) => exportInfo.name));
+  return parsed.localIdentifierReferences.filter((identifierName) =>
+    ownExportNames.has(identifierName),
+  );
+};
+
+const toPersistedArray = <ValueType>(values: ValueType[]): ValueType[] | undefined =>
+  values.length > 0 ? values : undefined;
+
+const serializeParsedSource = (
+  parsed: ParsedSource,
+  shouldPersistDryPatternFields: boolean,
+): PersistedParsedSource => ({
+  imports: toPersistedArray(parsed.imports),
+  exports: toPersistedArray(parsed.exports),
+  memberAccesses: toPersistedArray(parsed.memberAccesses),
+  wholeObjectUses: toPersistedArray(parsed.wholeObjectUses),
+  localIdentifierReferences: toPersistedArray(intersectLocalReferencesWithOwnExports(parsed)),
+  referencedFilenames: toPersistedArray(parsed.referencedFilenames),
+  ...(shouldPersistDryPatternFields
+    ? {
+        redundantTypePatterns: toPersistedArray(parsed.redundantTypePatterns),
+        identityWrappers: toPersistedArray(parsed.identityWrappers),
+        typeDefinitionHashes: toPersistedArray(parsed.typeDefinitionHashes),
+        inlineTypeLiterals: toPersistedArray(parsed.inlineTypeLiterals),
+        simplifiableFunctions: toPersistedArray(parsed.simplifiableFunctions),
+        simplifiableExpressions: toPersistedArray(parsed.simplifiableExpressions),
+        duplicateConstantCandidates: toPersistedArray(parsed.duplicateConstantCandidates),
+      }
+    : {}),
+  errors: toPersistedArray(parsed.errors.map((deslopError) => deslopError.toJSON())),
+});
+
+const isPersistedErrorJson = (value: unknown): value is DeslopErrorJson =>
+  isRecordValue(value) &&
+  typeof value.code === "string" &&
+  typeof value.module === "string" &&
+  typeof value.message === "string";
+
+const PERSISTED_SOURCE_ARRAY_FIELDS = [
+  "imports",
+  "exports",
+  "memberAccesses",
+  "wholeObjectUses",
+  "localIdentifierReferences",
+  "referencedFilenames",
+  "redundantTypePatterns",
+  "identityWrappers",
+  "typeDefinitionHashes",
+  "inlineTypeLiterals",
+  "simplifiableFunctions",
+  "simplifiableExpressions",
+  "duplicateConstantCandidates",
+  "errors",
+] as const;
+
+const reviveParsedSource = (persisted: unknown): ParsedSource | null => {
+  if (!isRecordValue(persisted)) return null;
+  for (const fieldName of PERSISTED_SOURCE_ARRAY_FIELDS) {
+    if (!isOptionalArray(persisted[fieldName])) return null;
+  }
+  const source = persisted as unknown as PersistedParsedSource;
+  const persistedErrors = source.errors ?? [];
+  if (!persistedErrors.every(isPersistedErrorJson)) return null;
+  return {
+    imports: source.imports ?? [],
+    exports: source.exports ?? [],
+    memberAccesses: source.memberAccesses ?? [],
+    wholeObjectUses: source.wholeObjectUses ?? [],
+    localIdentifierReferences: source.localIdentifierReferences ?? [],
+    referencedFilenames: source.referencedFilenames ?? [],
+    redundantTypePatterns: source.redundantTypePatterns ?? [],
+    identityWrappers: source.identityWrappers ?? [],
+    typeDefinitionHashes: source.typeDefinitionHashes ?? [],
+    inlineTypeLiterals: source.inlineTypeLiterals ?? [],
+    simplifiableFunctions: source.simplifiableFunctions ?? [],
+    simplifiableExpressions: source.simplifiableExpressions ?? [],
+    duplicateConstantCandidates: source.duplicateConstantCandidates ?? [],
+    errors: persistedErrors.map(
+      (errorJson) =>
+        new DeslopError({
+          code: errorJson.code,
+          module: errorJson.module,
+          severity: errorJson.severity,
+          message: errorJson.message,
+          path: errorJson.path,
+          detail: errorJson.detail,
+        }),
+    ),
+  };
+};
+
+const atomicWriteFile = (filePath: string, contents: string): void => {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const temporaryPath = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(temporaryPath, contents);
+    renameSync(temporaryPath, filePath);
+  } catch {
+    // A cache that cannot persist must never break the analysis.
+  }
+};
+
+const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCache => {
+  const scopeHash = computeScopeHash(config);
+  const store = readPersistedStore(cachePath, scopeHash);
+  const walkRoot = toPosixPath(resolve(config.rootDir));
+  const walkedStats = walkTreeStats(config.rootDir);
+  const collectHash = computeCollectHash(walkedStats);
+  const resolutionHash = computeResolutionHash(collectHash, walkedStats);
+  const shouldPersistDryPatternFields = config.reportRedundancy;
+
+  if (store.resolutions === null || store.resolutions.hash !== resolutionHash) {
+    store.resolutions = { hash: resolutionHash, entries: {} };
+  }
+  const resolutionEntries = store.resolutions.entries;
+
+  let isDirty = false;
+  const activeSummaryPaths = new Set<string>();
+  const activeResolutionKeys = new Set<string>();
+  const activeFactPaths = new Set<string>();
+  const sortedNameSetMemo = new WeakMap<ReadonlySet<string>, SortedNameSet>();
+
+  const statOf = (filePath: string): FileStatFingerprint | null => {
+    const walked = walkedStats.get(filePath);
+    if (walked) return walked;
+    try {
+      const fileStat = statSync(filePath);
+      return { m: fileStat.mtimeMs, s: fileStat.size };
+    } catch {
+      return null;
+    }
+  };
+
+  return {
+    lookupFileList: () => {
+      const cachedFileList = store.fileList;
+      if (
+        cachedFileList === null ||
+        cachedFileList.hash !== collectHash ||
+        !isStringArray(cachedFileList.files)
+      ) {
+        return null;
+      }
+      return cachedFileList.files.map((filePath, fileIndex) => ({
+        index: fileIndex,
+        path: filePath,
+      }));
+    },
+
+    storeFileList: (files) => {
+      store.fileList = {
+        hash: collectHash,
+        files: files.map((file) => file.path),
+      };
+      isDirty = true;
+    },
+
+    lookupSummary: (filePath) => {
+      const cachedSummary = store.summaries[filePath];
+      if (!isRecordValue(cachedSummary)) return null;
+      const fileStat = statOf(filePath);
+      if (!fileStat || fileStat.m !== cachedSummary.m || fileStat.s !== cachedSummary.s) {
+        return null;
+      }
+      const revived = reviveParsedSource(cachedSummary.p);
+      if (revived === null) return null;
+      activeSummaryPaths.add(filePath);
+      return revived;
+    },
+
+    storeSummary: (filePath, parsed) => {
+      const fileStat = statOf(filePath);
+      if (!fileStat) return;
+      store.summaries[filePath] = {
+        m: fileStat.m,
+        s: fileStat.s,
+        p: serializeParsedSource(parsed, shouldPersistDryPatternFields),
+      };
+      activeSummaryPaths.add(filePath);
+      isDirty = true;
+    },
+
+    lookupResolution: (specifier, fromFile) => {
+      const resolutionKey = `${dirname(fromFile)}::${specifier}`;
+      const cachedResolution = resolutionEntries[resolutionKey];
+      if (!isRecordValue(cachedResolution) || typeof cachedResolution.e !== "boolean") {
+        return null;
+      }
+      activeResolutionKeys.add(resolutionKey);
+      return {
+        resolvedPath: typeof cachedResolution.p === "string" ? cachedResolution.p : undefined,
+        isExternal: cachedResolution.e,
+        packageName: typeof cachedResolution.n === "string" ? cachedResolution.n : undefined,
+      };
+    },
+
+    storeResolution: (specifier, fromFile, resolved) => {
+      const resolutionKey = `${dirname(fromFile)}::${specifier}`;
+      resolutionEntries[resolutionKey] = {
+        p: resolved.resolvedPath ?? null,
+        e: resolved.isExternal,
+        n: resolved.packageName ?? null,
+      };
+      activeResolutionKeys.add(resolutionKey);
+      isDirty = true;
+    },
+
+    matchPackageNames: (filePath, kind, names, matcher) => {
+      let nameSet = sortedNameSetMemo.get(names);
+      if (nameSet === undefined) {
+        const sortedNames = [...names].sort();
+        nameSet = { sortedNames, hash: sha1Hex(sortedNames.join("\n")) };
+        sortedNameSetMemo.set(names, nameSet);
+      }
+      activeFactPaths.add(filePath);
+      const fileStat = statOf(filePath);
+      const existingEntry = store.packageFacts[filePath];
+      const validEntry =
+        fileStat !== null &&
+        isRecordValue(existingEntry) &&
+        existingEntry.m === fileStat.m &&
+        existingEntry.s === fileStat.s
+          ? existingEntry
+          : null;
+      const existingMatch = validEntry?.[kind];
+      if (
+        isRecordValue(existingMatch) &&
+        existingMatch.h === nameSet.hash &&
+        isStringArray(existingMatch.matched)
+      ) {
+        return existingMatch.matched;
+      }
+      const content = readFileSync(filePath, "utf-8");
+      const matchedNames = nameSet.sortedNames.filter((packageName) =>
+        matcher(content, packageName),
+      );
+      if (fileStat !== null) {
+        const factEntry = validEntry ?? { m: fileStat.m, s: fileStat.s };
+        factEntry[kind] = { h: nameSet.hash, matched: matchedNames };
+        store.packageFacts[filePath] = factEntry;
+        isDirty = true;
+      }
+      return matchedNames;
+    },
+
+    matchWalkedFiles: (query) => {
+      if (toPosixPath(resolve(query.cwd)) !== walkRoot) return null;
+      const positiveMatcher = compileGlobAlternation(query.patterns, query.dot === true);
+      if (positiveMatcher === null) return null;
+      const ignoreMatcher =
+        query.ignore.length > 0 ? compileGlobAlternation(query.ignore, true) : null;
+      if (query.ignore.length > 0 && ignoreMatcher === null) return null;
+      const rootPrefixLength = walkRoot.length + 1;
+      const matchedPaths: string[] = [];
+      for (const filePath of walkedStats.keys()) {
+        const relativePath = filePath.slice(rootPrefixLength);
+        if (countPathSegments(relativePath) > query.deep) continue;
+        if (ignoreMatcher !== null && ignoreMatcher.test(relativePath)) continue;
+        if (positiveMatcher.test(relativePath)) matchedPaths.push(filePath);
+      }
+      return matchedPaths.sort();
+    },
+
+    save: () => {
+      if (!isDirty) return;
+      const compactedSummaries: Record<string, PersistedSummaryEntry> = {};
+      for (const filePath of activeSummaryPaths) {
+        const summaryEntry = store.summaries[filePath];
+        if (summaryEntry !== undefined) compactedSummaries[filePath] = summaryEntry;
+      }
+      const compactedFacts: Record<string, PersistedPackageFactEntry> = {};
+      for (const filePath of activeFactPaths) {
+        const factEntry = store.packageFacts[filePath];
+        if (factEntry !== undefined) compactedFacts[filePath] = factEntry;
+      }
+      const compactedResolutions: Record<string, PersistedResolution> = {};
+      for (const resolutionKey of activeResolutionKeys) {
+        const resolutionEntry = resolutionEntries[resolutionKey];
+        if (resolutionEntry !== undefined) compactedResolutions[resolutionKey] = resolutionEntry;
+      }
+      const serialized = JSON.stringify({
+        version: SUMMARY_CACHE_SCHEMA_VERSION,
+        scopeHash,
+        fileList: store.fileList,
+        resolutions: { hash: resolutionHash, entries: compactedResolutions },
+        summaries: compactedSummaries,
+        packageFacts: compactedFacts,
+      } satisfies PersistedSummaryCache);
+      if (serialized.length > SUMMARY_CACHE_MAX_BYTES) return;
+      atomicWriteFile(cachePath, serialized);
+    },
+  };
+};
+
+/**
+ * Loads the incremental cache configured at `config.incrementalCachePath`.
+ * Returns `null` (analysis runs exactly as without a cache) when the path is
+ * unset or anything about initialization fails.
+ */
+export const loadSummaryCache = (config: DeslopConfig): SummaryCache | null => {
+  if (!config.incrementalCachePath) return null;
+  try {
+    return createSummaryCache(config.incrementalCachePath, config);
+  } catch {
+    return null;
+  }
+};
diff --git a/packages/deslop-js/src/types.ts b/packages/deslop-js/src/types.ts
index 937790d0c8..da1f8f7c84 100644
--- a/packages/deslop-js/src/types.ts
+++ b/packages/deslop-js/src/types.ts
@@ -626,6 +626,17 @@ export interface ScanResult {
   totalFiles: number;
   totalExports: number;
   analysisTimeMs: number;
+  /**
+   * Incremental-cache outcome for this run's per-file parse phase: how many
+   * collected files were served from cached summaries vs freshly parsed.
+   * Present only when `incrementalCachePath` was set and the cache loaded.
+   */
+  incrementalCacheStats?: IncrementalCacheStats;
+}
+
+export interface IncrementalCacheStats {
+  summaryHits: number;
+  summaryMisses: number;
 }
 
 export interface ResolvedEntries {
@@ -652,6 +663,18 @@ export interface DeslopConfig {
   includeExtensions: string[];
   tsConfigPath: string | undefined;
   paths: Record<string, string[]> | undefined;
+  /**
+   * Path of the on-disk incremental analysis cache (per-file parse summaries,
+   * the collected file list, the module-resolution map, and
+   * `detectStalePackages`' per-file package-reference facts; entry resolution
+   * always runs live). Unset (the default) means no caching — every run
+   * analyzes from scratch. The file is created on first use, validated
+   * stat-by-stat against the current tree on every run, and fails open on any
+   * corruption or version mismatch; results are byte-identical to an uncached
+   * run. Point it OUTSIDE the analyzed tree (e.g. `node_modules/.cache/...`)
+   * so its own writes don't churn the file fingerprint.
+   */
+  incrementalCachePath: string | undefined;
   reportTypes: boolean;
   includeEntryExports: boolean;
   reportRedundancy: boolean;
diff --git a/packages/deslop-js/tests/helpers/analyze-in-subprocess.ts b/packages/deslop-js/tests/helpers/analyze-in-subprocess.ts
new file mode 100644
index 0000000000..42ca39d1a6
--- /dev/null
+++ b/packages/deslop-js/tests/helpers/analyze-in-subprocess.ts
@@ -0,0 +1,10 @@
+// One-shot analyze runner for tests that need cross-PROCESS cache semantics
+// (the resolver keeps module-level fs/content caches, so a config-file content
+// edit is only observable from a fresh process — exactly how react-doctor's
+// dead-code worker runs deslop). Reads a partial DeslopConfig as argv JSON and
+// prints the ScanResult as JSON (DeslopError serializes via toJSON).
+import { analyze, defineConfig } from "../../src/index.js";
+
+const config = JSON.parse(process.argv[2]);
+const result = await analyze(defineConfig(config));
+process.stdout.write(JSON.stringify(result));
diff --git a/packages/deslop-js/tests/summary-cache.test.ts b/packages/deslop-js/tests/summary-cache.test.ts
new file mode 100644
index 0000000000..09a82f1db1
--- /dev/null
+++ b/packages/deslop-js/tests/summary-cache.test.ts
@@ -0,0 +1,670 @@
+import { after, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+  utimesSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import { dirname, join, relative } from "node:path";
+import { analyze, defineConfig } from "../src/index.js";
+import type { DeslopConfig, ScanResult } from "../src/types.js";
+import { SUMMARY_CACHE_SCHEMA_VERSION } from "../src/constants.js";
+import { loadSummaryCache } from "../src/summary-cache.js";
+
+// Canonicalized so deslop's fast-glob paths line up with oxc-resolver's —
+// `os.tmpdir()` is a symlink into /private on macOS.
+const temporaryRoot = realpathSync(mkdtempSync(join(os.tmpdir(), "deslop-summary-cache-")));
+
+after(() => {
+  rmSync(temporaryRoot, { recursive: true, force: true });
+});
+
+const FIXTURE_FILES: Record<string, string> = {
+  "package.json": JSON.stringify({
+    name: "summary-cache-fixture",
+    type: "module",
+    dependencies: { "used-dep": "1.0.0", "doc-dep": "1.0.0", "unused-dep": "1.0.0" },
+  }),
+  "tsconfig.json": JSON.stringify({
+    compilerOptions: { target: "es2022", module: "esnext", moduleResolution: "bundler" },
+  }),
+  "README.md": 'Usage:\n\n```ts\nimport { helper } from "doc-dep";\n```\n',
+  "src/index.ts":
+    'import "used-dep";\n' +
+    'import { usedFunction } from "./used.js";\n' +
+    'import { targetValue } from "./target";\n' +
+    "export const entryValue = usedFunction() + targetValue;\n",
+  "src/used.ts":
+    "export const usedFunction = (): number => 1;\n" +
+    "export const staleExport = (): number => 2;\n",
+  "src/target/index.ts": "export const targetValue = 3;\n",
+  "src/orphan.ts": "export const orphanValue = 4;\n",
+};
+
+interface FixtureWorkspace {
+  readonly projectDirectory: string;
+  readonly cachePath: string;
+}
+
+let fixtureCounter = 0;
+
+const buildFixture = (extraFiles: Record<string, string> = {}): FixtureWorkspace => {
+  fixtureCounter += 1;
+  const workspaceDirectory = join(temporaryRoot, `case-${fixtureCounter}`);
+  const projectDirectory = join(workspaceDirectory, "project");
+  for (const [relativePath, contents] of Object.entries({ ...FIXTURE_FILES, ...extraFiles })) {
+    const fullPath = join(projectDirectory, relativePath);
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeFileSync(fullPath, contents);
+  }
+  // The cache lives OUTSIDE the analyzed tree so its own writes don't churn
+  // the tree fingerprint — mirroring react-doctor's node_modules/.cache home.
+  return { projectDirectory, cachePath: join(workspaceDirectory, "cache", "summaries.json") };
+};
+
+const scan = async (
+  workspace: FixtureWorkspace,
+  options: { cached: boolean; overrides?: Partial<DeslopConfig> },
+): Promise<ScanResult> =>
+  analyze(
+    defineConfig({
+      rootDir: workspace.projectDirectory,
+      ...(options.cached ? { incrementalCachePath: workspace.cachePath } : {}),
+      ...options.overrides,
+    }),
+  );
+
+// Cross-process scan for edits the in-process resolver content caches would
+// hide (bundler-config content changes) — the dead-code worker's real model.
+const scanInSubprocess = (
+  workspace: FixtureWorkspace,
+  options: { cached: boolean },
+): ScanResult => {
+  const runnerPath = join(import.meta.dirname, "helpers", "analyze-in-subprocess.ts");
+  const stdout = execFileSync(
+    process.execPath,
+    [
+      "--import",
+      "tsx",
+      runnerPath,
+      JSON.stringify({
+        rootDir: workspace.projectDirectory,
+        ...(options.cached ? { incrementalCachePath: workspace.cachePath } : {}),
+      }),
+    ],
+    { cwd: join(import.meta.dirname, ".."), encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 },
+  );
+  return JSON.parse(stdout);
+};
+
+// Everything a consumer can observe from the graph analysis (plus the
+// redundancy findings, to prove full-fidelity summary round-trips), normalized
+// to a stable order with project-relative paths.
+const resultSignature = (result: ScanResult, projectDirectory: string): string => {
+  const relativePath = (filePath: string): string => relative(projectDirectory, filePath);
+  return JSON.stringify({
+    unusedFiles: result.unusedFiles.map((entry) => relativePath(entry.path)).sort(),
+    unusedExports: result.unusedExports
+      .map(
+        (entry) =>
+          `${relativePath(entry.path)}:${entry.line}:${entry.column}:${entry.name}` +
+          `${entry.isTypeOnly ? ":type" : ""}`,
+      )
+      .sort(),
+    unusedDependencies: result.unusedDependencies
+      .map((entry) => `${entry.name}:${entry.isDevDependency ? "dev" : "prod"}`)
+      .sort(),
+    circularDependencies: result.circularDependencies
+      .map((cycle) => cycle.files.map(relativePath).join(" -> "))
+      .sort(),
+    duplicateTypeDefinitions: result.duplicateTypeDefinitions
+      .map((duplicate) =>
+        duplicate.instances
+          .map((instance) => `${relativePath(instance.path)}:${instance.typeName}`)
+          .sort()
+          .join(","),
+      )
+      .sort(),
+    simplifiableExpressions: result.simplifiableExpressions
+      .map((entry) => `${entry.kind}:${entry.snippet}`)
+      .sort(),
+    errorCodes: result.analysisErrors.map((analysisError) => analysisError.code).sort(),
+  });
+};
+
+const unusedFileNames = (result: ScanResult, projectDirectory: string): string[] =>
+  result.unusedFiles.map((entry) => relative(projectDirectory, entry.path)).sort();
+
+const unusedExportNames = (result: ScanResult): string[] =>
+  result.unusedExports.map((entry) => entry.name).sort();
+
+const unusedDependencyNames = (result: ScanResult): string[] =>
+  result.unusedDependencies.map((entry) => entry.name).sort();
+
+describe("summary cache", () => {
+  it("warm run over an unchanged tree matches the cold run and an uncached control", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(existsSync(workspace.cachePath), "cold run should write the cache file");
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+
+    const coldSignature = resultSignature(cold, workspace.projectDirectory);
+    assert.equal(resultSignature(warm, workspace.projectDirectory), coldSignature);
+    assert.equal(resultSignature(control, workspace.projectDirectory), coldSignature);
+
+    // The fixture must exercise every consumed finding kind, or equality
+    // between empty results would be a vacuous pass.
+    assert.ok(unusedFileNames(cold, workspace.projectDirectory).includes("src/orphan.ts"));
+    assert.ok(unusedExportNames(cold).includes("staleExport"));
+    assert.deepEqual(unusedDependencyNames(cold), ["unused-dep"]);
+  });
+
+  it("skips the save when nothing changed", async () => {
+    const workspace = buildFixture();
+    await scan(workspace, { cached: true });
+    const bytesAfterCold = readFileSync(workspace.cachePath, "utf-8");
+    const mtimeAfterCold = statSync(workspace.cachePath).mtimeMs;
+    await scan(workspace, { cached: true });
+    assert.equal(readFileSync(workspace.cachePath, "utf-8"), bytesAfterCold);
+    assert.equal(statSync(workspace.cachePath).mtimeMs, mtimeAfterCold);
+  });
+
+  it("reflects a single edited file and matches an uncached control", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(!unusedExportNames(cold).includes("freshlyUnused"));
+
+    const editedPath = join(workspace.projectDirectory, "src/used.ts");
+    writeFileSync(
+      editedPath,
+      `${readFileSync(editedPath, "utf-8")}export const freshlyUnused = (): number => 5;\n`,
+    );
+
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.ok(unusedExportNames(warm).includes("freshlyUnused"));
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("re-resolves when an added file shadows an existing import target", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(
+      !unusedFileNames(cold, workspace.projectDirectory).includes("src/target/index.ts"),
+      "before the shadow, ./target must resolve to target/index.ts",
+    );
+
+    // `./target` now resolves to the FILE, orphaning the directory index —
+    // exactly the resolution flip a per-file resolved-path cache would miss.
+    writeFileSync(
+      join(workspace.projectDirectory, "src/target.ts"),
+      "export const targetValue = 30;\n",
+    );
+
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.ok(unusedFileNames(warm, workspace.projectDirectory).includes("src/target/index.ts"));
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("reflects a deleted file and compacts its entries out of the store", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(unusedFileNames(cold, workspace.projectDirectory).includes("src/orphan.ts"));
+
+    const orphanPath = join(workspace.projectDirectory, "src/orphan.ts");
+    unlinkSync(orphanPath);
+
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.ok(!unusedFileNames(warm, workspace.projectDirectory).includes("src/orphan.ts"));
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+
+    const persisted = JSON.parse(readFileSync(workspace.cachePath, "utf-8"));
+    const summaryPaths = Object.keys(persisted.summaries);
+    assert.ok(summaryPaths.length > 0);
+    assert.ok(
+      summaryPaths.every((summaryPath) => !summaryPath.endsWith("orphan.ts")),
+      "the deleted file's summary must be compacted away",
+    );
+  });
+
+  it("reflects a manifest edit and matches an uncached control", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+    assert.deepEqual(unusedDependencyNames(cold), ["unused-dep"]);
+
+    const manifestPath = join(workspace.projectDirectory, "package.json");
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    manifest.dependencies["second-unused-dep"] = "1.0.0";
+    writeFileSync(manifestPath, JSON.stringify(manifest));
+
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.deepEqual(unusedDependencyNames(warm), ["second-unused-dep", "unused-dep"]);
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("drops the resolution map when a bundler alias config changes content", async () => {
+    // The alias target is deliberately NOT "./"-relative so the config-string
+    // entry heuristic ignores it — the dest files are reachable only through
+    // MODULE RESOLUTION, isolating the resolution-map invalidation under test.
+    const workspace = buildFixture({
+      "src/index.ts":
+        'import "used-dep";\n' +
+        'import { usedFunction } from "./used.js";\n' +
+        'import { targetValue } from "./target";\n' +
+        'import { aliased } from "$dest";\n' +
+        "export const entryValue = usedFunction() + targetValue + aliased;\n",
+      "src/dest-a.ts": "export const aliased = 10;\n",
+      "src/dest-b.ts": "export const aliased = 20;\n",
+      "vite.config.ts": 'export default { resolve: { alias: { "$dest": "src/dest-a.ts" } } };\n',
+    });
+    // Subprocess scans: the resolver's in-process content caches would hide a
+    // config-file content edit from repeat `analyze()` calls in one process
+    // (pre-existing behavior, unrelated to the summary cache); the dead-code
+    // worker spawns a fresh process per scan, which this mirrors.
+    const cold = scanInSubprocess(workspace, { cached: true });
+    assert.ok(unusedFileNames(cold, workspace.projectDirectory).includes("src/dest-b.ts"));
+    assert.ok(!unusedFileNames(cold, workspace.projectDirectory).includes("src/dest-a.ts"));
+
+    // Same file NAME set — only the alias TARGET changed, which only the
+    // bundler-config content fingerprint can catch.
+    writeFileSync(
+      join(workspace.projectDirectory, "vite.config.ts"),
+      'export default { resolve: { alias: { "$dest": "src/dest-b.ts" } } };\n',
+    );
+
+    const warm = scanInSubprocess(workspace, { cached: true });
+    const control = scanInSubprocess(workspace, { cached: false });
+    assert.ok(unusedFileNames(warm, workspace.projectDirectory).includes("src/dest-a.ts"));
+    assert.ok(!unusedFileNames(warm, workspace.projectDirectory).includes("src/dest-b.ts"));
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("drops the resolution map when a tsconfig paths alias changes content", async () => {
+    const workspace = buildFixture({
+      "src/index.ts":
+        'import "used-dep";\n' +
+        'import { usedFunction } from "./used.js";\n' +
+        'import { targetValue } from "./target";\n' +
+        'import { aliased } from "@dest";\n' +
+        "export const entryValue = usedFunction() + targetValue + aliased;\n",
+      "src/dest-a.ts": "export const aliased = 10;\n",
+      "src/dest-b.ts": "export const aliased = 20;\n",
+      "tsconfig.json": JSON.stringify({
+        compilerOptions: {
+          target: "es2022",
+          module: "esnext",
+          moduleResolution: "bundler",
+          baseUrl: ".",
+          paths: { "@dest": ["./src/dest-a.ts"] },
+        },
+      }),
+    });
+    const cold = scanInSubprocess(workspace, { cached: true });
+    assert.ok(unusedFileNames(cold, workspace.projectDirectory).includes("src/dest-b.ts"));
+    assert.ok(!unusedFileNames(cold, workspace.projectDirectory).includes("src/dest-a.ts"));
+
+    // tsconfig files are stat-fingerprinted manifest-like inputs: the edit
+    // invalidates BOTH the collected-file-list key and the resolution map.
+    writeFileSync(
+      join(workspace.projectDirectory, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          target: "es2022",
+          module: "esnext",
+          moduleResolution: "bundler",
+          baseUrl: ".",
+          paths: { "@dest": ["./src/dest-b.ts"] },
+        },
+      }),
+    );
+
+    const warm = scanInSubprocess(workspace, { cached: true });
+    const control = scanInSubprocess(workspace, { cached: false });
+    assert.ok(unusedFileNames(warm, workspace.projectDirectory).includes("src/dest-a.ts"));
+    assert.ok(!unusedFileNames(warm, workspace.projectDirectory).includes("src/dest-b.ts"));
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("keeps entry resolution live: a config entry-string edit lands without invalidation", async () => {
+    // `resolveEntries` reads config CONTENT (here vite.config.ts's "./"-
+    // relative entry strings), which no name-based fingerprint can validate —
+    // so entries must never be served from the cache.
+    const workspace = buildFixture({
+      "src/dest-a.ts": "export const standalone = 10;\n",
+      "src/dest-b.ts": "export const standalone = 20;\n",
+      "vite.config.ts": 'export default { build: { lib: { entry: "./src/dest-a.ts" } } };\n',
+    });
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(unusedFileNames(cold, workspace.projectDirectory).includes("src/dest-b.ts"));
+    assert.ok(!unusedFileNames(cold, workspace.projectDirectory).includes("src/dest-a.ts"));
+
+    writeFileSync(
+      join(workspace.projectDirectory, "vite.config.ts"),
+      'export default { build: { lib: { entry: "./src/dest-b.ts" } } };\n',
+    );
+
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.ok(unusedFileNames(warm, workspace.projectDirectory).includes("src/dest-a.ts"));
+    assert.ok(!unusedFileNames(warm, workspace.projectDirectory).includes("src/dest-b.ts"));
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("fails open on a corrupt cache file and rewrites it", async () => {
+    const workspace = buildFixture();
+    mkdirSync(dirname(workspace.cachePath), { recursive: true });
+    writeFileSync(workspace.cachePath, "{ this is not json");
+
+    const corrupted = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.equal(
+      resultSignature(corrupted, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+    const persisted = JSON.parse(readFileSync(workspace.cachePath, "utf-8"));
+    assert.equal(persisted.version, SUMMARY_CACHE_SCHEMA_VERSION);
+  });
+
+  it("discards a schema-version-mismatched store instead of trusting its entries", async () => {
+    const workspace = buildFixture();
+    await scan(workspace, { cached: true });
+
+    const persisted = JSON.parse(readFileSync(workspace.cachePath, "utf-8"));
+    persisted.version = SUMMARY_CACHE_SCHEMA_VERSION + 999;
+    // Poison every stored summary: if the version gate ever stops discarding,
+    // the equivalence assertion below fails loudly.
+    for (const summaryPath of Object.keys(persisted.summaries)) {
+      persisted.summaries[summaryPath].p = { imports: "poisoned" };
+    }
+    writeFileSync(workspace.cachePath, JSON.stringify(persisted));
+
+    const rebuilt = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.equal(
+      resultSignature(rebuilt, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+    const rewritten = JSON.parse(readFileSync(workspace.cachePath, "utf-8"));
+    assert.equal(rewritten.version, SUMMARY_CACHE_SCHEMA_VERSION);
+  });
+
+  it("treats a poisoned summary entry as a per-file miss", async () => {
+    const workspace = buildFixture();
+    await scan(workspace, { cached: true });
+
+    const persisted = JSON.parse(readFileSync(workspace.cachePath, "utf-8"));
+    const usedSummaryPath = Object.keys(persisted.summaries).find((summaryPath) =>
+      summaryPath.endsWith("used.ts"),
+    );
+    assert.ok(usedSummaryPath);
+    persisted.summaries[usedSummaryPath].p = { imports: "poisoned" };
+    writeFileSync(workspace.cachePath, JSON.stringify(persisted));
+
+    const warm = await scan(workspace, { cached: true });
+    const control = await scan(workspace, { cached: false });
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
+  it("writes atomically, leaving no temp files behind", async () => {
+    const workspace = buildFixture();
+    await scan(workspace, { cached: true });
+    const cacheDirectoryEntries = readdirSync(dirname(workspace.cachePath));
+    assert.deepEqual(
+      cacheDirectoryEntries.filter((entryName) => entryName.endsWith(".tmp")),
+      [],
+    );
+  });
+
+  it("documents the accepted blind spot: an mtime+size-preserving edit is invisible", async () => {
+    // `blind.ts` must be REACHABLE (unused exports are only reported on
+    // reachable modules), so the entry imports its `keep` export.
+    const workspace = buildFixture({
+      "src/blind.ts": "export const keep = 1;\nexport const aa = 1;\n",
+      "src/index.ts":
+        'import "used-dep";\n' +
+        'import { usedFunction } from "./used.js";\n' +
+        'import { targetValue } from "./target";\n' +
+        'import { keep } from "./blind.js";\n' +
+        "export const entryValue = usedFunction() + targetValue + keep;\n",
+    });
+    const pinnedTime = new Date(Date.now() - 60_000);
+    const blindPath = join(workspace.projectDirectory, "src/blind.ts");
+    utimesSync(blindPath, pinnedTime, pinnedTime);
+
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(unusedExportNames(cold).includes("aa"));
+
+    // Same byte length, same pinned mtime — the stat-based fingerprint cannot
+    // see this edit (shared with core's whole-result and lint caches).
+    writeFileSync(blindPath, "export const keep = 1;\nexport const ab = 1;\n");
+    utimesSync(blindPath, pinnedTime, pinnedTime);
+
+    const warm = await scan(workspace, { cached: true });
+    assert.ok(unusedExportNames(warm).includes("aa"), "stale summary is served");
+    assert.ok(!unusedExportNames(warm).includes("ab"));
+
+    const control = await scan(workspace, { cached: false });
+    assert.ok(unusedExportNames(control).includes("ab"), "an uncached run sees the edit");
+  });
+
+  it("round-trips redundancy findings at full fidelity, and slims them when disabled", async () => {
+    const duplicateTypeFiles = {
+      "src/shape-a.ts":
+        "export interface Shape { id: string; name: string; size: number }\n" +
+        "export const shapeA: Shape = { id: 'a', name: 'a', size: 1 };\n",
+      "src/shape-b.ts":
+        "export interface Shape { id: string; name: string; size: number }\n" +
+        "export const shapeB: Shape = { id: 'b', name: 'b', size: 2 };\n",
+      "src/index.ts":
+        'import "used-dep";\n' +
+        'import { usedFunction } from "./used.js";\n' +
+        'import { targetValue } from "./target";\n' +
+        'import { shapeA } from "./shape-a.js";\n' +
+        'import { shapeB } from "./shape-b.js";\n' +
+        "export const entryValue = usedFunction() + targetValue + shapeA.size + shapeB.size;\n",
+    };
+
+    const fullFidelity = buildFixture(duplicateTypeFiles);
+    const cold = await scan(fullFidelity, { cached: true });
+    assert.ok(
+      cold.duplicateTypeDefinitions.some((duplicate) =>
+        duplicate.instances.some((instance) => instance.typeName === "Shape"),
+      ),
+      "the fixture must produce a redundancy finding",
+    );
+    const warm = await scan(fullFidelity, { cached: true });
+    const control = await scan(fullFidelity, { cached: false });
+    assert.equal(
+      resultSignature(warm, fullFidelity.projectDirectory),
+      resultSignature(control, fullFidelity.projectDirectory),
+    );
+    assert.ok(readFileSync(fullFidelity.cachePath, "utf-8").includes('"typeDefinitionHashes"'));
+
+    // react-doctor's worker config: the DRY-pattern consumers are off, so the
+    // summaries must not pay for their fields.
+    const slimOverrides: Partial<DeslopConfig> = {
+      reportRedundancy: false,
+      reportCodeQuality: false,
+      semantic: { enabled: false } as DeslopConfig["semantic"],
+    };
+    const slimmed = buildFixture(duplicateTypeFiles);
+    const slimCold = await scan(slimmed, { cached: true, overrides: slimOverrides });
+    const slimWarm = await scan(slimmed, { cached: true, overrides: slimOverrides });
+    const slimControl = await scan(slimmed, { cached: false, overrides: slimOverrides });
+    assert.equal(
+      resultSignature(slimWarm, slimmed.projectDirectory),
+      resultSignature(slimControl, slimmed.projectDirectory),
+    );
+    assert.equal(
+      resultSignature(slimCold, slimmed.projectDirectory),
+      resultSignature(slimControl, slimmed.projectDirectory),
+    );
+    const slimmedCacheBytes = readFileSync(slimmed.cachePath, "utf-8");
+    assert.ok(!slimmedCacheBytes.includes('"typeDefinitionHashes"'));
+    assert.ok(!slimmedCacheBytes.includes('"simplifiableExpressions"'));
+  });
+
+  it("reports summary hit/miss stats only when the cache is active", async () => {
+    const workspace = buildFixture();
+    const collectedFileCount = 4;
+
+    const control = await scan(workspace, { cached: false });
+    assert.equal(control.incrementalCacheStats, undefined);
+
+    const cold = await scan(workspace, { cached: true });
+    assert.deepEqual(cold.incrementalCacheStats, {
+      summaryHits: 0,
+      summaryMisses: collectedFileCount,
+    });
+
+    const warm = await scan(workspace, { cached: true });
+    assert.deepEqual(warm.incrementalCacheStats, {
+      summaryHits: collectedFileCount,
+      summaryMisses: 0,
+    });
+
+    const editedPath = join(workspace.projectDirectory, "src/used.ts");
+    writeFileSync(editedPath, `${readFileSync(editedPath, "utf-8")}export const extra = 6;\n`);
+    const oneTouched = await scan(workspace, { cached: true });
+    assert.deepEqual(oneTouched.incrementalCacheStats, {
+      summaryHits: collectedFileCount - 1,
+      summaryMisses: 1,
+    });
+  });
+
+  it("answers the stale-package glob queries from the walk byte-identically to fast-glob", async () => {
+    const workspace = buildFixture({
+      "packages/one/package.json": JSON.stringify({ name: "one" }),
+      "packages/one/nested/two/three/package.json": JSON.stringify({ name: "too-deep-for-5" }),
+      "dist/package.json": JSON.stringify({ name: "ignored-dist" }),
+      ".hidden/package.json": JSON.stringify({ name: "dot-excluded" }),
+      "docs/guide/deep/topics/more/usage.md": "# usage\n",
+      "docs/.dot.md": "# dot file\n",
+      "CHANGELOG.md": "# changes\n",
+      ".storybook/main.ts": "export default {};\n",
+      "tools/webpack.dev.config.js": "module.exports = {};\n",
+      "apps/site/tsconfig.build.json": "{}\n",
+      "linked-target/inner/package.json": JSON.stringify({ name: "via-symlink" }),
+    });
+    symlinkSync(
+      join(workspace.projectDirectory, "linked-target"),
+      join(workspace.projectDirectory, "linked"),
+    );
+
+    const cache = loadSummaryCache(
+      defineConfig({
+        rootDir: workspace.projectDirectory,
+        incrementalCachePath: workspace.cachePath,
+      }),
+    );
+    assert.ok(cache, "the cache must load for this fixture");
+
+    const queries: Array<{
+      patterns: string[];
+      ignore: string[];
+      deep: number;
+      dot?: boolean;
+    }> = [
+      {
+        patterns: ["**/package.json"],
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+        deep: 5,
+      },
+      {
+        patterns: [".storybook/main.{js,ts,mjs,cjs}", "**/webpack*.config*.{js,ts,mjs,cjs}"],
+        ignore: ["**/node_modules/**"],
+        dot: true,
+        deep: 3,
+      },
+      {
+        patterns: ["**/*.{mdx,md}"],
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/CHANGELOG.md"],
+        deep: 6,
+      },
+      {
+        patterns: ["tsconfig.json", "tsconfig.*.json", "**/tsconfig.json", "**/tsconfig.*.json"],
+        ignore: ["**/node_modules/**"],
+        dot: false,
+        deep: 4,
+      },
+    ];
+    const fg = (await import("fast-glob")).default;
+    for (const query of queries) {
+      const walked = cache.matchWalkedFiles({ cwd: workspace.projectDirectory, ...query });
+      assert.ok(walked, "the walk root matches, so the query must be answerable");
+      const globbed = fg
+        .sync(query.patterns, {
+          cwd: workspace.projectDirectory,
+          absolute: true,
+          onlyFiles: true,
+          ignore: query.ignore,
+          deep: query.deep,
+          ...(query.dot === undefined ? {} : { dot: query.dot }),
+        })
+        .sort();
+      assert.deepEqual(walked, globbed, JSON.stringify(query.patterns));
+    }
+    assert.ok(
+      cache
+        .matchWalkedFiles({
+          cwd: workspace.projectDirectory,
+          patterns: ["**/package.json"],
+          ignore: [],
+          deep: 5,
+        })
+        ?.some((matchedPath) => matchedPath.endsWith("linked/inner/package.json")),
+      "symlinked directories are followed, matching fast-glob",
+    );
+
+    // A search root other than the walk root (the monorepo-root case) is not
+    // answerable from this walk — callers fall back to a real glob scan.
+    assert.equal(
+      cache.matchWalkedFiles({
+        cwd: dirname(workspace.projectDirectory),
+        patterns: ["**/package.json"],
+        ignore: [],
+        deep: 5,
+      }),
+      null,
+    );
+  });
+});
diff --git a/packages/deslop-js/vite.config.ts b/packages/deslop-js/vite.config.ts
index 2f6ee062dd..87295ff145 100644
--- a/packages/deslop-js/vite.config.ts
+++ b/packages/deslop-js/vite.config.ts
@@ -12,7 +12,7 @@ export default defineConfig({
       minify: process.env.NODE_ENV === "production",
     },
     {
-      entry: ["./src/collect/parse-worker.ts"],
+      entry: ["./src/collect/parse-worker.ts", "./src/collect/entries-worker.ts"],
       format: ["esm"],
       dts: false,
       clean: false,
diff --git a/packages/react-doctor/src/cli/utils/build-run-event.ts b/packages/react-doctor/src/cli/utils/build-run-event.ts
index b3b7727f87..d2b2616ff5 100644
--- a/packages/react-doctor/src/cli/utils/build-run-event.ts
+++ b/packages/react-doctor/src/cli/utils/build-run-event.ts
@@ -287,6 +287,13 @@ const buildOutcomeAttributes = (input: RunEventInput): RunEventAttributes => {
       // Dead-code result cache outcome; `null` when the pass never consulted
       // the cache, so "no cache" reads distinctly from a miss.
       cacheHit: result.deadCodeCacheHit ?? null,
+      // Incremental summary-cache outcome for the analysis that ran (the
+      // kill-criterion metric for the fill overhead: if warm scans are rare,
+      // hits stay near zero). Numeric so Sentry can aggregate; `null` when no
+      // analysis consulted the incremental store (whole-result hit, cache
+      // off, or dead-code skipped).
+      summaryCacheHits: result.deadCodeSummaryCacheHits ?? null,
+      summaryCacheMisses: result.deadCodeSummaryCacheMisses ?? null,
     }),
     ...withNamespace("supplyChain", {
       overlapTimedOut: input.supplyChainOverlapTimedOut ?? null,
diff --git a/packages/react-doctor/src/inspect.ts b/packages/react-doctor/src/inspect.ts
index 092a424fec..d3e6a227a6 100644
--- a/packages/react-doctor/src/inspect.ts
+++ b/packages/react-doctor/src/inspect.ts
@@ -793,6 +793,8 @@ const runInspectWithRuntime = async (
     lintCacheHitFileCount: output.lintCacheHitFileCount,
     lintCacheTotalFileCount: output.lintCacheTotalFileCount,
     deadCodeCacheHit: output.deadCodeCacheHit,
+    deadCodeSummaryCacheHits: output.deadCodeSummaryCacheHits,
+    deadCodeSummaryCacheMisses: output.deadCodeSummaryCacheMisses,
   });
   recordOnboardingCompletion(options);
   return result;
@@ -817,6 +819,8 @@ interface FinalizeInput {
   lintCacheHitFileCount: number | null;
   lintCacheTotalFileCount: number | null;
   deadCodeCacheHit: boolean | null;
+  deadCodeSummaryCacheHits: number | null;
+  deadCodeSummaryCacheMisses: number | null;
   baselineDelta: InspectResult["baselineDelta"];
 }
 
@@ -851,6 +855,13 @@ interface RenderAndRecordScanInput {
    * leaves it absent.
    */
   readonly deadCodeCacheHit?: boolean | null;
+  /**
+   * deslop's incremental summary-cache outcome for THIS scan's dead-code
+   * analysis (files served from cached parse summaries vs freshly parsed).
+   * Same outside-the-payload contract as the fields above.
+   */
+  readonly deadCodeSummaryCacheHits?: number | null;
+  readonly deadCodeSummaryCacheMisses?: number | null;
 }
 
 const runMaybeSilent = <A, E, R>(
@@ -897,6 +908,8 @@ const renderAndRecordScan = async (input: RenderAndRecordScanInput): Promise<Ins
     lintCacheHitFileCount: input.lintCacheHitFileCount ?? null,
     lintCacheTotalFileCount: input.lintCacheTotalFileCount ?? null,
     deadCodeCacheHit: input.deadCodeCacheHit ?? null,
+    deadCodeSummaryCacheHits: input.deadCodeSummaryCacheHits ?? null,
+    deadCodeSummaryCacheMisses: input.deadCodeSummaryCacheMisses ?? null,
     baselineDelta: input.payload.baselineDelta,
   };
   const result = await Effect.runPromise(
@@ -970,6 +983,8 @@ const finalizeAndRender = (input: FinalizeInput): Effect.Effect<InspectResult> =
       lintCacheHitFileCount,
       lintCacheTotalFileCount,
       deadCodeCacheHit,
+      deadCodeSummaryCacheHits,
+      deadCodeSummaryCacheMisses,
       baselineDelta,
     } = input;
 
@@ -998,6 +1013,9 @@ const finalizeAndRender = (input: FinalizeInput): Effect.Effect<InspectResult> =
         ? { lintCacheHitFileCount, lintCacheTotalFileCount }
         : {}),
       ...(deadCodeCacheHit !== null ? { deadCodeCacheHit } : {}),
+      ...(deadCodeSummaryCacheHits !== null && deadCodeSummaryCacheMisses !== null
+        ? { deadCodeSummaryCacheHits, deadCodeSummaryCacheMisses }
+        : {}),
       ...(baselineDelta ? { baselineDelta } : {}),
     });
 
diff --git a/packages/react-doctor/tests/build-run-event.test.ts b/packages/react-doctor/tests/build-run-event.test.ts
index 3fbe5cc1c3..067da7f1c8 100644
--- a/packages/react-doctor/tests/build-run-event.test.ts
+++ b/packages/react-doctor/tests/build-run-event.test.ts
@@ -126,6 +126,21 @@ describe("buildRunEventAttributes", () => {
     ).toBeUndefined();
   });
 
+  it("records the incremental summary-cache outcome, and drops it when no analysis consulted it", () => {
+    const attributes = buildRunEventAttributes(
+      baseInput({
+        result: buildResult({ deadCodeSummaryCacheHits: 8900, deadCodeSummaryCacheMisses: 3 }),
+      }),
+    );
+    expect(attributes["deadCode.summaryCacheHits"]).toBe(8900);
+    expect(attributes["deadCode.summaryCacheMisses"]).toBe(3);
+    // Whole-result hit / cache off / dead-code skipped: absent, so "no cache"
+    // reads distinctly from a 0% hit rate.
+    const absentAttributes = buildRunEventAttributes(baseInput({ result: buildResult() }));
+    expect(absentAttributes["deadCode.summaryCacheHits"]).toBeUndefined();
+    expect(absentAttributes["deadCode.summaryCacheMisses"]).toBeUndefined();
+  });
+
   it("marks a finding-free run clean and drops absent CI signals", () => {
     const attributes = buildRunEventAttributes(baseInput({ result: buildResult() }));
     expect(attributes["outcome.status"]).toBe("clean");

From ea9a77511760635f09022d48b29fefb5602c07e8 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 00:16:23 -0500
Subject: [PATCH 21/33] perf(core): incremental cross-file sidecar lint via
 dependency probe traces (#1058)

* perf(core): incremental cross-file sidecar lint via dependency probe traces

Every cross-file rule's external reads are soundly bounded by re-running
its own resolver helpers under a probe recorder; cache-hit files replay
their sidecar diagnostics when every recorded probe (content hash or
existence) still answers identically, and re-lint otherwise. A guard test
forces every new cross-file rule into a conscious bounded/unbounded
classification (unbounded = always re-lint). Warm sidecar on a 9k-file
repo: 8.7s -> ~1.5s with byte-identical output in every mutation scenario.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(core): count sidecar-replayed files in the lint progress numerator

Replayed files never ticked the spinner, so it stalled short of the total
whenever the sidecar cache replayed anything, and an all-replayed pass
never ticked at all.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-sidecar-lint-cache.md         |   5 +
 packages/core/src/constants.ts                |   9 +
 packages/core/src/refs.ts                     |  29 ++
 packages/core/src/run-inspect.ts              |  18 +
 packages/core/src/run-oxlint.ts               | 397 ++++++++++++++++--
 packages/core/src/runners/oxlint/config.ts    |  17 +-
 .../oxlint/resolve-sidecar-probe-answer.ts    |  74 ++++
 .../src/runners/oxlint/sidecar-lint-cache.ts  | Bin 0 -> 7542 bytes
 packages/core/src/services/linter.ts          |   9 +
 packages/core/src/types/inspect.ts            |   8 +
 .../core/tests/cross-file-rule-ids.test.ts    |  23 +-
 .../core/tests/sidecar-lint-cache.test.ts     | 147 +++++++
 .../oxlint-plugin-react-doctor/src/index.ts   |   7 +
 .../plugin/constants/cross-file-rule-ids.ts   |  17 +-
 .../plugin/cross-file-dependencies.test.ts    | 278 ++++++++++++
 .../src/plugin/cross-file-dependencies.ts     | 379 +++++++++++++++++
 .../plugin/utils/classify-package-platform.ts |  30 +-
 .../plugin/utils/cross-file-probe-recorder.ts |  67 +++
 .../plugin/utils/does-module-export-name.ts   |   5 +
 .../plugin/utils/is-barrel-index-module.ts    |  42 +-
 .../src/plugin/utils/parse-source-file.ts     |  16 +-
 .../utils/resolve-relative-import-path.ts     |   4 +
 .../plugin/utils/resolve-tsconfig-alias.ts    |  40 +-
 .../src/cli/utils/build-run-event.ts          |   8 +
 packages/react-doctor/src/inspect.ts          |  17 +
 .../run-oxlint/sidecar-lint-cache.test.ts     | 283 +++++++++++++
 26 files changed, 1872 insertions(+), 57 deletions(-)
 create mode 100644 .changeset/perf-sidecar-lint-cache.md
 create mode 100644 packages/core/src/runners/oxlint/resolve-sidecar-probe-answer.ts
 create mode 100644 packages/core/src/runners/oxlint/sidecar-lint-cache.ts
 create mode 100644 packages/core/tests/sidecar-lint-cache.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/utils/cross-file-probe-recorder.ts
 create mode 100644 packages/react-doctor/tests/run-oxlint/sidecar-lint-cache.test.ts

diff --git a/.changeset/perf-sidecar-lint-cache.md b/.changeset/perf-sidecar-lint-cache.md
new file mode 100644
index 0000000000..59e3a0aeea
--- /dev/null
+++ b/.changeset/perf-sidecar-lint-cache.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": patch
+---
+
+Warm rescans now skip the cross-file lint sidecar for files whose dependencies are unchanged. Previously the per-file lint cache replayed most rules but re-linted EVERY file with the cross-file ruleset (`no-barrel-import`, the Next.js metadata/Suspense rules, `no-mutating-reducer-state`, the React Native text rules) on every scan, because a sibling edit can flip an unchanged file's verdict. Each file now carries a dependency fingerprint — the exact set of filesystem probes (resolved import targets, barrel chains, ancestor layouts, nearest package.json/tsconfig, and the negative resolution candidates that catch shadowing) its cross-file rules consulted — and the sidecar replays the stored diagnostics when every probe still answers the same, re-linting only files whose dependency set changed. Every entry fails open (corrupt store, unparseable file, partial lint → fresh re-lint), a cross-file rule without a registered dependency collector re-lints everywhere, and `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_SIDECAR_CACHE`) disables it.
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index a67785e85e..dd3e6e7172 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -627,6 +627,15 @@ export const FILE_LINT_CACHE_MAX_RULESET_COUNT = 8;
 // repos; the most-recently-stored entries are kept when over the cap.
 export const FILE_LINT_CACHE_MAX_FILE_COUNT = 50_000;
 
+// Sidecar lint cache (`runners/oxlint/sidecar-lint-cache.ts`). Caches the
+// cross-file rules' per-file diagnostics keyed by content hash + sidecar
+// ruleset hash, each entry guarded by the file's cross-file dependency probe
+// set, so a warm rescan replays the sidecar instead of re-linting every
+// unchanged file. Shares the file cache's bucket/file caps.
+export const SIDECAR_LINT_CACHE_SCHEMA_VERSION = 1;
+
+export const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
+
 // Length (chars) of the project-directory hash used to name the tmp-dir cache
 // fallback when a project has no `node_modules` to host `.cache/react-doctor`.
 export const CACHE_FILENAME_HASH_LENGTH_CHARS = 16;
diff --git a/packages/core/src/refs.ts b/packages/core/src/refs.ts
index b265f6aa2f..ab42473eb9 100644
--- a/packages/core/src/refs.ts
+++ b/packages/core/src/refs.ts
@@ -208,6 +208,35 @@ export class PerFileLintCacheEnabled extends Context.Reference<boolean>(
   },
 ) {}
 
+/**
+ * Whether the sidecar lint cache (`runners/oxlint/sidecar-lint-cache.ts`) is
+ * active. Defaults ON — warm rescans replay the cross-file rules' cached
+ * diagnostics for every file whose dependency fingerprint (the probe set the
+ * plugin's collectors recorded) still matches the tree, and re-lint only the
+ * rest. Only reachable when the per-file lint cache itself is on (the
+ * sidecar covers its cache hits), so `REACT_DOCTOR_NO_CACHE` /
+ * `REACT_DOCTOR_NO_FILE_CACHE` implicitly disable it too. Opt-OUT knobs:
+ *
+ *   - `REACT_DOCTOR_NO_CACHE` — the global off-switch.
+ *   - `REACT_DOCTOR_NO_SIDECAR_CACHE` — granular rollback hatch: keep the
+ *     per-file cache but run the always-fresh sidecar over every hit
+ *     (the pre-cache behavior).
+ *
+ * Tests override via `Layer.succeed(SidecarLintCacheEnabled, false)`.
+ */
+export class SidecarLintCacheEnabled extends Context.Reference<boolean>(
+  "react-doctor/SidecarLintCacheEnabled",
+  {
+    defaultValue: () => {
+      const noCache = process.env["REACT_DOCTOR_NO_CACHE"]?.toLowerCase() ?? "";
+      const noSidecarCache = process.env["REACT_DOCTOR_NO_SIDECAR_CACHE"]?.toLowerCase() ?? "";
+      if (CACHE_DISABLED_VALUES.has(noCache)) return false;
+      if (CACHE_DISABLED_VALUES.has(noSidecarCache)) return false;
+      return true;
+    },
+  },
+) {}
+
 /**
  * Whether the whole-project dead-code result cache
  * (`dead-code/dead-code-result-cache.ts`) is active. Defaults ON — a rescan
diff --git a/packages/core/src/run-inspect.ts b/packages/core/src/run-inspect.ts
index 5e07e34b18..ce41aa4dbc 100644
--- a/packages/core/src/run-inspect.ts
+++ b/packages/core/src/run-inspect.ts
@@ -238,6 +238,16 @@ export interface InspectOutput {
    */
   readonly lintCacheHitFileCount: number | null;
   readonly lintCacheTotalFileCount: number | null;
+  /**
+   * Sidecar lint cache outcome for the lint pass: cache-hit files whose
+   * cross-file diagnostics replayed from the sidecar store, and the hits
+   * considered. Both `null` when the sidecar cache was disabled or bypassed
+   * (per-file cache off, `REACT_DOCTOR_NO_SIDECAR_CACHE`, no bounded
+   * cross-file rule enabled). Fed to the Sentry wide event as
+   * `lint.sidecarReplayRatio`.
+   */
+  readonly lintSidecarReplayedFileCount: number | null;
+  readonly lintSidecarTotalFileCount: number | null;
   /**
    * Dead-code result cache outcome for this scan's dead-code pass: `true`
    * when the cached result was replayed (the analysis worker never spawned),
@@ -764,6 +774,8 @@ export const runInspect = <HooksR = never>(
     // or bypassed so the wide event can tell "no cache" from "0% hit".
     let lintCacheHitFileCount: number | null = null;
     let lintCacheTotalFileCount: number | null = null;
+    let lintSidecarReplayedFileCount: number | null = null;
+    let lintSidecarTotalFileCount: number | null = null;
     let deadCodeCacheHit: boolean | null = null;
     let deadCodeSummaryCacheHits: number | null = null;
     let deadCodeSummaryCacheMisses: number | null = null;
@@ -792,6 +804,10 @@ export const runInspect = <HooksR = never>(
           lintCacheHitFileCount = cacheHitFileCount;
           lintCacheTotalFileCount = totalConsideredFileCount;
         },
+        onSidecarStats: (sidecarReplayedFileCount, sidecarConsideredFileCount) => {
+          lintSidecarReplayedFileCount = sidecarReplayedFileCount;
+          lintSidecarTotalFileCount = sidecarConsideredFileCount;
+        },
         deadlineEpochMs: input.deadlineEpochMs,
       })
       .pipe(
@@ -1016,6 +1032,8 @@ export const runInspect = <HooksR = never>(
       securityScanFailed,
       lintCacheHitFileCount,
       lintCacheTotalFileCount,
+      lintSidecarReplayedFileCount,
+      lintSidecarTotalFileCount,
       // Lint failure discards the dead-code pass entirely (see
       // `deadCodeFailureState` above), so its cache outcomes must not leak.
       deadCodeCacheHit: lintFailureState.didFail ? null : deadCodeCacheHit,
diff --git a/packages/core/src/run-oxlint.ts b/packages/core/src/run-oxlint.ts
index 86a9525856..0ed9b86b81 100644
--- a/packages/core/src/run-oxlint.ts
+++ b/packages/core/src/run-oxlint.ts
@@ -1,7 +1,11 @@
 import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
-import { CROSS_FILE_RULE_IDS } from "oxlint-plugin-react-doctor";
+import {
+  CROSS_FILE_DEPENDENCY_COLLECTORS,
+  CROSS_FILE_RULE_IDS,
+  collectCrossFileDependencyProbes,
+} from "oxlint-plugin-react-doctor";
 import type { Diagnostic, ProjectInfo, ReactDoctorConfig } from "./types/index.js";
 import { batchIncludePaths } from "./batch-include-paths.js";
 import { COOPERATIVE_YIELD_BUDGET_MS } from "./constants.js";
@@ -14,6 +18,13 @@ import { neutralizeDisableDirectives } from "./neutralize-disable-directives.js"
 import { computeRulesetHash } from "./runners/oxlint/compute-ruleset-hash.js";
 import { createOxlintConfig } from "./runners/oxlint/config.js";
 import { createFileLintCache } from "./runners/oxlint/file-lint-cache.js";
+import { createSidecarProbeAnswerResolver } from "./runners/oxlint/resolve-sidecar-probe-answer.js";
+import type { SidecarProbeAnswerResolver } from "./runners/oxlint/resolve-sidecar-probe-answer.js";
+import { createSidecarLintCache } from "./runners/oxlint/sidecar-lint-cache.js";
+import type {
+  SidecarDependencyProbe,
+  SidecarLintCache,
+} from "./runners/oxlint/sidecar-lint-cache.js";
 import { resolveUserPlugins } from "./runners/oxlint/plugin-resolution.js";
 import { resolveOxlintToolchainVersions } from "./runners/oxlint/resolve-toolchain-versions.js";
 import {
@@ -79,12 +90,29 @@ interface RunOxlintOptions {
    * misses' full pass, and in a sidecar pass over the cache hits).
    */
   perFileLintCacheEnabled?: boolean;
+  /**
+   * Enables the sidecar lint cache, resolved from the
+   * `SidecarLintCacheEnabled` Reference. When on (and the per-file cache is
+   * active), each cache-hit file's cross-file diagnostics replay from the
+   * sidecar store as long as the file's recorded dependency probes still
+   * match the tree; only mismatching files re-lint. Off → every cache hit
+   * runs the always-fresh sidecar pass (the pre-cache behavior).
+   */
+  sidecarLintCacheEnabled?: boolean;
   /**
    * Called once after the cache split with `(cacheHitFileCount,
    * totalConsideredFileCount)`. Surfaced to the Sentry wide event as
    * `lintCacheHitRatio`. Not invoked when the cache is disabled or bypassed.
    */
   onCacheStats?: (cacheHitFileCount: number, totalConsideredFileCount: number) => void;
+  /**
+   * Called once with `(sidecarReplayedFileCount, sidecarConsideredFileCount)`
+   * — how many cache-hit files replayed their cross-file diagnostics from
+   * the sidecar store vs. the hits considered. Surfaced to the Sentry wide
+   * event as `lint.sidecarReplayRatio`. Not invoked when the sidecar cache
+   * is disabled or bypassed.
+   */
+  onSidecarStats?: (sidecarReplayedFileCount: number, sidecarConsideredFileCount: number) => void;
   /** Per-batch wall-clock budget, resolved from the `OxlintSpawnTimeoutMs` Reference. */
   spawnTimeoutMs?: number;
   /** Per-batch stdout+stderr byte cap, resolved from the `OxlintOutputMaxBytes` Reference. */
@@ -138,6 +166,139 @@ const writeOxlintConfig = (
   }
 };
 
+/**
+ * Attributes diagnostics back to the file that produced them by the
+ * normalized path oxlint echoes. Returns `null` when ANY diagnostic can't be
+ * attributed — the path forms don't align, so the caller must skip its cache
+ * store rather than risk caching a wrong empty result for a file that
+ * actually had diagnostics.
+ */
+const attributeDiagnosticsToFiles = (
+  diagnostics: ReadonlyArray<Diagnostic>,
+  files: ReadonlyArray<string>,
+): Map<string, Diagnostic[]> | null => {
+  const fileByNormalizedPath = new Map<string, string>();
+  for (const file of files) {
+    fileByNormalizedPath.set(file.replaceAll("\\", "/"), file);
+  }
+  const diagnosticsByFile = new Map<string, Diagnostic[]>();
+  for (const diagnostic of diagnostics) {
+    const file = fileByNormalizedPath.get(diagnostic.filePath);
+    if (file === undefined) return null;
+    const fileDiagnostics = diagnosticsByFile.get(file) ?? [];
+    fileDiagnostics.push(diagnostic);
+    diagnosticsByFile.set(file, fileDiagnostics);
+  }
+  return diagnosticsByFile;
+};
+
+interface SidecarStorablePass {
+  readonly files: ReadonlyArray<string>;
+  /** Cross-file BOUNDED-rule diagnostics this pass produced for `files`. */
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  /** False when the pass had a partial failure or a config fallback — its
+   * output may be incomplete, so nothing from it is stored. */
+  readonly isTrusted: boolean;
+  /** Each file's answered probe set (from `collectSidecarProbesForFiles`). */
+  readonly probesByFile: ReadonlyMap<string, ReadonlyArray<SidecarDependencyProbe> | null>;
+}
+
+/**
+ * Collects each file's cross-file dependency probes (via the plugin's
+ * collectors) with their current answers. Fail-open per file: an unreadable /
+ * unparseable / collector-failing file maps to `null` (no entry stored — it
+ * re-lints next scan). The filesystem is frozen for the scan, so this can run
+ * CONCURRENTLY with an oxlint child-process await — the caller starts it
+ * unawaited before a lint pass and awaits it at store time, hiding the
+ * in-process parse + resolution cost under the subprocess wait. The loop
+ * yields on the cooperative time budget so the child's stdout handling (and
+ * sibling fibers) keep flowing; each per-file collection is synchronous, so
+ * the module-level probe recorder never sees interleaved use. Never rejects.
+ */
+const collectSidecarProbesForFiles = async (input: {
+  files: ReadonlyArray<string>;
+  rootDirectory: string;
+  boundedSidecarRuleIds: ReadonlyArray<string>;
+  probeAnswers: SidecarProbeAnswerResolver;
+}): Promise<Map<string, ReadonlyArray<SidecarDependencyProbe> | null>> => {
+  const buildProbes = (file: string): SidecarDependencyProbe[] | null => {
+    const absoluteFilePath = path.resolve(input.rootDirectory, file);
+    let trace: ReturnType<typeof collectCrossFileDependencyProbes>;
+    try {
+      trace = collectCrossFileDependencyProbes({
+        absoluteFilePath,
+        sourceText: fs.readFileSync(absoluteFilePath, "utf8"),
+        ruleIds: input.boundedSidecarRuleIds,
+      });
+    } catch {
+      return null;
+    }
+    if (trace === null) return null;
+    const probes: SidecarDependencyProbe[] = [];
+    for (const contentPath of trace.contentPaths) {
+      const relativePath = input.probeAnswers.toRelativePath(contentPath);
+      probes.push({
+        kind: "content",
+        path: relativePath,
+        answer: input.probeAnswers.answerFor("content", relativePath),
+      });
+    }
+    // A path can carry BOTH probe kinds (e.g. a package.json probed for
+    // existence during the ancestor walk and then read): keep both — the
+    // content answer can't distinguish a directory from a missing file, but
+    // the resolvers can (`"dir"` vs `"none"`).
+    for (const existencePath of trace.existencePaths) {
+      const relativePath = input.probeAnswers.toRelativePath(existencePath);
+      probes.push({
+        kind: "exists",
+        path: relativePath,
+        answer: input.probeAnswers.answerFor("exists", relativePath),
+      });
+    }
+    return probes;
+  };
+
+  const probesByFile = new Map<string, ReadonlyArray<SidecarDependencyProbe> | null>();
+  let collectSliceStartedAt = performance.now();
+  for (const file of input.files) {
+    probesByFile.set(file, buildProbes(file));
+    if (performance.now() - collectSliceStartedAt >= COOPERATIVE_YIELD_BUDGET_MS) {
+      await yieldToEventLoop();
+      collectSliceStartedAt = performance.now();
+    }
+  }
+  return probesByFile;
+};
+
+/**
+ * Stores each freshly-linted file's probe set + cross-file diagnostics so
+ * the next scan can replay instead of re-linting.
+ */
+const storeSidecarEntries = (input: {
+  sidecarCache: SidecarLintCache;
+  cacheKeyByFile: ReadonlyMap<string, string>;
+  storablePasses: ReadonlyArray<SidecarStorablePass>;
+}): void => {
+  let didStoreAnyEntry = false;
+  for (const pass of input.storablePasses) {
+    if (!pass.isTrusted) continue;
+    const diagnosticsByFile = attributeDiagnosticsToFiles(pass.diagnostics, pass.files);
+    if (diagnosticsByFile === null) continue;
+    for (const file of pass.files) {
+      const cacheKey = input.cacheKeyByFile.get(file);
+      if (cacheKey === undefined) continue;
+      const probes = pass.probesByFile.get(file);
+      if (probes === undefined || probes === null) continue;
+      input.sidecarCache.store(cacheKey, {
+        probes,
+        diagnostics: diagnosticsByFile.get(file) ?? [],
+      });
+      didStoreAnyEntry = true;
+    }
+  }
+  if (didStoreAnyEntry) input.sidecarCache.persist();
+};
+
 const REACT_HOOKS_JS_DROP_PREFIX =
   "React Compiler rules (react-hooks-js/*) skipped — eslint-plugin-react-hooks failed to load in this environment";
 
@@ -206,7 +367,9 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
     configSourceDirectory = rootDirectory,
     onPartialFailure,
     perFileLintCacheEnabled = false,
+    sidecarLintCacheEnabled = false,
     onCacheStats,
+    onSidecarStats,
     spawnTimeoutMs,
     outputMaxBytes,
     lintBatchOrdering = "cost",
@@ -250,6 +413,7 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
     extendsPaths: string[];
     disableReactHooksJsPlugin?: boolean;
     ruleSelection?: "cacheable" | "sidecar";
+    sidecarRuleIdFilter?: ReadonlySet<string>;
   }) =>
     createOxlintConfig({
       pluginPath,
@@ -262,6 +426,7 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       userPlugins,
       disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin,
       ruleSelection: overrides.ruleSelection,
+      sidecarRuleIdFilter: overrides.sidecarRuleIdFilter,
     });
 
   // HACK: only neutralize disable comments in audit mode. Default
@@ -455,15 +620,24 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       // this pre-spawn burst starves the forked security-scan / supply-chain
       // fibers (and sibling projects) until the first oxlint spawn.
       const cacheKeyByFile = new Map<string, string>();
+      // Canonical relative path → content hash, reused by the sidecar cache's
+      // probe-answer resolver so verifying a source-file dependency is a map
+      // lookup instead of a re-read.
+      const contentHashByRelativePath = new Map<string, string>();
       const missFiles: string[] = [];
       const replayedDiagnostics: Diagnostic[] = [];
       let hashSliceStartedAt = performance.now();
       for (const candidateFile of candidateFiles) {
-        const contentHash = hashFileContents(path.resolve(rootDirectory, candidateFile));
+        const absoluteCandidatePath = path.resolve(rootDirectory, candidateFile);
+        const contentHash = hashFileContents(absoluteCandidatePath);
         if (contentHash === null) {
           missFiles.push(candidateFile);
           continue;
         }
+        contentHashByRelativePath.set(
+          path.relative(rootDirectory, absoluteCandidatePath).replaceAll("\\", "/"),
+          contentHash,
+        );
         const cacheKey = `${candidateFile.replaceAll("\\", "/")}\u0000${contentHash}`;
         cacheKeyByFile.set(candidateFile, cacheKey);
         const cachedDiagnostics = cache.lookup(cacheKey);
@@ -476,15 +650,78 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       }
       const cacheHitFileCount = candidateFiles.length - missFiles.length;
 
+      // The cross-file sidecar over the cache hits. The enabled sidecar rules
+      // split by whether the plugin ships a dependency collector for them:
+      //
+      //   - BOUNDED rules replay from the sidecar cache: a hit file whose
+      //     stored dependency probes all still match the tree replays its
+      //     stored cross-file diagnostics; only mismatching (or unknown)
+      //     files re-lint, in a sidecar pass narrowed to the bounded rules.
+      //   - UNBOUNDED rules (no collector — see the plugin's
+      //     `UNBOUNDED_CROSS_FILE_RULE_IDS`; empty today) can't be
+      //     fingerprinted, so they run always-fresh over EVERY hit file in a
+      //     second narrowed pass. The degradation is per-rule, not global.
+      //
+      // With the sidecar cache off (or no bounded rule enabled) the split
+      // collapses to the pre-cache behavior: one always-fresh sidecar pass,
+      // all cross-file rules, every hit file.
+      const enabledSidecarRuleIds = Object.keys(
+        buildConfig({ extendsPaths: [], ruleSelection: "sidecar" }).rules,
+      )
+        .map((ruleKey) => ruleKey.slice(ruleKey.lastIndexOf("/") + 1))
+        .filter((ruleId) => CROSS_FILE_RULE_IDS.has(ruleId));
+      const boundedSidecarRuleIds = enabledSidecarRuleIds.filter((ruleId) =>
+        CROSS_FILE_DEPENDENCY_COLLECTORS.has(ruleId),
+      );
+      const boundedSidecarRuleIdSet: ReadonlySet<string> = new Set(boundedSidecarRuleIds);
+      const unboundedSidecarRuleIds = enabledSidecarRuleIds.filter(
+        (ruleId) => !CROSS_FILE_DEPENDENCY_COLLECTORS.has(ruleId),
+      );
+      const useSidecarCache = sidecarLintCacheEnabled && boundedSidecarRuleIds.length > 0;
+
+      const sidecarCache = useSidecarCache
+        ? createSidecarLintCache(
+            resolveReactDoctorCacheDir(rootDirectory),
+            computeRulesetHash({
+              config: buildConfig({
+                extendsPaths: [],
+                ruleSelection: "sidecar",
+                sidecarRuleIdFilter: boundedSidecarRuleIdSet,
+              }),
+              toolchainVersions: resolveOxlintToolchainVersions(nodeBinaryPath),
+              ignorePatterns: combinedPatterns,
+              tsconfigContent,
+            }),
+          )
+        : null;
+      const probeAnswers = createSidecarProbeAnswerResolver({
+        rootDirectory,
+        contentHashByRelativePath,
+      });
+      // Started UNAWAITED so the in-process probe collection interleaves with
+      // the full pass's child-process await below (the filesystem is frozen
+      // for the scan, so collecting before/during/after the pass is
+      // equivalent). Never rejects — a failing file maps to `null`.
+      const missProbesTask =
+        sidecarCache === null
+          ? null
+          : collectSidecarProbesForFiles({
+              files: missFiles,
+              rootDirectory,
+              boundedSidecarRuleIds,
+              probeAnswers,
+            });
+
       // Miss files run the FULL config in one pass — cacheable and cross-file
-      // rules together — and the always-fresh cross-file sidecar covers only
-      // the cache HITS. The previous shape (cacheable pass over misses, then
-      // sidecar over every file) parsed and spawned over each miss twice,
-      // doubling the lint cost of a cold-cache scan — every CI run. The fresh
-      // output is partitioned by rule id below so only cacheable-rule
-      // diagnostics are stored; cache contents and reported diagnostics are
-      // unchanged, and a stale cross-file verdict still can't be served (hits
-      // get the sidecar, misses ran the cross-file rules in the full pass).
+      // rules together — and the cross-file sidecar covers only the cache
+      // HITS. The previous shape (cacheable pass over misses, then sidecar
+      // over every file) parsed and spawned over each miss twice, doubling
+      // the lint cost of a cold-cache scan — every CI run. The fresh output
+      // is partitioned by rule id below so only cacheable-rule diagnostics
+      // are stored; cache contents and reported diagnostics are unchanged,
+      // and a stale cross-file verdict still can't be served (hits replay
+      // only behind matching dependency probes, misses ran the cross-file
+      // rules in the full pass).
       const fullResult = await runConfigOverFiles(
         (overrides) =>
           buildConfig({
@@ -498,44 +735,103 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       );
       const missFileSet = new Set(missFiles);
       const hitFiles = candidateFiles.filter((candidateFile) => !missFileSet.has(candidateFile));
-      const sidecarResult = await runConfigOverFiles(
-        () => buildConfig({ extendsPaths: [], ruleSelection: "sidecar" }),
+
+      // Split the hit files into replays and sidecar re-lints by re-answering
+      // each stored probe against the current tree. Source-file answers are
+      // map lookups over the hashes computed above; the loop still stats
+      // package.json / tsconfig probes, so it shares the cooperative budget.
+      const sidecarReplayedDiagnostics: Diagnostic[] = [];
+      const sidecarLintFiles: string[] = [];
+      if (sidecarCache === null) {
+        sidecarLintFiles.push(...hitFiles);
+      } else {
+        let verifySliceStartedAt = performance.now();
+        for (const hitFile of hitFiles) {
+          const cacheKey = cacheKeyByFile.get(hitFile);
+          const entry = cacheKey === undefined ? null : sidecarCache.lookup(cacheKey);
+          const isReplayable =
+            entry !== null &&
+            entry.probes.every(
+              (probe) => probeAnswers.answerFor(probe.kind, probe.path) === probe.answer,
+            );
+          if (isReplayable) sidecarReplayedDiagnostics.push(...entry.diagnostics);
+          else sidecarLintFiles.push(hitFile);
+          if (performance.now() - verifySliceStartedAt >= COOPERATIVE_YIELD_BUDGET_MS) {
+            await yieldToEventLoop();
+            verifySliceStartedAt = performance.now();
+          }
+        }
+      }
+
+      // Same overlap as `missProbesTask`: collect the re-lint set's probes
+      // while the bounded sidecar pass awaits its child processes.
+      const sidecarProbesTask =
+        sidecarCache === null
+          ? null
+          : collectSidecarProbesForFiles({
+              files: sidecarLintFiles,
+              rootDirectory,
+              boundedSidecarRuleIds,
+              probeAnswers,
+            });
+      // Replayed files are completed work: without them in the numerator the
+      // spinner stalls at missFiles + sidecarLintFiles of candidateFiles, and
+      // an all-replayed pass (empty sidecarLintFiles) would never tick at all.
+      const sidecarReplayedFileCount = hitFiles.length - sidecarLintFiles.length;
+      if (sidecarReplayedFileCount > 0) {
+        options.onFileProgress?.(
+          missFiles.length + sidecarReplayedFileCount,
+          candidateFiles.length,
+        );
+      }
+      const boundedSidecarResult = await runConfigOverFiles(
+        () =>
+          buildConfig({
+            extendsPaths: [],
+            ruleSelection: "sidecar",
+            ...(useSidecarCache ? { sidecarRuleIdFilter: boundedSidecarRuleIdSet } : {}),
+          }),
         "oxlintrc.sidecar.json",
-        hitFiles,
+        sidecarLintFiles,
         options.onFileProgress &&
           ((scannedFileCount) =>
-            options.onFileProgress?.(missFiles.length + scannedFileCount, candidateFiles.length)),
+            options.onFileProgress?.(
+              missFiles.length + sidecarReplayedFileCount + scannedFileCount,
+              candidateFiles.length,
+            )),
       );
+      const unboundedSidecarResult =
+        useSidecarCache && unboundedSidecarRuleIds.length > 0
+          ? await runConfigOverFiles(
+              () =>
+                buildConfig({
+                  extendsPaths: [],
+                  ruleSelection: "sidecar",
+                  sidecarRuleIdFilter: new Set(unboundedSidecarRuleIds),
+                }),
+              "oxlintrc.sidecar-unbounded.json",
+              hitFiles,
+              undefined,
+            )
+          : { diagnostics: [], didDropReactHooksJsPlugin: false, hadPartialFailure: false };
+
       const freshCacheableDiagnostics: Diagnostic[] = [];
       for (const diagnostic of fullResult.diagnostics) {
         if (!CROSS_FILE_RULE_IDS.has(diagnostic.rule)) freshCacheableDiagnostics.push(diagnostic);
       }
 
-      // Reported only after both passes succeed — if lint throws, the run fails
-      // and no cache-hit ratio is attached to a failed scan's telemetry.
+      // Reported only after every pass succeeds — if lint throws, the run
+      // fails and no cache ratio is attached to a failed scan's telemetry.
       onCacheStats?.(cacheHitFileCount, candidateFiles.length);
-
-      // Attribute fresh cacheable diagnostics back to their miss file by the
-      // normalized path oxlint echoes. If ANY diagnostic can't be attributed,
-      // the path forms don't align — skip the store rather than risk caching a
-      // wrong empty result for a file that actually had diagnostics.
-      const missFileByNormalizedPath = new Map<string, string>();
-      for (const missFile of missFiles) {
-        missFileByNormalizedPath.set(missFile.replaceAll("\\", "/"), missFile);
-      }
-      const freshDiagnosticsByFile = new Map<string, Diagnostic[]>();
-      let isAttributionSound = true;
-      for (const diagnostic of freshCacheableDiagnostics) {
-        const missFile = missFileByNormalizedPath.get(diagnostic.filePath);
-        if (missFile === undefined) {
-          isAttributionSound = false;
-          break;
-        }
-        const fileDiagnostics = freshDiagnosticsByFile.get(missFile) ?? [];
-        fileDiagnostics.push(diagnostic);
-        freshDiagnosticsByFile.set(missFile, fileDiagnostics);
+      if (sidecarCache !== null) {
+        onSidecarStats?.(hitFiles.length - sidecarLintFiles.length, hitFiles.length);
       }
 
+      const freshDiagnosticsByFile = attributeDiagnosticsToFiles(
+        freshCacheableDiagnostics,
+        missFiles,
+      );
+
       // Skip the store when this run can't be trusted to represent a clean,
       // complete lint of the miss files:
       //   - a react-hooks-js fallback rewrote the cacheable config, so its
@@ -546,7 +842,7 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       if (
         !fullResult.didDropReactHooksJsPlugin &&
         !fullResult.hadPartialFailure &&
-        isAttributionSound
+        freshDiagnosticsByFile !== null
       ) {
         for (const missFile of missFiles) {
           const cacheKey = cacheKeyByFile.get(missFile);
@@ -557,6 +853,29 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
         cache.persist();
       }
 
+      if (sidecarCache !== null && missProbesTask !== null && sidecarProbesTask !== null) {
+        storeSidecarEntries({
+          sidecarCache,
+          cacheKeyByFile,
+          storablePasses: [
+            {
+              files: sidecarLintFiles,
+              diagnostics: boundedSidecarResult.diagnostics,
+              isTrusted: !boundedSidecarResult.hadPartialFailure,
+              probesByFile: await sidecarProbesTask,
+            },
+            {
+              files: missFiles,
+              diagnostics: fullResult.diagnostics.filter((diagnostic) =>
+                boundedSidecarRuleIdSet.has(diagnostic.rule),
+              ),
+              isTrusted: !fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure,
+              probesByFile: await missProbesTask,
+            },
+          ],
+        });
+      }
+
       // Dedupe the merged result to match the non-cached path (which dedupes
       // at the end of `spawnLintBatches`): a duplicate path in `includePaths`
       // replays the same cached set twice, which dedupe collapses — so warm
@@ -564,7 +883,9 @@ export const runOxlint = async (options: RunOxlintOptions): Promise<Diagnostic[]
       return dedupeDiagnostics([
         ...replayedDiagnostics,
         ...fullResult.diagnostics,
-        ...sidecarResult.diagnostics,
+        ...sidecarReplayedDiagnostics,
+        ...boundedSidecarResult.diagnostics,
+        ...unboundedSidecarResult.diagnostics,
       ]);
     }
 
diff --git a/packages/core/src/runners/oxlint/config.ts b/packages/core/src/runners/oxlint/config.ts
index e4402b0bd5..bc1e7cd880 100644
--- a/packages/core/src/runners/oxlint/config.ts
+++ b/packages/core/src/runners/oxlint/config.ts
@@ -46,9 +46,16 @@ export interface OxlintConfigOptions {
    *     linted file's own content, so their output is content-addressable.
    *   - `"sidecar"` — ONLY the cross-file react-doctor rules; the React
    *     Compiler frontend and user plugins are dropped (none are cross-file).
-   *     This config always runs fresh on every file and is never cached.
    */
   ruleSelection?: "cacheable" | "sidecar";
+  /**
+   * Narrows a `"sidecar"` selection to a subset of the cross-file rules.
+   * The sidecar cache path uses it to split fingerprint-BOUNDED rules
+   * (replayable via the dependency-probe store) from UNBOUNDED ones (no
+   * dependency collector — they re-lint every file, every scan). Ignored
+   * for other selections.
+   */
+  sidecarRuleIdFilter?: ReadonlySet<string>;
 }
 
 const resolveSettingsRootDirectory = (rootDirectory: string): string => {
@@ -117,6 +124,7 @@ export const createOxlintConfig = ({
   userPlugins = [],
   disableReactHooksJsPlugin = false,
   ruleSelection,
+  sidecarRuleIdFilter,
 }: OxlintConfigOptions) => {
   // The sidecar carries only cross-file react-doctor rules — the React
   // Compiler frontend isn't cross-file, so it never belongs there.
@@ -149,6 +157,13 @@ export const createOxlintConfig = ({
     // only them. The default (undefined) keeps every rule.
     if (ruleSelection === "cacheable" && CROSS_FILE_RULE_IDS.has(registryEntry.id)) continue;
     if (ruleSelection === "sidecar" && !CROSS_FILE_RULE_IDS.has(registryEntry.id)) continue;
+    if (
+      ruleSelection === "sidecar" &&
+      sidecarRuleIdFilter !== undefined &&
+      !sidecarRuleIdFilter.has(registryEntry.id)
+    ) {
+      continue;
+    }
     // Scan rules run via core's check-security-scan environment
     // check, not oxlint — registering them would only add dead visitors.
     if (rule.scan !== undefined) continue;
diff --git a/packages/core/src/runners/oxlint/resolve-sidecar-probe-answer.ts b/packages/core/src/runners/oxlint/resolve-sidecar-probe-answer.ts
new file mode 100644
index 0000000000..19cdd6b53f
--- /dev/null
+++ b/packages/core/src/runners/oxlint/resolve-sidecar-probe-answer.ts
@@ -0,0 +1,74 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { hashFileContents } from "../../utils/hash-file-contents.js";
+import type { SidecarDependencyProbe } from "./sidecar-lint-cache.js";
+
+const ABSENT_CONTENT_ANSWER = "absent";
+
+export interface SidecarProbeAnswerResolver {
+  /** Current answer for a probe path: content hash / existence class. */
+  readonly answerFor: (kind: SidecarDependencyProbe["kind"], relativePath: string) => string;
+  /** Root-relative, `/`-separated form every stored probe path uses. */
+  readonly toRelativePath: (absolutePath: string) => string;
+}
+
+/**
+ * Answers dependency probes for the sidecar lint cache — used both when
+ * STORING an entry (turn the collector's probe paths into answers) and when
+ * VERIFYING one (re-answer each stored probe against the current tree).
+ * Store and verify must agree exactly, so both go through this one resolver.
+ *
+ *   - `content` — SHA-1 of the file's bytes, `"absent"` when unreadable
+ *     (missing, a directory, permission failure). Source files reuse the
+ *     hashes the cache-partition loop already computed
+ *     (`contentHashByRelativePath`); everything else (package.json,
+ *     tsconfig, ignored files) is hashed on demand.
+ *   - `exists` — the existence class a module-resolution candidate probe
+ *     sees: `"file"`, `"dir"`, or `"none"` (missing or an exotic entry —
+ *     `statSync` follows symlinks, matching the resolvers).
+ *
+ * Answers are memoized per scan: the filesystem is frozen for the run, and
+ * hot dependency paths (a barrel imported by hundreds of files, the shared
+ * tsconfig chain) repeat across many files' probe sets.
+ */
+export const createSidecarProbeAnswerResolver = (input: {
+  rootDirectory: string;
+  contentHashByRelativePath: ReadonlyMap<string, string>;
+}): SidecarProbeAnswerResolver => {
+  const contentAnswerByPath = new Map<string, string>();
+  const existsAnswerByPath = new Map<string, string>();
+
+  const toRelativePath = (absolutePath: string): string =>
+    path.relative(input.rootDirectory, absolutePath).replaceAll("\\", "/");
+
+  const contentAnswer = (relativePath: string): string => {
+    const memoized = contentAnswerByPath.get(relativePath);
+    if (memoized !== undefined) return memoized;
+    const answer =
+      input.contentHashByRelativePath.get(relativePath) ??
+      hashFileContents(path.resolve(input.rootDirectory, relativePath)) ??
+      ABSENT_CONTENT_ANSWER;
+    contentAnswerByPath.set(relativePath, answer);
+    return answer;
+  };
+
+  const existsAnswer = (relativePath: string): string => {
+    const memoized = existsAnswerByPath.get(relativePath);
+    if (memoized !== undefined) return memoized;
+    let answer: string;
+    try {
+      const stat = fs.statSync(path.resolve(input.rootDirectory, relativePath));
+      answer = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "none";
+    } catch {
+      answer = "none";
+    }
+    existsAnswerByPath.set(relativePath, answer);
+    return answer;
+  };
+
+  return {
+    answerFor: (kind, relativePath) =>
+      kind === "content" ? contentAnswer(relativePath) : existsAnswer(relativePath),
+    toRelativePath,
+  };
+};
diff --git a/packages/core/src/runners/oxlint/sidecar-lint-cache.ts b/packages/core/src/runners/oxlint/sidecar-lint-cache.ts
new file mode 100644
index 0000000000000000000000000000000000000000..773be064158fffcf66c8978c012738482e69080c
GIT binary patch
literal 7542
zcmb_hZExF14!+O%72JH-%3WJo;J!IcifrOyyPKE7Y3~I=Q7h6oRwGM-Mv7~+0q#fK
zFT7uJ56KxxcAV}Wa6y2?(hSKVA3o&J>9Q=UnqE?5sf_9c&8uQb`+1R=F@N4a+)H~)
zuH%JSMsAUr&rMt(=(BENy)F%XrL#1;%L`klF+I8sVR(RFes2%bJTYIw&$iq5b&u%H
z+w;k%^S77pKb@YO{yO<|aq^E(^6d2L!{z(oGb^Sa&L`Is?D31P-=0lQPo{lIEamd#
zV!|?ZyuOCEi<3`(n@q3YUR@6NHcgI;+}2TE+f9S}XN3Q{6FWC;3bEq5Z4psjEYtY!
zRa%?hY>{vIs;Se=9_X6UiWiMOW7U=!^C-=(N|R4blsqeh7mW(68dX@fOH68~CN8RE
zrwysaK7OmZ_YPjZ+yiW`)5OG4MOm8H6h}BB&5Md^{Ee%^+R;4C3{_2LY>36TSa(Oo
zoVU*S)rdEaWMf#{83i_48p?_|s?#DL(rpvpo0_s{T{QKO&Zi%!tePBBh7{!q%Te!8
zdp;^nWm8+5JT?Pbr2uu28;X)7Wtse%OkP*(v6#tLys#{&XK-TRs00$$^lp0f%Y*>0
zA*lmQLbq$#T4v2%n!m8rEf+aOmLV~U%2F^ZzQ_r6DZ4(dM@hkNXG5BGDo3r16t03R
z1}ti|FuAA_gJ}hnS!^{)h_}4pJv*FTd~eoNrn&8%iHcQDfG#{y!;)8($>7xo^A34^
z{FhgY$S#g&$cLANAm&KaD5JV)1!y=2>}Gl9Lc!ZQP1eO<B5Z0F_7j8@S-gnS{7^QQ
zRdH*`B8+07c`((wUN8_Q=hqWi()mHL0#`>8Tm@5V^^pJh*T1O%wkr8(U$m!Vql|4$
zHD6r(*`7FytWD=Qo`k=clUM*1w#blRfJBTlrb$$rkY+&FNP{MTtV{{;v1pbhVc>wb
z<Yob`Y)#R;hE<grMY&y>iVvq+^zhLgykToTtC-YO6$gbQXV-x0QcPb)bu50-tt#pe
zuhz6ot-PfG*~Jf#cHn3h#=vhXL+l*gh%B%4u>1}d0?Y&KxT~TBUP6qS!VTi+!zbyh
zX<08KHEc*Zi__(xKY$D$lQgawd<T0>0d$4TYSW^3969zF_=PY=Ei-77)h3a&rL<;`
zvZq28Wxhxi0u`8Q9>vDf%2}I+?*v0!B3SEe-@$r+CdX#F(L6?K);J;rvt3bgh_!+S
z>y}EiSbd8T1&G)|vPYKOqd<+R)kELN%Q<vLOpBsMLTgS@FguuytSKXS-XsGlrcfS+
zvr$=@dHMykA=wNbW3LPBD~Q-u%vE=cEN2XPRi`eACHD@tO$P%iD^Q(+JOgVCV9e-#
zFe4XX7=a{o=oEU{)~n&@G(YY=8<sbK?SvVWI3Vn1aha&FW16}LCsh@#UtKFhY=!ce
zkJj$&rPKEIuBc+mcWgQbcuuAMuuTjS`IKnNwnYgvIV7aeEN`-GhTKIeAh%GQ0K=X|
zSy9|K<(LA7)$aziLL)MuqhpWG&JEv)#rbGy6$QXG$+EQ+ImF*VRQx1-_|rzs={RNE
z8sYq>#teNOb3Sej5-T5yH1Q_A$r>R@(5?l;a?N5YL#g5PPEvbM0q8%2Lt=vz6*l9n
z5@IMppo49jT$P1YJ#7e3m&ET}9ZsfP{z3m7nKtH4$%LDn)E9tE-YjoT#n!g(*;xW6
zZaQA6_lMNv_c_X%Vqu3W=ZQ@;v@*e87JR=`pQ~U`Rc;?cbu*#W^bloIH#(Hk5oz}q
zDnoxzgRj?l9CWL6$>4BrPvxXm2<~@~4g>@c+nBLG>|o4#8bgTP?rgf*XS&+|2ynuM
zy7=hms83(t`i~tWLjA!3ok=C(I%e9|$)ydqJatoXyX7+`ozuzXKT*jIXc`7BqYO2A
z33S_nr7>t$ivq=h1GrUmIMXPIK#o<NqTA>)VO2C)f&(X}8r?Nfm3Ub_YG|pRElpCC
z9Vy;Yu$B#?q4jDJm0a&a=UNTJc80K*t7z5t@slN*)tvAQTpT?3!MDh~cR=61(GNm$
zVQS?sKMs`!pL^Ro&tTx(+p>p(K?RJTi#4K5Hy=4yxH$@R4-^Z6&|6dA2)5kW{=`z*
zAa?rQVP^6>^vgd0JAZv*9Z40h>4w2J)ZlS1$t9gjIUD9Bv3ae}L=j^<;GLq8FM%*s
zj><Ab<-TV5K0DSeP{|u_2NDhzui$LGNAxIKMW_u+P+stroUu|>TXo)KdPENDK3~o@
z+$#N^_h~<LJ2F3z#VQXSC0aRW=$4smq<i#L9bkw3hH@+c>?z~B`E;YEp0%aom>y9U
zHIc>5xW+5(@~*g8mbh@x%!jNWtr^u#367Ptig3lM?zm?vC5@%xSXv+>aoYen%#qne
zW6>zP4`w+;%1gfgc71h;`p9iE8aQiw>f!!`9`#9HA@#&nEyBCH)#f8-UBKYgV2-uY
zx!ekuQ5gjCMrzNE{2TUQ8FClpAR0P!4*2TdbE}uxdxU#`$H`_{)@yAkU@=IzEd=gF
zU6Jv|w)N#tOc($HEsLl)UmrI#XGP>|=EPNLSODwgp3L6jl<_SIAIpjQ71yBdF-*RQ
z%C>ZF$KlvBn=%N8g!_Rb(CF&>8v_BkBP(Czv5{{Z{W-*|XFYa|ZUeIde-tz_t+RuH
zNN2irNXBi~IaYY!4}B}V+%k11#QPh(tF-8{(4E{9fu76Vc8`2I!3e+qrsr+p;my*Z
zJC*-iEA(N=HPLpw-_zXV@*7@-o)gtKS}_3DA36W7Za<^qg>Fx<B~eeLwrk1bPGWcQ
z<1!_3#nVdDeh*VWH?srZAcpANd>0I!l4c>1jXff355iRBZgXl&jOMHM9MH>{4$o&&
z$qSyxxGwKIfZmmQd~~O*4=Nm=Ss?seq`AVa)im5S0`wEY9=P4HAn9pJZX>t{3P|81
zNbBUFwtb%v-g4r@yUxP{di`4b&sj}+t?L?p*YL|`4LGhk2Ph6BOcxC1xQ>vQn7cxM
z3<a1?=){O8M3^4&v=;-Bx^1R-q_#p?E>@yZ1m2sn=DU&09q#kEud9*Yj6_w&gA=so
zxWc=Q{y2%rOl>@79L8ujo_NpNEddGgnVnL9vDiE(xAJ_-2%`%fCgL_jJQ?L4HKMb(
zZ{AF%lgsy>68!`*wfPH-r{o7Ni?iYuHx3!3$uk8|k)QEh=>JP)EMLWY2H{KY#<k|1
zXVIzF1aPynl@JHEsii>f>;ISnfBX?aQzd~D;FV*r*#5l6pgs)4trf11(p6lY1kd~t
zp1UyIC-AT-FBoJPkKraDleq>HFn85cb{gVtT~&pQ!~Bd!i`cje#bzk&B67<CI+=GY
zqc#3{zywhypB_ij{R*FA+S5t%Gph#W1=F7bHaT1}%4HLe&sYuaEXWCuUX764i~yxy
zbnc9X))na|q|ffy+{4uj^|N(v8-Pur1L_B7^PMXY^jc>;ts(lHG#0Gc>&E#+?Gr@#
zi!!jx@zXs!i;Se8R2b(dUmkgnm+xy5_xQWpx?cOs8@V{}kGg2dph+fei?LP91ccrb
za-N~U(jCrq>7BTkuXsIi8{$KorLhS{-~TSDrKOz#X0Nqz+?Z6H@st=Nh(Ov&Iiikn
z$G$-GH)!sps1ZFw+Z|m#sdxAr4dXk$KQVxSb<Tl(U9G)a&h-cE=RM;It$GmL_^((#
zN>OPctNANXbvH5BZ}gl&GGfrt&HjdTt}-Hfo>sR0I3%dCV7xq0HTr+pmo<VHv9|wg
zQ=|m-=i$z;2sgd}Y~8G7m_xMnCEIrC?n3>)HSijJ@82=*D*ZTWHA5!!%Ns(E-~R#*
CM&K#{

literal 0
HcmV?d00001

diff --git a/packages/core/src/services/linter.ts b/packages/core/src/services/linter.ts
index 25247b5d9c..cc7c0b0247 100644
--- a/packages/core/src/services/linter.ts
+++ b/packages/core/src/services/linter.ts
@@ -11,6 +11,7 @@ import {
   OxlintOutputMaxBytes,
   OxlintSpawnTimeoutMs,
   PerFileLintCacheEnabled,
+  SidecarLintCacheEnabled,
 } from "../refs.js";
 import { runOxlint } from "../run-oxlint.js";
 
@@ -46,6 +47,11 @@ export interface LintInput {
   readonly nodeBinaryPath?: string;
   readonly onFileProgress?: (scannedFileCount: number, totalFileCount: number) => void;
   readonly onCacheStats?: (cacheHitFileCount: number, totalConsideredFileCount: number) => void;
+  /** See `RunOxlintOptions.onSidecarStats`. */
+  readonly onSidecarStats?: (
+    sidecarReplayedFileCount: number,
+    sidecarConsideredFileCount: number,
+  ) => void;
   /** See `RunOxlintOptions.deadlineEpochMs`. */
   readonly deadlineEpochMs?: number;
 }
@@ -117,6 +123,7 @@ export class Linter extends Context.Service<
             const concurrency = yield* OxlintConcurrency;
             const lintBatchOrdering = yield* LintBatchOrdering;
             const perFileLintCacheEnabled = yield* PerFileLintCacheEnabled;
+            const sidecarLintCacheEnabled = yield* SidecarLintCacheEnabled;
             const collectedFailures: string[] = [];
             const diagnostics = yield* Effect.tryPromise({
               // `Effect.tryPromise` aborts this signal when the fiber is
@@ -139,7 +146,9 @@ export class Linter extends Context.Service<
                   },
                   onFileProgress: input.onFileProgress,
                   perFileLintCacheEnabled,
+                  sidecarLintCacheEnabled,
                   onCacheStats: input.onCacheStats,
+                  onSidecarStats: input.onSidecarStats,
                   spawnTimeoutMs,
                   outputMaxBytes,
                   concurrency,
diff --git a/packages/core/src/types/inspect.ts b/packages/core/src/types/inspect.ts
index 8247e50e43..2fec8f51fd 100644
--- a/packages/core/src/types/inspect.ts
+++ b/packages/core/src/types/inspect.ts
@@ -48,6 +48,14 @@ export interface InspectResult {
    */
   lintCacheHitFileCount?: number | null;
   lintCacheTotalFileCount?: number | null;
+  /**
+   * Sidecar lint cache outcome: cache-hit files whose cross-file diagnostics
+   * replayed from the sidecar store, and the hits considered. Both absent
+   * when the sidecar cache was off or bypassed. The CLI projects these onto
+   * the Sentry wide event as `lint.sidecarReplayRatio`.
+   */
+  lintSidecarReplayedFileCount?: number | null;
+  lintSidecarTotalFileCount?: number | null;
   /**
    * Dead-code result cache outcome: `true` when the pass replayed a cached
    * result (the analysis never ran), `false` on a fresh analysis. Absent when
diff --git a/packages/core/tests/cross-file-rule-ids.test.ts b/packages/core/tests/cross-file-rule-ids.test.ts
index 8e465a117d..8d5f404bc2 100644
--- a/packages/core/tests/cross-file-rule-ids.test.ts
+++ b/packages/core/tests/cross-file-rule-ids.test.ts
@@ -2,7 +2,11 @@ import * as fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { describe, expect, it } from "vite-plus/test";
-import { CROSS_FILE_RULE_IDS } from "oxlint-plugin-react-doctor";
+import {
+  CROSS_FILE_DEPENDENCY_COLLECTORS,
+  CROSS_FILE_RULE_IDS,
+  UNBOUNDED_CROSS_FILE_RULE_IDS,
+} from "oxlint-plugin-react-doctor";
 
 // The staleness safety net. Reproduces the transitive import-graph analysis
 // that classifies a rule as cross-file (its verdict can depend on the content
@@ -137,4 +141,21 @@ describe("CROSS_FILE_RULE_IDS", () => {
       "rn-prefer-expo-image",
     ]);
   });
+
+  // The sidecar lint cache's classification guard: every cross-file rule must
+  // be CONSCIOUSLY classified as either fingerprint-BOUNDED (it ships a
+  // dependency collector, so its diagnostics can replay from the sidecar
+  // cache) or UNBOUNDED (no sound dependency bound exists — it re-lints every
+  // file on every scan). A new cross-file rule fails here until its author
+  // adds it to one side in the plugin's `cross-file-dependencies.ts`.
+  it("classifies every cross-file rule as bounded (collector) or unbounded — exactly one", () => {
+    const collectorRuleIds = [...CROSS_FILE_DEPENDENCY_COLLECTORS.keys()];
+    const overlappingRuleIds = collectorRuleIds.filter((ruleId) =>
+      UNBOUNDED_CROSS_FILE_RULE_IDS.has(ruleId),
+    );
+    expect(overlappingRuleIds).toEqual([]);
+    expect([...collectorRuleIds, ...UNBOUNDED_CROSS_FILE_RULE_IDS].sort()).toEqual(
+      [...CROSS_FILE_RULE_IDS].sort(),
+    );
+  });
 });
diff --git a/packages/core/tests/sidecar-lint-cache.test.ts b/packages/core/tests/sidecar-lint-cache.test.ts
new file mode 100644
index 0000000000..cc4ae422cf
--- /dev/null
+++ b/packages/core/tests/sidecar-lint-cache.test.ts
@@ -0,0 +1,147 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vite-plus/test";
+import type { Diagnostic } from "../src/types/index.js";
+import {
+  SIDECAR_LINT_CACHE_FILENAME,
+  SIDECAR_LINT_CACHE_SCHEMA_VERSION,
+} from "../src/constants.js";
+import { createSidecarLintCache } from "../src/runners/oxlint/sidecar-lint-cache.js";
+import type { SidecarFileEntry } from "../src/runners/oxlint/sidecar-lint-cache.js";
+
+const tempRoots: string[] = [];
+const makeCacheDir = (): string => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-sidecar-lint-cache-"));
+  tempRoots.push(dir);
+  return dir;
+};
+
+afterEach(() => {
+  for (const root of tempRoots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+const diagnostic = (overrides: Partial<Diagnostic> = {}): Diagnostic => ({
+  filePath: "src/app.tsx",
+  plugin: "react-doctor",
+  rule: "no-barrel-import",
+  severity: "warning",
+  message: "Import from a barrel file",
+  help: "Import directly",
+  line: 1,
+  column: 1,
+  category: "Bundle Size",
+  ...overrides,
+});
+
+const entry = (overrides: Partial<SidecarFileEntry> = {}): SidecarFileEntry => ({
+  probes: [
+    { kind: "content", path: "src/components/index.ts", answer: "hash-index" },
+    { kind: "exists", path: "src/components.tsx", answer: "none" },
+  ],
+  diagnostics: [diagnostic()],
+  ...overrides,
+});
+
+describe("createSidecarLintCache", () => {
+  it("round-trips probes + diagnostics across a persist + reload", () => {
+    const cacheDir = makeCacheDir();
+    const writer = createSidecarLintCache(cacheDir, "ruleset-1");
+    writer.store("src/app.tsx hashA", entry());
+    writer.store("src/clean.tsx hashB", entry({ diagnostics: [] }));
+    writer.persist();
+
+    const reader = createSidecarLintCache(cacheDir, "ruleset-1");
+    const replayed = reader.lookup("src/app.tsx hashA");
+    expect(replayed).not.toBeNull();
+    expect(replayed?.probes).toEqual(entry().probes);
+    expect(replayed?.diagnostics).toHaveLength(1);
+    expect(reader.lookup("src/clean.tsx hashB")?.diagnostics).toEqual([]);
+    expect(reader.lookup("src/never-seen.tsx hashZ")).toBeNull();
+  });
+
+  it("isolates entries by ruleset hash (a toolchain/config change is a clean miss)", () => {
+    const cacheDir = makeCacheDir();
+    const writer = createSidecarLintCache(cacheDir, "ruleset-1");
+    writer.store("src/app.tsx hashA", entry());
+    writer.persist();
+
+    expect(createSidecarLintCache(cacheDir, "ruleset-2").lookup("src/app.tsx hashA")).toBeNull();
+  });
+
+  it("degrades an entry with a malformed probe to a miss (never a partial guard)", () => {
+    const cacheDir = makeCacheDir();
+    fs.writeFileSync(
+      path.join(cacheDir, SIDECAR_LINT_CACHE_FILENAME),
+      JSON.stringify({
+        version: SIDECAR_LINT_CACHE_SCHEMA_VERSION,
+        rulesets: {
+          "ruleset-1": {
+            updatedAtMs: Date.now(),
+            files: {
+              "src/app.tsx hashA": {
+                // A probe tuple missing its answer — replaying diagnostics
+                // guarded by a truncated probe set could serve a stale verdict.
+                probes: [["content", "src/components/index.ts"]],
+                diagnostics: [diagnostic()],
+              },
+            },
+          },
+        },
+      }),
+    );
+    expect(createSidecarLintCache(cacheDir, "ruleset-1").lookup("src/app.tsx hashA")).toBeNull();
+  });
+
+  it("degrades an entry with a malformed diagnostic to a miss", () => {
+    const cacheDir = makeCacheDir();
+    fs.writeFileSync(
+      path.join(cacheDir, SIDECAR_LINT_CACHE_FILENAME),
+      JSON.stringify({
+        version: SIDECAR_LINT_CACHE_SCHEMA_VERSION,
+        rulesets: {
+          "ruleset-1": {
+            updatedAtMs: Date.now(),
+            files: {
+              "src/app.tsx hashA": {
+                probes: [],
+                diagnostics: [{ notADiagnostic: true }],
+              },
+            },
+          },
+        },
+      }),
+    );
+    expect(createSidecarLintCache(cacheDir, "ruleset-1").lookup("src/app.tsx hashA")).toBeNull();
+  });
+
+  it("fails open on a corrupt cache file (no throw, treated as empty)", () => {
+    const cacheDir = makeCacheDir();
+    fs.writeFileSync(path.join(cacheDir, SIDECAR_LINT_CACHE_FILENAME), "{ not json !!");
+    const cache = createSidecarLintCache(cacheDir, "ruleset-1");
+    expect(cache.lookup("src/app.tsx hashA")).toBeNull();
+    cache.store("src/app.tsx hashA", entry());
+    expect(() => cache.persist()).not.toThrow();
+    expect(
+      createSidecarLintCache(cacheDir, "ruleset-1").lookup("src/app.tsx hashA"),
+    ).not.toBeNull();
+  });
+
+  it("preserves sibling ruleset buckets when a different ruleset persists", () => {
+    const cacheDir = makeCacheDir();
+    const first = createSidecarLintCache(cacheDir, "ruleset-1");
+    first.store("src/app.tsx hashA", entry());
+    first.persist();
+
+    const second = createSidecarLintCache(cacheDir, "ruleset-2");
+    second.store("src/other.tsx hashB", entry({ diagnostics: [] }));
+    second.persist();
+
+    expect(
+      createSidecarLintCache(cacheDir, "ruleset-1").lookup("src/app.tsx hashA"),
+    ).not.toBeNull();
+    expect(
+      createSidecarLintCache(cacheDir, "ruleset-2").lookup("src/other.tsx hashB"),
+    ).not.toBeNull();
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/index.ts b/packages/oxlint-plugin-react-doctor/src/index.ts
index 7fa2d6aaba..b08d67d840 100644
--- a/packages/oxlint-plugin-react-doctor/src/index.ts
+++ b/packages/oxlint-plugin-react-doctor/src/index.ts
@@ -22,6 +22,13 @@ export { MOTION_LIBRARY_PACKAGES } from "./plugin/constants/style.js";
 
 export { CROSS_FILE_RULE_IDS } from "./plugin/constants/cross-file-rule-ids.js";
 
+export {
+  CROSS_FILE_DEPENDENCY_COLLECTORS,
+  UNBOUNDED_CROSS_FILE_RULE_IDS,
+  collectCrossFileDependencyProbes,
+} from "./plugin/cross-file-dependencies.js";
+export type { CrossFileProbeTrace } from "./plugin/utils/cross-file-probe-recorder.js";
+
 export {
   classifySecurityScanFile,
   shouldReadSecurityScanContent,
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/cross-file-rule-ids.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/cross-file-rule-ids.ts
index 3a21358d37..8fccac606d 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/cross-file-rule-ids.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/cross-file-rule-ids.ts
@@ -2,22 +2,27 @@
 // lint time. The per-file lint cache (`@react-doctor/core`'s `file-lint-cache`)
 // keys cached diagnostics on a single file's own content, so it would serve
 // STALE results for these rules when a dependency file changes. They are
-// therefore run in an always-fresh "sidecar" pass that is never cached.
+// therefore run in a separate "sidecar" pass whose caching is guarded by
+// per-file dependency fingerprints (`cross-file-dependencies.ts`) rather than
+// content alone — a rule here without a dependency collector re-lints every
+// file on every scan.
 //
-// Two flavors live here, both safe to keep always-fresh:
+// Two flavors live here:
 //   - Source-file readers — resolve imports / walk ancestor layouts and read
 //     OTHER source files (`no-barrel-import`, the two `nextjs-*` rules,
 //     `no-mutating-reducer-state`, and `rn-no-raw-text`, which resolves an
 //     imported component to see whether it forwards its children into a
-//     `<Text>` or a non-text host). These MUST stay uncached.
+//     `<Text>` or a non-text host).
 //   - Project-config readers — `rn-prefer-expo-image` classifies the owning
 //     package by reading the nearest `package.json`. That input is not folded
 //     into the ruleset hash, so it is carved here too (conservative, and only
 //     active on React Native / Expo projects).
 //
-// `cross-file-rules.test.ts` reproduces the transitive import-graph analysis
-// and fails if a rule reaching a cross-file primitive is missing from this set —
-// turning a future silent staleness bug into a failing test.
+// `cross-file-rule-ids.test.ts` reproduces the transitive import-graph
+// analysis and fails if a rule reaching a cross-file primitive is missing from
+// this set — turning a future silent staleness bug into a failing test. It
+// also forces every rule here into the bounded/unbounded classification in
+// `cross-file-dependencies.ts`.
 export const CROSS_FILE_RULE_IDS: ReadonlySet<string> = new Set([
   "no-barrel-import",
   "nextjs-missing-metadata",
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.test.ts
new file mode 100644
index 0000000000..4cca8fedf3
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.test.ts
@@ -0,0 +1,278 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
+import {
+  CROSS_FILE_DEPENDENCY_COLLECTORS,
+  collectCrossFileDependencyProbes,
+} from "./cross-file-dependencies.js";
+import { CROSS_FILE_RULE_IDS } from "./constants/cross-file-rule-ids.js";
+import { __clearParseSourceFileCacheForTests } from "./utils/parse-source-file.js";
+import { __clearTsconfigAliasCacheForTests } from "./utils/resolve-tsconfig-alias.js";
+
+// The collectors' contract (see cross-file-dependencies.ts): for a given file,
+// the recorded probe set must contain every path whose existence or content
+// the corresponding rule's cross-file reads can consult. These tests pin the
+// per-rule probe sets on real fixture trees — a dependency file must appear,
+// an unrelated file must not, and the negative resolution candidates that make
+// shadowing detectable must be present.
+
+let temporaryDirectory: string;
+
+beforeEach(() => {
+  temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "rd-cross-file-deps-"));
+  __clearParseSourceFileCacheForTests();
+  __clearTsconfigAliasCacheForTests();
+});
+
+afterEach(() => {
+  fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+});
+
+const writeFixtureFile = (relativePath: string, contents: string): string => {
+  const absolutePath = path.join(temporaryDirectory, relativePath);
+  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+  fs.writeFileSync(absolutePath, contents, "utf8");
+  return absolutePath;
+};
+
+const collectFor = (absoluteFilePath: string, ruleIds: ReadonlyArray<string>) =>
+  collectCrossFileDependencyProbes({
+    absoluteFilePath,
+    sourceText: fs.readFileSync(absoluteFilePath, "utf8"),
+    ruleIds,
+  });
+
+const fixturePath = (relativePath: string): string => path.join(temporaryDirectory, relativePath);
+
+describe("collectCrossFileDependencyProbes — driver", () => {
+  it("returns null for a rule without a collector (must degrade to unbounded)", () => {
+    const appPath = writeFixtureFile("App.tsx", "export const App = () => null;\n");
+    expect(collectFor(appPath, ["some-future-cross-file-rule"])).toBeNull();
+  });
+
+  it("returns null for a file with a fatal parse error (always re-lint)", () => {
+    const appPath = writeFixtureFile("broken.tsx", "const = ;;; <<<\n");
+    expect(collectFor(appPath, ["no-barrel-import"])).toBeNull();
+  });
+
+  it("collects an empty trace for a file with no cross-file reads", () => {
+    const appPath = writeFixtureFile("plain.tsx", "export const Plain = () => <div>ok</div>;\n");
+    const trace = collectFor(appPath, [
+      "no-barrel-import",
+      "no-mutating-reducer-state",
+      "nextjs-missing-metadata",
+      "nextjs-no-use-search-params-without-suspense",
+    ]);
+    expect(trace).not.toBeNull();
+    expect(trace?.contentPaths.size).toBe(0);
+    expect(trace?.existencePaths.size).toBe(0);
+  });
+});
+
+describe("no-barrel-import collector", () => {
+  const setupBarrelFixture = (): string => {
+    writeFixtureFile("src/components/Button.tsx", "export const Button = () => null;\n");
+    writeFixtureFile("src/components/index.ts", "export { Button } from './Button';\n");
+    writeFixtureFile("src/unrelated.tsx", "export const Unrelated = () => null;\n");
+    return writeFixtureFile(
+      "src/App.tsx",
+      `import { Button } from "./components";\nexport const App = () => <Button />;\n`,
+    );
+  };
+
+  it("records the barrel, its export target, and the resolution candidates", () => {
+    const appPath = setupBarrelFixture();
+    const trace = collectFor(appPath, ["no-barrel-import"]);
+    expect(trace).not.toBeNull();
+    // The barrel's content is read; a NAMED re-export target is only
+    // resolved (existence) — the rule never reads its content.
+    expect(trace?.contentPaths.has(fixturePath("src/components/index.ts"))).toBe(true);
+    expect(trace?.existencePaths.has(fixturePath("src/components/Button.tsx"))).toBe(true);
+    // The extension candidates probed (and absent) BEFORE the directory
+    // resolution — a file appearing at one of them shadows the barrel.
+    expect(trace?.existencePaths.has(fixturePath("src/components.ts"))).toBe(true);
+    expect(trace?.existencePaths.has(fixturePath("src/components.tsx"))).toBe(true);
+    // An unrelated sibling is NOT a dependency.
+    expect(trace?.contentPaths.has(fixturePath("src/unrelated.tsx"))).toBe(false);
+    expect(trace?.existencePaths.has(fixturePath("src/unrelated.tsx"))).toBe(false);
+  });
+
+  it("reads star-export targets' content (the name lookup goes through them)", () => {
+    writeFixtureFile("src/components/Button.tsx", "export const Button = () => null;\n");
+    writeFixtureFile("src/components/index.ts", "export * from './Button';\n");
+    const appPath = writeFixtureFile(
+      "src/App.tsx",
+      `import { Button } from "./components";\nexport const App = () => <Button />;\n`,
+    );
+    const trace = collectFor(appPath, ["no-barrel-import"]);
+    expect(trace?.contentPaths.has(fixturePath("src/components/Button.tsx"))).toBe(true);
+  });
+
+  it("records no probes for bare-module and side-effect-only imports", () => {
+    const appPath = writeFixtureFile(
+      "src/App.tsx",
+      `import * as React from "react";\nimport "./styles.css";\nexport const App = () => null;\n`,
+    );
+    const trace = collectFor(appPath, ["no-barrel-import"]);
+    expect(trace?.contentPaths.size).toBe(0);
+    expect(trace?.existencePaths.size).toBe(0);
+  });
+
+  it("records no probes for type-only relative imports (mirrors the rule)", () => {
+    writeFixtureFile("src/types/index.ts", "export type { Props } from './props';\n");
+    writeFixtureFile("src/types/props.ts", "export interface Props { id: string }\n");
+    const appPath = writeFixtureFile(
+      "src/App.tsx",
+      `import type { Props } from "./types";\nexport const App = (props: Props) => null;\n`,
+    );
+    const trace = collectFor(appPath, ["no-barrel-import"]);
+    expect(trace?.contentPaths.size).toBe(0);
+    expect(trace?.existencePaths.size).toBe(0);
+  });
+});
+
+describe("no-mutating-reducer-state collector", () => {
+  it("resolves import targets only when the file can reference useReducer", () => {
+    writeFixtureFile("src/reducer.ts", "export const reducer = (state) => state;\n");
+    const withHook = writeFixtureFile(
+      "src/Store.tsx",
+      `import { useReducer } from "react";\nimport { reducer } from "./reducer";\nexport const useStore = () => useReducer(reducer, {});\n`,
+    );
+    const withoutHook = writeFixtureFile(
+      "src/Plain.tsx",
+      `import { reducer } from "./reducer";\nexport const usePlain = () => reducer({});\n`,
+    );
+
+    const gatedInTrace = collectFor(withHook, ["no-mutating-reducer-state"]);
+    expect(gatedInTrace?.contentPaths.has(fixturePath("src/reducer.ts"))).toBe(true);
+
+    const gatedOutTrace = collectFor(withoutHook, ["no-mutating-reducer-state"]);
+    expect(gatedOutTrace?.contentPaths.size).toBe(0);
+    expect(gatedOutTrace?.existencePaths.size).toBe(0);
+  });
+
+  it("resolves only the imports actually passed to useReducer", () => {
+    writeFixtureFile("src/reducer.ts", "export const reducer = (state) => state;\n");
+    writeFixtureFile("src/helper.ts", "export const helper = () => 1;\n");
+    const storePath = writeFixtureFile(
+      "src/Store.tsx",
+      `import { useReducer } from "react";\nimport { reducer } from "./reducer";\nimport { helper } from "./helper";\nexport const useStore = () => useReducer(reducer, helper());\n`,
+    );
+    const trace = collectFor(storePath, ["no-mutating-reducer-state"]);
+    expect(trace?.contentPaths.has(fixturePath("src/reducer.ts"))).toBe(true);
+    // Imported but never a reducer argument — the rule never follows it.
+    expect(trace?.contentPaths.has(fixturePath("src/helper.ts"))).toBe(false);
+  });
+
+  it("records the tsconfig chain for alias-imported reducers on EVERY collection", () => {
+    writeFixtureFile("tsconfig.json", `{ "extends": "./tsconfig.base.json" }\n`);
+    writeFixtureFile(
+      "tsconfig.base.json",
+      `{ "compilerOptions": { "baseUrl": ".", "paths": { "@app/*": ["src/*"] } } }\n`,
+    );
+    writeFixtureFile("src/reducer.ts", "export const reducer = (state) => state;\n");
+    const storeSource = (label: string): string =>
+      `import { useReducer } from "react";\nimport { reducer } from "@app/reducer";\nexport const use${label} = () => useReducer(reducer, {});\n`;
+    const firstPath = writeFixtureFile("src/StoreA.tsx", storeSource("A"));
+    const secondPath = writeFixtureFile("src/StoreB.tsx", storeSource("B"));
+
+    const chainPaths = [fixturePath("tsconfig.json"), fixturePath("tsconfig.base.json")];
+    const firstTrace = collectFor(firstPath, ["no-mutating-reducer-state"]);
+    for (const chainPath of chainPaths) {
+      expect(firstTrace?.contentPaths.has(chainPath)).toBe(true);
+    }
+    expect(firstTrace?.contentPaths.has(fixturePath("src/reducer.ts"))).toBe(true);
+    // The second file resolves through the now-MEMOIZED tsconfig loader —
+    // the memo hit must replay the chain's probes, not swallow them.
+    const secondTrace = collectFor(secondPath, ["no-mutating-reducer-state"]);
+    for (const chainPath of chainPaths) {
+      expect(secondTrace?.contentPaths.has(chainPath)).toBe(true);
+    }
+    expect(secondTrace?.contentPaths.has(fixturePath("src/reducer.ts"))).toBe(true);
+  });
+
+  it("keeps the gate open for unicode-escaped identifiers (soundness fallback)", () => {
+    writeFixtureFile("src/reducer.ts", "export const reducer = (state) => state;\n");
+    // The fixture spells the property as `React.useReducer` — the raw
+    // text never contains "useReducer", only the cooked identifier does.
+    const escapedHook = writeFixtureFile(
+      "src/Escaped.tsx",
+      `import * as React from "react";\nimport { reducer } from "./reducer";\nexport const useStore = () => React.\\u0075seReducer(reducer, {});\n`,
+    );
+    const trace = collectFor(escapedHook, ["no-mutating-reducer-state"]);
+    expect(trace?.contentPaths.has(fixturePath("src/reducer.ts"))).toBe(true);
+  });
+});
+
+describe("nextjs collectors", () => {
+  it("records ancestor layout probes for a page file only", () => {
+    writeFixtureFile("app/layout.tsx", "export default ({ children }) => children;\n");
+    const pagePath = writeFixtureFile("app/products/page.tsx", "export default () => <div />;\n");
+    const componentPath = writeFixtureFile(
+      "app/products/list.tsx",
+      "export const List = () => <div />;\n",
+    );
+
+    const pageTrace = collectFor(pagePath, ["nextjs-missing-metadata"]);
+    expect(pageTrace?.contentPaths.has(fixturePath("app/products/layout.tsx"))).toBe(true);
+    expect(pageTrace?.contentPaths.has(fixturePath("app/layout.tsx"))).toBe(true);
+
+    const componentTrace = collectFor(componentPath, ["nextjs-missing-metadata"]);
+    expect(componentTrace?.contentPaths.size).toBe(0);
+  });
+
+  it("resolves imported components for a page without an ancestor Suspense layout", () => {
+    writeFixtureFile("app/results.tsx", "export const Results = () => <div />;\n");
+    const pagePath = writeFixtureFile(
+      "app/page.tsx",
+      `import { Results } from "./results";\nexport default () => <Results />;\n`,
+    );
+    const trace = collectFor(pagePath, ["nextjs-no-use-search-params-without-suspense"]);
+    expect(trace?.contentPaths.has(fixturePath("app/results.tsx"))).toBe(true);
+    // The layout candidates were probed on the walk (absent → content "absent").
+    expect(trace?.contentPaths.has(fixturePath("app/layout.tsx"))).toBe(true);
+  });
+});
+
+describe("react-native collectors", () => {
+  it("records the package.json walk for every file (the wrapper gate)", () => {
+    writeFixtureFile("package.json", `{ "dependencies": { "expo": "^50.0.0" } }\n`);
+    const appPath = writeFixtureFile("src/App.tsx", "export const App = () => null;\n");
+    const trace = collectFor(appPath, ["rn-prefer-expo-image"]);
+    expect(trace?.contentPaths.has(fixturePath("package.json"))).toBe(true);
+    expect(trace?.existencePaths.has(fixturePath("src/package.json"))).toBe(true);
+
+    // Re-collecting the same file hits the MEMOIZED directory walk — the
+    // memo hit must regenerate the walk's probes, not swallow them.
+    const repeatTrace = collectFor(appPath, ["rn-prefer-expo-image"]);
+    expect(repeatTrace?.contentPaths.has(fixturePath("package.json"))).toBe(true);
+    expect(repeatTrace?.existencePaths.has(fixturePath("src/package.json"))).toBe(true);
+  });
+
+  it("resolves imported components rendered as JSX for rn-no-raw-text", () => {
+    writeFixtureFile("package.json", `{ "dependencies": { "react-native": "0.74.0" } }\n`);
+    writeFixtureFile(
+      "src/Banner.tsx",
+      "export const Banner = ({ children }) => <>{children}</>;\n",
+    );
+    writeFixtureFile("src/helper.ts", "export const helper = () => 1;\n");
+    const appPath = writeFixtureFile(
+      "src/App.tsx",
+      `import { Banner } from "./Banner";\nimport { helper } from "./helper";\nexport const App = () => <Banner>hi {helper()}</Banner>;\n`,
+    );
+    const trace = collectFor(appPath, ["rn-no-raw-text"]);
+    expect(trace?.contentPaths.has(fixturePath("src/Banner.tsx"))).toBe(true);
+    // Imported but never rendered as JSX → not consulted by the rule's
+    // element resolution, so not a dependency.
+    expect(trace?.contentPaths.has(fixturePath("src/helper.ts"))).toBe(false);
+  });
+});
+
+describe("collector registry", () => {
+  it("ships a collector for every cross-file rule (none unbounded today)", () => {
+    expect([...CROSS_FILE_DEPENDENCY_COLLECTORS.keys()].sort()).toEqual(
+      [...CROSS_FILE_RULE_IDS].sort(),
+    );
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.ts b/packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.ts
new file mode 100644
index 0000000000..3d024cd43b
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/cross-file-dependencies.ts
@@ -0,0 +1,379 @@
+import { parseSync } from "oxc-parser";
+import type { StaticImport } from "oxc-parser";
+import {
+  INTERNAL_PAGE_PATH_PATTERN,
+  PAGE_FILE_PATTERN,
+  PAGE_OR_LAYOUT_FILE_PATTERN,
+} from "./constants/nextjs.js";
+import { classifyPackagePlatform } from "./utils/classify-package-platform.js";
+import { collectCrossFileProbes } from "./utils/cross-file-probe-recorder.js";
+import type { CrossFileProbeTrace } from "./utils/cross-file-probe-recorder.js";
+import type { EsTreeNode } from "./utils/es-tree-node.js";
+import { hasAncestorMetadataLayout } from "./utils/find-ancestor-metadata-layout.js";
+import { hasAncestorSuspenseLayout } from "./utils/find-ancestor-suspense-layout.js";
+import { isBarrelIndexModule } from "./utils/is-barrel-index-module.js";
+import { normalizeFilename } from "./utils/normalize-filename.js";
+import { resolveLang } from "./utils/parse-source-file.js";
+import { resolveBarrelExportFilePath } from "./utils/resolve-barrel-export-file-path.js";
+import { resolveCrossFileFunctionExport } from "./utils/resolve-cross-file-function-export.js";
+import { resolveRelativeImportPath } from "./utils/resolve-relative-import-path.js";
+import { stripParenExpression } from "./utils/strip-paren-expression.js";
+import { walkAst } from "./utils/walk-ast.js";
+
+/**
+ * Per-rule cross-file dependency collectors — the foundation of the sidecar
+ * lint cache's dependency fingerprints (`@react-doctor/core`,
+ * `runners/oxlint/sidecar-lint-cache.ts`).
+ *
+ * A collector re-runs the SAME resolver helpers its rule calls at lint time
+ * (import resolution, barrel following, ancestor-layout walks, package.json
+ * classification) under the probe recorder
+ * (`utils/cross-file-probe-recorder.ts`), so the recorded probe set is the
+ * exact set of filesystem facts the rule's execution consulted — including
+ * the negative probes (extension candidates that did NOT exist) that make
+ * resolution shadowing detectable when a new file appears.
+ *
+ * SOUNDNESS INVARIANT — each collector's probe set must be a SUPERSET of
+ * every filesystem read its rule can make while linting the file, for any
+ * file content and any filesystem state:
+ *
+ *   - Over-approximation is always safe (extra probes only cause a spurious
+ *     re-lint); under-approximation is forbidden (a missed probe could
+ *     replay a stale verdict).
+ *   - Where a rule gates its cross-file reads on in-file conditions, a
+ *     collector may skip the gate (probe more) or must mirror it EXACTLY
+ *     (probe the same). Each collector documents which it does per gate.
+ *   - The replay argument: the stored probe set is the complete read set of
+ *     the collector's execution at store time. If every stored probe has
+ *     the same answer on a later scan, re-executing the collector — and
+ *     therefore the rule, whose reads are a subset — reproduces the same
+ *     execution step by step (the file's own content is pinned separately
+ *     by the cache key's content hash), so the stored diagnostics are
+ *     exactly what a fresh sidecar lint would produce.
+ *
+ * A cross-file rule WITHOUT a collector here must be listed in
+ * `UNBOUNDED_CROSS_FILE_RULE_IDS` — it then re-lints every file on every
+ * scan (the sound fallback). `cross-file-rule-ids.test.ts` in
+ * `@react-doctor/core` forces every `CROSS_FILE_RULE_IDS` entry into
+ * exactly one of the two classifications.
+ */
+
+interface CrossFileDependencyCollectorInput {
+  /** Absolute, forward-slash-normalized path of the file being fingerprinted. */
+  readonly absoluteFilePath: string;
+  readonly sourceText: string;
+  /** oxc module record — the file's static import declarations. */
+  readonly staticImports: ReadonlyArray<StaticImport>;
+  /** Parsed program (no parent references attached). */
+  readonly program: EsTreeNode;
+}
+
+type CrossFileDependencyCollector = (input: CrossFileDependencyCollectorInput) => void;
+
+interface ImportEntryName {
+  readonly source: string;
+  readonly exportedName: string;
+}
+
+// Flattens the module record into (source, exportedName) pairs the resolver
+// helpers accept: named entries keep their pre-rename name, default entries
+// map to "default", namespace entries are dropped (every consumer rule's
+// binding lookup returns null / no export name for a namespace import, so no
+// rule follows them into another file). Type-only entries are KEPT — the
+// consuming rules' import lookups don't filter them.
+const flattenImportEntries = (staticImports: ReadonlyArray<StaticImport>): ImportEntryName[] => {
+  const flattened: ImportEntryName[] = [];
+  for (const staticImport of staticImports) {
+    for (const entry of staticImport.entries) {
+      if (entry.importName.kind === "NamespaceObject") continue;
+      const exportedName =
+        entry.importName.kind === "Default" ? "default" : (entry.importName.name ?? null);
+      if (exportedName === null) continue;
+      flattened.push({ source: staticImport.moduleRequest.value, exportedName });
+    }
+  }
+  return flattened;
+};
+
+// no-barrel-import reads, per relative runtime import: the resolution probe
+// chain (`resolveRelativeImportPath` — extension candidates, package.json
+// entries, index fallbacks), the resolved file's barrel classification, the
+// nearest package.json (for the report's RN wording), and — when building the
+// report message — the transitive barrel/re-export chain for each imported
+// name. The rule stops probing after its first report (`didReportForFile`)
+// and only follows the chain for the reported import; tracing EVERY relative
+// import is the superset. Type-only entries are skipped exactly like the
+// rule's `getRuntimeImportRequests`; a bare `import "./x"` has no entries and
+// is skipped before any resolution, also mirroring the rule.
+const collectNoBarrelImportDependencies: CrossFileDependencyCollector = ({
+  absoluteFilePath,
+  staticImports,
+}) => {
+  let didProbePackagePlatform = false;
+  for (const staticImport of staticImports) {
+    const source = staticImport.moduleRequest.value;
+    if (!source.startsWith(".")) continue;
+    const runtimeEntries = staticImport.entries.filter((entry) => !entry.isType);
+    if (runtimeEntries.length === 0) continue;
+
+    const resolvedImportPath = resolveRelativeImportPath(absoluteFilePath, source);
+    if (!resolvedImportPath || !isBarrelIndexModule(resolvedImportPath)) continue;
+
+    if (!didProbePackagePlatform) {
+      didProbePackagePlatform = true;
+      classifyPackagePlatform(absoluteFilePath);
+    }
+    for (const entry of runtimeEntries) {
+      const importedName = entry.importName.kind === "Default" ? "default" : entry.importName.name;
+      if (importedName) resolveBarrelExportFilePath(resolvedImportPath, importedName);
+    }
+  }
+};
+
+// nextjs-missing-metadata reads other files only through the ancestor
+// `layout.*` walk (`hasAncestorMetadataLayout`), and only for page files.
+// The rule's in-file early-outs ("use client", an own metadata export) are
+// deliberately NOT mirrored — always walking is the cheap superset (page
+// files are few), at the cost of a spurious re-lint when a layout changes
+// above a page that carries its own metadata.
+const collectNextjsMissingMetadataDependencies: CrossFileDependencyCollector = ({
+  absoluteFilePath,
+}) => {
+  if (!PAGE_FILE_PATTERN.test(absoluteFilePath)) return;
+  if (INTERNAL_PAGE_PATH_PATTERN.test(absoluteFilePath)) return;
+  hasAncestorMetadataLayout(absoluteFilePath);
+};
+
+// nextjs-no-use-search-params-without-suspense, for page/layout files, first
+// probes the ancestor layouts for a Suspense boundary and — exactly like the
+// rule — stops there when one is found. Otherwise it resolves imported
+// components rendered as JSX through `resolveCrossFileFunctionExport`;
+// tracing EVERY import entry (the rule's `collectImportedComponents` does not
+// filter type-only specifiers, so neither does this) is the superset of the
+// rendered-and-unwrapped subset the rule follows.
+const collectNextjsSearchParamsDependencies: CrossFileDependencyCollector = ({
+  absoluteFilePath,
+  staticImports,
+}) => {
+  if (!PAGE_OR_LAYOUT_FILE_PATTERN.test(absoluteFilePath)) return;
+  if (hasAncestorSuspenseLayout(absoluteFilePath)) return;
+  for (const entry of flattenImportEntries(staticImports)) {
+    resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
+  }
+};
+
+// no-mutating-reducer-state only reads another file when a `useReducer`
+// call's reducer argument resolves to an imported binding, and the call must
+// be wired to a react import: either a named `useReducer` import (any alias —
+// the module record's cooked names see through every escape) or a member call
+// on a react default/namespace import. The member form's `useReducer`
+// property can only hide behind a `\u` identifier escape, so the lexical
+// gate below is a sound superset for it. Gated-in files walk the AST for the
+// statically matchable call shapes and trace the resolution of every import
+// entry used as a reducer argument — a superset of what the rule follows
+// (the rule additionally abstains when a local binding shadows the import).
+const collectMutatingReducerDependencies: CrossFileDependencyCollector = ({
+  absoluteFilePath,
+  sourceText,
+  staticImports,
+  program,
+}) => {
+  const namedUseReducerLocals = new Set<string>();
+  const reactObjectLocals = new Set<string>();
+  for (const staticImport of staticImports) {
+    if (staticImport.moduleRequest.value !== "react") continue;
+    for (const entry of staticImport.entries) {
+      if (entry.importName.kind === "Name" && entry.importName.name === "useReducer") {
+        namedUseReducerLocals.add(entry.localName.value);
+      } else if (
+        entry.importName.kind === "Default" ||
+        entry.importName.kind === "NamespaceObject"
+      ) {
+        reactObjectLocals.add(entry.localName.value);
+      }
+    }
+  }
+  const mayCallUseReducer =
+    namedUseReducerLocals.size > 0 ||
+    (reactObjectLocals.size > 0 &&
+      (sourceText.includes("useReducer") || sourceText.includes("\\u")));
+  if (!mayCallUseReducer) return;
+
+  const identifierName = (node: EsTreeNode | null | undefined): string | null => {
+    if (node?.type !== "Identifier") return null;
+    const { name } = node as { name?: unknown };
+    return typeof name === "string" ? name : null;
+  };
+  // Mirrors the rule's `isCallToImportedReactUseReducer` shapes: a named
+  // useReducer local, or `<reactObject>.useReducer` (computed members with an
+  // Identifier property match the rule too, so no `computed` check here).
+  const isUseReducerCallee = (callee: EsTreeNode): boolean => {
+    const calleeName = identifierName(callee);
+    if (calleeName !== null) return namedUseReducerLocals.has(calleeName);
+    if (callee.type !== "MemberExpression") return false;
+    const member = callee as { object?: EsTreeNode; property?: EsTreeNode };
+    const objectName = identifierName(member.object);
+    return (
+      objectName !== null &&
+      reactObjectLocals.has(objectName) &&
+      identifierName(member.property) === "useReducer"
+    );
+  };
+
+  const reducerArgumentNames = new Set<string>();
+  walkAst(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const call = node as { callee?: EsTreeNode; arguments?: ReadonlyArray<EsTreeNode> };
+    if (!call.callee || !isUseReducerCallee(call.callee)) return;
+    const reducerArgument = call.arguments?.[0];
+    if (!reducerArgument) return;
+    const argumentName = identifierName(stripParenExpression(reducerArgument));
+    if (argumentName !== null) reducerArgumentNames.add(argumentName);
+  });
+  if (reducerArgumentNames.size === 0) return;
+
+  for (const staticImport of staticImports) {
+    for (const entry of staticImport.entries) {
+      if (entry.importName.kind === "NamespaceObject") continue;
+      if (!reducerArgumentNames.has(entry.localName.value)) continue;
+      const exportedName = entry.importName.kind === "Default" ? "default" : entry.importName.name;
+      if (exportedName) {
+        resolveCrossFileFunctionExport(
+          absoluteFilePath,
+          staticImport.moduleRequest.value,
+          exportedName,
+        );
+      }
+    }
+  }
+};
+
+// The JSX names rn-no-raw-text's boundary checks consult
+// (`resolveTextBoundaryName`): plain identifiers, the property of a member
+// tag, and the namespace of a namespaced tag.
+const collectJsxBoundaryNames = (program: EsTreeNode): Set<string> => {
+  const jsxNames = new Set<string>();
+  walkAst(program, (node) => {
+    if (node.type !== "JSXOpeningElement") return;
+    const nameNode = (node as { name?: EsTreeNode }).name;
+    if (!nameNode) return;
+    if (nameNode.type === "JSXIdentifier") {
+      const name = (nameNode as { name?: unknown }).name;
+      if (typeof name === "string") jsxNames.add(name);
+    } else if (nameNode.type === "JSXMemberExpression") {
+      const property = (nameNode as { property?: { type?: string; name?: unknown } }).property;
+      if (property?.type === "JSXIdentifier" && typeof property.name === "string") {
+        jsxNames.add(property.name);
+      }
+    } else if (nameNode.type === "JSXNamespacedName") {
+      const namespace = (nameNode as { namespace?: { name?: unknown } }).namespace;
+      if (typeof namespace?.name === "string") jsxNames.add(namespace.name);
+    }
+  });
+  return jsxNames;
+};
+
+// rn-no-raw-text reads other files two ways: the package-platform gate
+// (`wrapReactNativeRule` + the rule's own RN checks — probed on EVERY file
+// the rule is enabled for) and `resolveImportedComponentForwarding` for JSX
+// element names bound to non-namespace imports. Resolving every imported
+// name that appears as a JSX boundary name — without the rule's raw-text /
+// text-component-name gates — is the superset of the elements the rule
+// actually resolves.
+const collectRnNoRawTextDependencies: CrossFileDependencyCollector = ({
+  absoluteFilePath,
+  staticImports,
+  program,
+}) => {
+  classifyPackagePlatform(absoluteFilePath);
+  const jsxNames = collectJsxBoundaryNames(program);
+  if (jsxNames.size === 0) return;
+  for (const staticImport of staticImports) {
+    for (const entry of staticImport.entries) {
+      if (entry.importName.kind === "NamespaceObject") continue;
+      if (!jsxNames.has(entry.localName.value)) continue;
+      const exportedName = entry.importName.kind === "Default" ? "default" : entry.importName.name;
+      if (exportedName) {
+        resolveCrossFileFunctionExport(
+          absoluteFilePath,
+          staticImport.moduleRequest.value,
+          exportedName,
+        );
+      }
+    }
+  }
+};
+
+// rn-prefer-expo-image's only cross-file input is the package-platform
+// classification (`isExpoManagedFileActive` + the `wrapReactNativeRule`
+// gate): the ancestor package.json walk plus the nearest manifest's content.
+const collectRnPreferExpoImageDependencies: CrossFileDependencyCollector = ({
+  absoluteFilePath,
+}) => {
+  classifyPackagePlatform(absoluteFilePath);
+};
+
+export const CROSS_FILE_DEPENDENCY_COLLECTORS: ReadonlyMap<string, CrossFileDependencyCollector> =
+  new Map([
+    ["no-barrel-import", collectNoBarrelImportDependencies],
+    ["nextjs-missing-metadata", collectNextjsMissingMetadataDependencies],
+    ["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
+    ["no-mutating-reducer-state", collectMutatingReducerDependencies],
+    ["rn-no-raw-text", collectRnNoRawTextDependencies],
+    ["rn-prefer-expo-image", collectRnPreferExpoImageDependencies],
+  ]);
+
+/**
+ * Cross-file rules whose dependency set CANNOT be soundly bounded — they are
+ * excluded from fingerprinting and re-lint every file on every scan. Empty
+ * today; a new cross-file rule must be added either here or to
+ * `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
+ * partition), forcing a conscious classification.
+ */
+export const UNBOUNDED_CROSS_FILE_RULE_IDS: ReadonlySet<string> = new Set();
+
+/**
+ * Runs the collectors for `ruleIds` over one file and returns every
+ * filesystem probe they made — the file's cross-file dependency set.
+ *
+ * Returns `null` (caller must treat the file as unfingerprintable and always
+ * re-lint it) when the file has a fatal parse error — an execution the
+ * collectors cannot mirror — or when a requested rule has no collector.
+ */
+export const collectCrossFileDependencyProbes = (input: {
+  absoluteFilePath: string;
+  sourceText: string;
+  ruleIds: ReadonlyArray<string>;
+}): CrossFileProbeTrace | null => {
+  const collectors: CrossFileDependencyCollector[] = [];
+  for (const ruleId of input.ruleIds) {
+    const collector = CROSS_FILE_DEPENDENCY_COLLECTORS.get(ruleId);
+    if (!collector) return null;
+    collectors.push(collector);
+  }
+
+  const absoluteFilePath = normalizeFilename(input.absoluteFilePath);
+  let staticImports: ReadonlyArray<StaticImport>;
+  let program: EsTreeNode;
+  try {
+    const parseResult = parseSync(absoluteFilePath, input.sourceText, {
+      astType: "ts",
+      lang: resolveLang(absoluteFilePath),
+    });
+    if (parseResult.errors.some((parseError) => parseError.severity === "Error")) return null;
+    staticImports = parseResult.module.staticImports;
+    program = parseResult.program as unknown as EsTreeNode;
+  } catch {
+    return null;
+  }
+
+  const collectorInput: CrossFileDependencyCollectorInput = {
+    absoluteFilePath,
+    sourceText: input.sourceText,
+    staticImports,
+    program,
+  };
+  return collectCrossFileProbes(() => {
+    for (const collector of collectors) collector(collectorInput);
+  });
+};
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/classify-package-platform.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/classify-package-platform.ts
index 1e992a9450..4b71b2adcb 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/classify-package-platform.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/classify-package-platform.ts
@@ -4,6 +4,11 @@ import {
   isExpoManagedDependencyName,
   isReactNativeDependencyName,
 } from "../../react-native-dependency-names.js";
+import {
+  isProbeRecorderActive,
+  recordContentProbe,
+  recordExistenceProbe,
+} from "./cross-file-probe-recorder.js";
 
 // Packages that mark the manifest as a web-only React target. If a manifest
 // contains one of these AND has no React Native indicator, every React
@@ -43,12 +48,31 @@ const cachedPackageDirectoryByFilename = new Map<string, string | null>();
 const findNearestPackageDirectory = (filename: string): string | null => {
   if (!filename) return null;
 
+  // The walk's outcome depends on EVERY ancestor probe (a package.json
+  // appearing closer to the file re-anchors the classification), so a memo
+  // hit regenerates the walk's existence probes LEXICALLY — the exact
+  // candidate list is derivable from the filename and the memoized stop
+  // directory without touching the filesystem
+  // (see cross-file-probe-recorder.ts).
   const fromCache = cachedPackageDirectoryByFilename.get(filename);
-  if (fromCache !== undefined) return fromCache;
+  if (fromCache !== undefined) {
+    if (isProbeRecorderActive()) {
+      let probedDirectory = path.dirname(filename);
+      while (true) {
+        recordExistenceProbe(path.join(probedDirectory, "package.json"));
+        if (probedDirectory === fromCache) break;
+        const parentDirectory = path.dirname(probedDirectory);
+        if (parentDirectory === probedDirectory) break;
+        probedDirectory = parentDirectory;
+      }
+    }
+    return fromCache;
+  }
 
   let currentDirectory = path.dirname(filename);
   while (true) {
     const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+    recordExistenceProbe(candidatePackageJsonPath);
     let hasPackageJson = false;
     try {
       hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
@@ -166,6 +190,10 @@ export const classifyPackagePlatform = (filename: string): PackagePlatform => {
   const packageDirectory = findNearestPackageDirectory(filename);
   if (!packageDirectory) return "unknown";
 
+  // Recorded BEFORE the memo lookup — the classification is a pure function
+  // of this one manifest's content, so the probe alone captures the
+  // dependency while the memo stays warm (see cross-file-probe-recorder.ts).
+  recordContentProbe(path.join(packageDirectory, "package.json"));
   const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
   if (cached !== undefined) return cached;
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/cross-file-probe-recorder.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/cross-file-probe-recorder.ts
new file mode 100644
index 0000000000..1eda277fcc
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/cross-file-probe-recorder.ts
@@ -0,0 +1,67 @@
+// Filesystem-probe recorder for the cross-file dependency collectors
+// (`cross-file-dependencies.ts`). While a recorder is active, every
+// cross-file helper that touches the filesystem reports WHICH paths its
+// outcome depends on — existence probes (module-resolution candidates,
+// package.json walks) and content probes (files whose bytes were read or
+// whose parsed shape was consumed). The recorded probe set is the file's
+// dependency fingerprint input: if every probed path still has the same
+// answer (existence classification / content hash) on a later scan, the
+// helpers — and therefore the cross-file rules built on them — are
+// guaranteed to produce the same verdict for an unchanged file.
+//
+// SOUNDNESS INVARIANT (the whole sidecar-cache scheme rests on this):
+// every helper reachable from a cross-file rule that reads the existence
+// or content of a file OTHER than the one being linted MUST report each
+// consulted path here. Two integration rules keep that true:
+//
+//   - single-file-derived caches (`parse-source-file`,
+//     `does-module-export-name`, `is-barrel-index-module`) record the
+//     content probe BEFORE their cache lookup — the cached value is a pure
+//     function of that one file's content, so the probe alone captures the
+//     dependency and the cache stays warm;
+//   - multi-file-derived memos (`classify-package-platform`'s directory
+//     walk, `resolve-tsconfig-alias`'s extends-chain loader) BYPASS their
+//     memo while a recorder is active (still repopulating it), because a
+//     memo hit would skip the intermediate probes the fingerprint needs.
+//
+// Recording is synchronous and single-flight: collectors run in the core
+// orchestrator's synchronous sections, so a module-level slot is safe.
+// When no recorder is active (every production lint path inside oxlint),
+// both record functions are a single null check.
+
+export interface CrossFileProbeTrace {
+  /** Paths whose existence classification (file / dir / none) was consulted. */
+  readonly existencePaths: Set<string>;
+  /** Paths whose content (bytes, exports, parse) was consulted. */
+  readonly contentPaths: Set<string>;
+}
+
+let activeProbeTrace: CrossFileProbeTrace | null = null;
+
+export const recordExistenceProbe = (absolutePath: string): void => {
+  activeProbeTrace?.existencePaths.add(absolutePath);
+};
+
+export const recordContentProbe = (absolutePath: string): void => {
+  activeProbeTrace?.contentPaths.add(absolutePath);
+};
+
+export const isProbeRecorderActive = (): boolean => activeProbeTrace !== null;
+
+// Runs `collect` with a fresh trace installed and returns everything it
+// probed. Re-entrant use is a programming error — the collectors never
+// nest — so the previous trace is restored defensively rather than merged.
+export const collectCrossFileProbes = (collect: () => void): CrossFileProbeTrace => {
+  const previousTrace = activeProbeTrace;
+  const trace: CrossFileProbeTrace = {
+    existencePaths: new Set<string>(),
+    contentPaths: new Set<string>(),
+  };
+  activeProbeTrace = trace;
+  try {
+    collect();
+  } finally {
+    activeProbeTrace = previousTrace;
+  }
+  return trace;
+};
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts
index 91f55f6dd9..6ea7571f96 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/does-module-export-name.ts
@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { recordContentProbe } from "./cross-file-probe-recorder.js";
 import { parseExportSpecifiers } from "./parse-export-specifiers.js";
 import { stripJsComments } from "./strip-js-comments.js";
 
@@ -41,6 +42,10 @@ interface ExportNamesCacheEntry {
 const exportNamesCache = new Map<string, ExportNamesCacheEntry>();
 
 export const doesModuleExportName = (filePath: string, exportedName: string): boolean => {
+  // Recorded BEFORE the cache lookup — the export set is a pure function of
+  // this one file's content (see cross-file-probe-recorder.ts). An absent
+  // file lands in the same probe: its content answer is "absent".
+  recordContentProbe(filePath);
   try {
     const fileStat = fs.statSync(filePath);
     const cached = exportNamesCache.get(filePath);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-barrel-index-module.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-barrel-index-module.ts
index 5ff4293010..568f8bdcc5 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-barrel-index-module.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-barrel-index-module.ts
@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { recordContentProbe } from "./cross-file-probe-recorder.js";
 import { parseExportSpecifiers } from "./parse-export-specifiers.js";
 import { stripJsComments } from "./strip-js-comments.js";
 
@@ -32,7 +33,17 @@ interface ImportedBinding {
   didExport: boolean;
 }
 
-const barrelIndexModuleInfoCache = new Map<string, BarrelIndexModuleInfo>();
+interface BarrelInfoCacheEntry {
+  mtimeMs: number;
+  size: number;
+  moduleInfo: BarrelIndexModuleInfo;
+}
+
+// Keyed by mtime/size like its siblings (`parse-source-file.ts`,
+// `does-module-export-name.ts`) so a long-lived process — the language
+// server, repeated `diagnose()` calls — re-reads a barrel that changed on
+// disk instead of serving a stale classification.
+const barrelIndexModuleInfoCache = new Map<string, BarrelInfoCacheEntry>();
 
 const isIndexModuleFilePath = (filePath: string): boolean =>
   INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
@@ -215,10 +226,31 @@ const classifyBarrelModule = (sourceText: string): BarrelIndexModuleInfo => {
 };
 
 export const getBarrelIndexModuleInfo = (filePath: string): BarrelIndexModuleInfo => {
+  // Non-index paths never touch the filesystem — the answer is a pure
+  // function of the filename, so no probe is recorded for them.
   if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
 
+  // Recorded BEFORE the cache lookup: the classification is a pure function
+  // of this one file's content, so the content probe alone captures the
+  // dependency while the cache stays warm (see cross-file-probe-recorder.ts).
+  recordContentProbe(filePath);
+
+  let fileStat: fs.Stats | null;
+  try {
+    fileStat = fs.statSync(filePath);
+  } catch {
+    fileStat = null;
+  }
   const cachedResult = barrelIndexModuleInfoCache.get(filePath);
-  if (cachedResult !== undefined) return cachedResult;
+  if (
+    cachedResult !== undefined &&
+    fileStat !== null &&
+    cachedResult.mtimeMs === fileStat.mtimeMs &&
+    cachedResult.size === fileStat.size
+  ) {
+    return cachedResult.moduleInfo;
+  }
+  if (fileStat === null) return createNonBarrelInfo();
 
   let moduleInfo = createNonBarrelInfo();
   try {
@@ -227,7 +259,11 @@ export const getBarrelIndexModuleInfo = (filePath: string): BarrelIndexModuleInf
     moduleInfo = createNonBarrelInfo();
   }
 
-  barrelIndexModuleInfoCache.set(filePath, moduleInfo);
+  barrelIndexModuleInfoCache.set(filePath, {
+    mtimeMs: fileStat.mtimeMs,
+    size: fileStat.size,
+    moduleInfo,
+  });
   return moduleInfo;
 };
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/parse-source-file.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/parse-source-file.ts
index b1a90cfaa2..8d4ea1a687 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/parse-source-file.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/parse-source-file.ts
@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { parseSync } from "oxc-parser";
 import { CROSS_FILE_PARSE_MAX_BYTES } from "../constants/thresholds.js";
 import { attachParentReferences } from "./attach-parent-references.js";
+import { recordContentProbe } from "./cross-file-probe-recorder.js";
 import type { EsTreeNode } from "./es-tree-node.js";
 
 const FILENAME_TO_LANG: Record<string, "ts" | "tsx" | "js" | "jsx"> = {
@@ -16,7 +17,9 @@ const FILENAME_TO_LANG: Record<string, "ts" | "tsx" | "js" | "jsx"> = {
   ".cts": "ts",
 };
 
-const resolveLang = (filename: string): "ts" | "tsx" | "js" | "jsx" => {
+// Exported so the cross-file dependency collectors parse a file with the
+// SAME language selection as the rules' own cross-file parses.
+export const resolveLang = (filename: string): "ts" | "tsx" | "js" | "jsx" => {
   const extension = path.extname(filename).toLowerCase();
   return FILENAME_TO_LANG[extension] ?? "tsx";
 };
@@ -59,6 +62,17 @@ const parseCache = new Map<string, CacheEntry>();
 // Node process, which matches the way oxlint runs a single batch
 // of files per process.
 export const parseSourceFile = (absoluteFilePath: string): EsTreeNode | null => {
+  // Declaration files are constant-null regardless of the filesystem (absent,
+  // present, any size — every branch below lands on `null`), so they are not
+  // a dependency and record no probe. Everything else records its content
+  // probe BEFORE the cache lookup — the parse is a pure function of this one
+  // file's content (see cross-file-probe-recorder.ts).
+  const isDeclarationFile =
+    absoluteFilePath.endsWith(".d.ts") ||
+    absoluteFilePath.endsWith(".d.mts") ||
+    absoluteFilePath.endsWith(".d.cts");
+  if (!isDeclarationFile) recordContentProbe(absoluteFilePath);
+
   let fileStat: fs.Stats;
   try {
     fileStat = fs.statSync(absoluteFilePath);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-relative-import-path.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-relative-import-path.ts
index dbc008c4db..c99d9dba09 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-relative-import-path.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-relative-import-path.ts
@@ -1,11 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { recordContentProbe, recordExistenceProbe } from "./cross-file-probe-recorder.js";
 
 const MODULE_FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
 const PACKAGE_EXPORT_CONDITIONS = ["import", "default", "module", "browser", "require"];
 const PACKAGE_ENTRY_FIELDS = ["module", "main", "browser"];
 
 const getExistingFilePath = (filePath: string): string | null => {
+  recordExistenceProbe(filePath);
   try {
     return fs.statSync(filePath).isFile() ? filePath : null;
   } catch {
@@ -14,6 +16,7 @@ const getExistingFilePath = (filePath: string): string | null => {
 };
 
 const getExistingDirectoryPath = (directoryPath: string): string | null => {
+  recordExistenceProbe(directoryPath);
   try {
     return fs.statSync(directoryPath).isDirectory() ? directoryPath : null;
   } catch {
@@ -88,6 +91,7 @@ const resolvePackageDirectoryEntry = (directoryPath: string): string | null => {
   if (!existingDirectoryPath) return null;
 
   const packageJsonPath = path.join(existingDirectoryPath, "package.json");
+  recordContentProbe(packageJsonPath);
   try {
     const packageJson: Record<string, unknown> = JSON.parse(
       fs.readFileSync(packageJsonPath, "utf8"),
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-tsconfig-alias.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-tsconfig-alias.ts
index ef2717834c..560bae1125 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-tsconfig-alias.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/resolve-tsconfig-alias.ts
@@ -4,6 +4,7 @@ import {
   CROSS_FILE_DIRECTORY_WALK_MAX_LEVELS,
   TSCONFIG_EXTENDS_MAX_DEPTH,
 } from "../constants/thresholds.js";
+import { recordContentProbe } from "./cross-file-probe-recorder.js";
 import { resolveModuleFileFromAbsolutePath } from "./resolve-relative-import-path.js";
 
 interface ResolvedTsconfig {
@@ -74,7 +75,12 @@ const stripJsonComments = (text: string): string => {
   return output.replace(/,(\s*[}\]])/g, "$1");
 };
 
-const parseTsconfigFile = (configFilePath: string): Record<string, unknown> | null => {
+const parseTsconfigFile = (
+  configFilePath: string,
+  probedPaths: string[],
+): Record<string, unknown> | null => {
+  recordContentProbe(configFilePath);
+  probedPaths.push(configFilePath);
   let sourceText: string;
   try {
     sourceText = fs.readFileSync(configFilePath, "utf8");
@@ -119,8 +125,9 @@ const parsePathsField = (pathsField: unknown): Map<string, readonly string[]> =>
 const readResolvedTsconfig = (
   configFilePath: string,
   extendsDepth: number,
+  probedPaths: string[],
 ): ResolvedTsconfig | null => {
-  const parsed = parseTsconfigFile(configFilePath);
+  const parsed = parseTsconfigFile(configFilePath, probedPaths);
   if (!parsed) return null;
 
   const configDirectory = path.dirname(configFilePath);
@@ -136,7 +143,9 @@ const readResolvedTsconfig = (
 
   if (typeof parsed.extends === "string" && extendsDepth < TSCONFIG_EXTENDS_MAX_DEPTH) {
     const parentPath = resolveExtendsPath(parsed.extends, configDirectory);
-    const inherited = parentPath ? readResolvedTsconfig(parentPath, extendsDepth + 1) : null;
+    const inherited = parentPath
+      ? readResolvedTsconfig(parentPath, extendsDepth + 1, probedPaths)
+      : null;
     if (inherited) return inherited;
   }
 
@@ -146,22 +155,41 @@ const readResolvedTsconfig = (
 interface CacheEntry {
   readonly mtimeMs: number;
   readonly config: ResolvedTsconfig | null;
+  /** Every tsconfig read while resolving the `extends` chain, in order. */
+  readonly probedChainPaths: ReadonlyArray<string>;
 }
 
 const configByFilePath = new Map<string, CacheEntry>();
 
 const loadTsconfigCached = (configFilePath: string): ResolvedTsconfig | null => {
+  // A missing entry config resolves to null without reading anything else,
+  // so the entry path itself is always a content dependency (its answer is
+  // "absent" when the statSync throws).
+  recordContentProbe(configFilePath);
   let fileStat: fs.Stats;
   try {
     fileStat = fs.statSync(configFilePath);
   } catch {
     return null;
   }
+  // The resolved config depends on the whole `extends` CHAIN, not just this
+  // entry file, so each entry remembers the chain paths it read and replays
+  // them into an active probe recorder on a memo hit — the fingerprint gets
+  // the full chain without re-parsing it per file
+  // (see cross-file-probe-recorder.ts).
   const cached = configByFilePath.get(configFilePath);
-  if (cached && cached.mtimeMs === fileStat.mtimeMs) return cached.config;
+  if (cached && cached.mtimeMs === fileStat.mtimeMs) {
+    for (const probedPath of cached.probedChainPaths) recordContentProbe(probedPath);
+    return cached.config;
+  }
 
-  const config = readResolvedTsconfig(configFilePath, 0);
-  configByFilePath.set(configFilePath, { mtimeMs: fileStat.mtimeMs, config });
+  const probedChainPaths: string[] = [];
+  const config = readResolvedTsconfig(configFilePath, 0, probedChainPaths);
+  configByFilePath.set(configFilePath, {
+    mtimeMs: fileStat.mtimeMs,
+    config,
+    probedChainPaths,
+  });
   return config;
 };
 
diff --git a/packages/react-doctor/src/cli/utils/build-run-event.ts b/packages/react-doctor/src/cli/utils/build-run-event.ts
index d2b2616ff5..00ea8d5ddc 100644
--- a/packages/react-doctor/src/cli/utils/build-run-event.ts
+++ b/packages/react-doctor/src/cli/utils/build-run-event.ts
@@ -280,6 +280,14 @@ const buildOutcomeAttributes = (input: RunEventInput): RunEventAttributes => {
         result.lintCacheTotalFileCount != null && result.lintCacheTotalFileCount > 0
           ? (result.lintCacheHitFileCount ?? 0) / result.lintCacheTotalFileCount
           : null,
+      // Sidecar lint cache outcome — same shape as the per-file cache dims;
+      // all `null` when the sidecar cache was off/bypassed.
+      sidecarReplayedFiles: result.lintSidecarReplayedFileCount ?? null,
+      sidecarTotalFiles: result.lintSidecarTotalFileCount ?? null,
+      sidecarReplayRatio:
+        result.lintSidecarTotalFileCount != null && result.lintSidecarTotalFileCount > 0
+          ? (result.lintSidecarReplayedFileCount ?? 0) / result.lintSidecarTotalFileCount
+          : null,
     }),
     ...withNamespace("deadCode", {
       failed: input.didDeadCodeFail ?? null,
diff --git a/packages/react-doctor/src/inspect.ts b/packages/react-doctor/src/inspect.ts
index d3e6a227a6..962edc43bd 100644
--- a/packages/react-doctor/src/inspect.ts
+++ b/packages/react-doctor/src/inspect.ts
@@ -792,6 +792,8 @@ const runInspectWithRuntime = async (
     baselineDegraded,
     lintCacheHitFileCount: output.lintCacheHitFileCount,
     lintCacheTotalFileCount: output.lintCacheTotalFileCount,
+    lintSidecarReplayedFileCount: output.lintSidecarReplayedFileCount,
+    lintSidecarTotalFileCount: output.lintSidecarTotalFileCount,
     deadCodeCacheHit: output.deadCodeCacheHit,
     deadCodeSummaryCacheHits: output.deadCodeSummaryCacheHits,
     deadCodeSummaryCacheMisses: output.deadCodeSummaryCacheMisses,
@@ -818,6 +820,8 @@ interface FinalizeInput {
   scanElapsedMilliseconds: number;
   lintCacheHitFileCount: number | null;
   lintCacheTotalFileCount: number | null;
+  lintSidecarReplayedFileCount: number | null;
+  lintSidecarTotalFileCount: number | null;
   deadCodeCacheHit: boolean | null;
   deadCodeSummaryCacheHits: number | null;
   deadCodeSummaryCacheMisses: number | null;
@@ -848,6 +852,12 @@ interface RenderAndRecordScanInput {
    */
   readonly lintCacheHitFileCount?: number | null;
   readonly lintCacheTotalFileCount?: number | null;
+  /**
+   * Sidecar lint cache outcome for THIS scan's lint pass. Threaded outside
+   * `CachedScanPayload` for the same reason as the lint cache stats above.
+   */
+  readonly lintSidecarReplayedFileCount?: number | null;
+  readonly lintSidecarTotalFileCount?: number | null;
   /**
    * Dead-code result cache outcome for THIS scan's dead-code pass. Threaded
    * outside `CachedScanPayload` for the same reason as the lint cache stats
@@ -907,6 +917,8 @@ const renderAndRecordScan = async (input: RenderAndRecordScanInput): Promise<Ins
     scanElapsedMilliseconds: input.payload.scanElapsedMilliseconds,
     lintCacheHitFileCount: input.lintCacheHitFileCount ?? null,
     lintCacheTotalFileCount: input.lintCacheTotalFileCount ?? null,
+    lintSidecarReplayedFileCount: input.lintSidecarReplayedFileCount ?? null,
+    lintSidecarTotalFileCount: input.lintSidecarTotalFileCount ?? null,
     deadCodeCacheHit: input.deadCodeCacheHit ?? null,
     deadCodeSummaryCacheHits: input.deadCodeSummaryCacheHits ?? null,
     deadCodeSummaryCacheMisses: input.deadCodeSummaryCacheMisses ?? null,
@@ -982,6 +994,8 @@ const finalizeAndRender = (input: FinalizeInput): Effect.Effect<InspectResult> =
       scanElapsedMilliseconds,
       lintCacheHitFileCount,
       lintCacheTotalFileCount,
+      lintSidecarReplayedFileCount,
+      lintSidecarTotalFileCount,
       deadCodeCacheHit,
       deadCodeSummaryCacheHits,
       deadCodeSummaryCacheMisses,
@@ -1012,6 +1026,9 @@ const finalizeAndRender = (input: FinalizeInput): Effect.Effect<InspectResult> =
       ...(lintCacheTotalFileCount !== null
         ? { lintCacheHitFileCount, lintCacheTotalFileCount }
         : {}),
+      ...(lintSidecarTotalFileCount !== null
+        ? { lintSidecarReplayedFileCount, lintSidecarTotalFileCount }
+        : {}),
       ...(deadCodeCacheHit !== null ? { deadCodeCacheHit } : {}),
       ...(deadCodeSummaryCacheHits !== null && deadCodeSummaryCacheMisses !== null
         ? { deadCodeSummaryCacheHits, deadCodeSummaryCacheMisses }
diff --git a/packages/react-doctor/tests/run-oxlint/sidecar-lint-cache.test.ts b/packages/react-doctor/tests/run-oxlint/sidecar-lint-cache.test.ts
new file mode 100644
index 0000000000..d16983eb08
--- /dev/null
+++ b/packages/react-doctor/tests/run-oxlint/sidecar-lint-cache.test.ts
@@ -0,0 +1,283 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import { afterAll, describe, expect, it } from "vite-plus/test";
+import type { Diagnostic } from "@react-doctor/core";
+import { buildDiagnosticIdentity, runOxlint } from "@react-doctor/core";
+import { buildTestProject, setupReactProject, writeFile } from "../regressions/_helpers.js";
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rd-sidecar-cache-e2e-"));
+
+afterAll(() => {
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+// Every scenario asserts INCREMENTAL ≡ FULL: after a mutation, a scan with
+// both caches warm must produce byte-identical diagnostics to a from-scratch
+// cache-off scan of the same tree — including the cases where a SIBLING edit
+// must flip an unchanged file's cross-file verdict (the exact staleness class
+// the dependency fingerprints exist to catch).
+const USER_CONFIG = {
+  rules: {
+    "react-doctor/no-barrel-import": "warn",
+    "react-doctor/no-mutating-reducer-state": "warn",
+  },
+} as const;
+
+const APP_SOURCE = `import { Button } from "./components";
+export const App = () => <div><Button /></div>;
+`;
+const STORE_SOURCE = `import { useReducer } from "react";
+import { listReducer } from "./listReducer";
+export const useStore = () => useReducer(listReducer, { count: 0 });
+`;
+const MUTATING_REDUCER = `export const listReducer = (state, action) => {
+  state.count += 1;
+  return state;
+};
+`;
+const PURE_REDUCER = `export const listReducer = (state, action) => ({ count: state.count + 1 });
+`;
+
+interface ScanOptions {
+  perFileLintCacheEnabled?: boolean;
+  sidecarLintCacheEnabled?: boolean;
+  onSidecarStats?: (replayedFileCount: number, consideredFileCount: number) => void;
+  onFileProgress?: (scannedFileCount: number, totalFileCount: number) => void;
+}
+
+const setupFixture = (caseId: string): string => {
+  const projectDir = setupReactProject(tempRoot, caseId, {
+    files: {
+      "src/components/Button.tsx": "export const Button = () => null;\n",
+      "src/components/index.ts": "export { Button } from './Button';\n",
+      "src/App.tsx": APP_SOURCE,
+      "src/listReducer.ts": MUTATING_REDUCER,
+      "src/Store.tsx": STORE_SOURCE,
+      "src/clean.tsx": "export const Clean = () => <div>ok</div>;\n",
+    },
+  });
+  // A `node_modules` directory makes the cache land inside the fixture
+  // (cleaned up with `tempRoot`) instead of the OS temp dir.
+  fs.mkdirSync(path.join(projectDir, "node_modules"), { recursive: true });
+  return projectDir;
+};
+
+const scan = (projectDir: string, options: ScanOptions = {}): Promise<Diagnostic[]> =>
+  runOxlint({
+    rootDirectory: projectDir,
+    project: buildTestProject({ rootDirectory: projectDir, framework: "vite" }),
+    userConfig: USER_CONFIG,
+    perFileLintCacheEnabled: options.perFileLintCacheEnabled ?? true,
+    sidecarLintCacheEnabled: options.sidecarLintCacheEnabled ?? true,
+    onSidecarStats: options.onSidecarStats,
+    onFileProgress: options.onFileProgress,
+  });
+
+const scanFull = (projectDir: string): Promise<Diagnostic[]> =>
+  scan(projectDir, { perFileLintCacheEnabled: false, sidecarLintCacheEnabled: false });
+
+const serialize = (diagnostics: ReadonlyArray<Diagnostic>): string =>
+  JSON.stringify(
+    [...diagnostics]
+      .map((diagnostic) => ({ ...diagnostic }))
+      .sort((first, second) =>
+        buildDiagnosticIdentity(first).localeCompare(buildDiagnosticIdentity(second)),
+      ),
+  );
+
+const ruleHitsOn = (
+  diagnostics: ReadonlyArray<Diagnostic>,
+  rule: string,
+  filePath: string,
+): ReadonlyArray<Diagnostic> =>
+  diagnostics.filter((diagnostic) => diagnostic.rule === rule && diagnostic.filePath === filePath);
+
+describe("sidecar lint cache", () => {
+  it("reports file progress through to the full total when the sidecar replays files", async () => {
+    const projectDir = setupFixture("progress-completes");
+    await scan(projectDir);
+    const progressReports: Array<readonly [number, number]> = [];
+    await scan(projectDir, {
+      onFileProgress: (scannedFileCount, totalFileCount) => {
+        progressReports.push([scannedFileCount, totalFileCount]);
+      },
+    });
+
+    const lastReport = progressReports.at(-1);
+    expect(lastReport).toBeDefined();
+    expect(lastReport?.[0]).toBe(lastReport?.[1]);
+  });
+
+  it("replays a fully unchanged tree and stays byte-identical to a full scan", async () => {
+    const projectDir = setupFixture("unchanged-replay");
+    const full = await scanFull(projectDir);
+    const cold = await scan(projectDir);
+    let replayed: number | null = null;
+    let considered: number | null = null;
+    const warm = await scan(projectDir, {
+      onSidecarStats: (replayedFileCount, consideredFileCount) => {
+        replayed = replayedFileCount;
+        considered = consideredFileCount;
+      },
+    });
+
+    expect(serialize(cold)).toBe(serialize(full));
+    expect(serialize(warm)).toBe(serialize(full));
+    // Sanity: both cross-file rules actually fired.
+    expect(full.some((diagnostic) => diagnostic.rule === "no-barrel-import")).toBe(true);
+    expect(full.some((diagnostic) => diagnostic.rule === "no-mutating-reducer-state")).toBe(true);
+    // Every cache-hit file replayed its sidecar diagnostics — no oxlint
+    // sidecar pass ran at all on the warm scan.
+    expect(considered).toBeGreaterThan(0);
+    expect(replayed).toBe(considered);
+  });
+
+  it("flips an unchanged importer's verdict when the barrel stops being a barrel", async () => {
+    const projectDir = setupFixture("barrel-flip");
+    const before = await scan(projectDir);
+    await scan(projectDir); // warm: App.tsx now replays from the sidecar store
+    expect(ruleHitsOn(before, "no-barrel-import", "src/App.tsx")).toHaveLength(1);
+
+    // Change ONLY the dependency: the index stops re-exporting (not a barrel).
+    // App.tsx is byte-for-byte unchanged, so without the dependency probes it
+    // would replay the stale "barrel" verdict.
+    writeFile(
+      path.join(projectDir, "src/components/index.ts"),
+      "export const Button = () => null;\n",
+    );
+    const incremental = await scan(projectDir);
+    const full = await scanFull(projectDir);
+
+    expect(serialize(incremental)).toBe(serialize(full));
+    expect(ruleHitsOn(incremental, "no-barrel-import", "src/App.tsx")).toHaveLength(0);
+  });
+
+  it("re-points the suggestion when the barrel's re-export target moves", async () => {
+    const projectDir = setupFixture("barrel-retarget");
+    await scan(projectDir);
+    const warmBefore = await scan(projectDir);
+    const suggestionBefore = ruleHitsOn(warmBefore, "no-barrel-import", "src/App.tsx")[0]?.message;
+    expect(suggestionBefore).toContain("./components/Button");
+
+    // The barrel now re-exports Button from a DIFFERENT file. App.tsx is
+    // unchanged, but its diagnostic's direct-import suggestion must follow.
+    writeFile(
+      path.join(projectDir, "src/components/ButtonAlt.tsx"),
+      "export const Button = () => null;\n",
+    );
+    writeFile(
+      path.join(projectDir, "src/components/index.ts"),
+      "export { Button } from './ButtonAlt';\n",
+    );
+    const incremental = await scan(projectDir);
+    const full = await scanFull(projectDir);
+
+    expect(serialize(incremental)).toBe(serialize(full));
+    expect(ruleHitsOn(incremental, "no-barrel-import", "src/App.tsx")[0]?.message).toContain(
+      "./components/ButtonAlt",
+    );
+  });
+
+  it("re-resolves when a new file SHADOWS the barrel directory (negative probes)", async () => {
+    const projectDir = setupFixture("resolution-shadowing");
+    await scan(projectDir);
+    const warmBefore = await scan(projectDir);
+    expect(ruleHitsOn(warmBefore, "no-barrel-import", "src/App.tsx")).toHaveLength(1);
+
+    // `./components` now resolves to this NEW file (extension candidates win
+    // over the directory index). Nothing App.tsx read before changed — only a
+    // previously-ABSENT resolution candidate appeared.
+    writeFile(path.join(projectDir, "src/components.tsx"), "export const Button = () => null;\n");
+    const incremental = await scan(projectDir);
+    const full = await scanFull(projectDir);
+
+    expect(serialize(incremental)).toBe(serialize(full));
+    expect(ruleHitsOn(incremental, "no-barrel-import", "src/App.tsx")).toHaveLength(0);
+  });
+
+  it("flips an unchanged consumer's verdict when its imported reducer is fixed", async () => {
+    const projectDir = setupFixture("reducer-fix");
+    const before = await scan(projectDir);
+    await scan(projectDir);
+    expect(ruleHitsOn(before, "no-mutating-reducer-state", "src/Store.tsx")).toHaveLength(1);
+
+    // Fix the mutation in the OTHER file; Store.tsx is unchanged.
+    writeFile(path.join(projectDir, "src/listReducer.ts"), PURE_REDUCER);
+    const incremental = await scan(projectDir);
+    const full = await scanFull(projectDir);
+
+    expect(serialize(incremental)).toBe(serialize(full));
+    expect(ruleHitsOn(incremental, "no-mutating-reducer-state", "src/Store.tsx")).toHaveLength(0);
+  });
+
+  it("keeps replaying unaffected files when an unrelated file changes", async () => {
+    const projectDir = setupFixture("unrelated-edit");
+    await scan(projectDir);
+    writeFile(
+      path.join(projectDir, "src/clean.tsx"),
+      "export const Clean = () => <div>still ok</div>;\n",
+    );
+    let replayed: number | null = null;
+    let considered: number | null = null;
+    const incremental = await scan(projectDir, {
+      onSidecarStats: (replayedFileCount, consideredFileCount) => {
+        replayed = replayedFileCount;
+        considered = consideredFileCount;
+      },
+    });
+    const full = await scanFull(projectDir);
+
+    expect(serialize(incremental)).toBe(serialize(full));
+    // The edited file is a per-file-cache MISS (not a sidecar candidate);
+    // every remaining hit is a dependency-clean replay.
+    expect(replayed).toBe(considered);
+    expect(considered).toBeGreaterThan(0);
+  });
+
+  it("re-lints everything (correctly) when the sidecar store is corrupt", async () => {
+    const projectDir = setupFixture("corrupt-store");
+    await scan(projectDir);
+    const storePath = path.join(
+      projectDir,
+      "node_modules",
+      ".cache",
+      "react-doctor",
+      "sidecar-lint-cache.json",
+    );
+    expect(fs.existsSync(storePath)).toBe(true);
+    fs.writeFileSync(storePath, "{ not json !!");
+
+    let replayed: number | null = null;
+    const incremental = await scan(projectDir, {
+      onSidecarStats: (replayedFileCount) => {
+        replayed = replayedFileCount;
+      },
+    });
+    const full = await scanFull(projectDir);
+
+    expect(serialize(incremental)).toBe(serialize(full));
+    expect(replayed).toBe(0);
+  });
+
+  it("never consults the sidecar store when disabled (rollback hatch)", async () => {
+    const projectDir = setupFixture("sidecar-disabled");
+    let sidecarStatsCalled = false;
+    await scan(projectDir, { sidecarLintCacheEnabled: false });
+    const warm = await scan(projectDir, {
+      sidecarLintCacheEnabled: false,
+      onSidecarStats: () => {
+        sidecarStatsCalled = true;
+      },
+    });
+    const full = await scanFull(projectDir);
+
+    expect(sidecarStatsCalled).toBe(false);
+    expect(serialize(warm)).toBe(serialize(full));
+    expect(
+      fs.existsSync(
+        path.join(projectDir, "node_modules", ".cache", "react-doctor", "sidecar-lint-cache.json"),
+      ),
+    ).toBe(false);
+  });
+});

From bdf80748eb0d186456b30aee30dbe731c06293b3 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 00:22:47 -0500
Subject: [PATCH 22/33] feat(telemetry): classify every scan's cache
 temperature in the wide event (#1059)

cache.temperature (turbo from an explicit whole-repo-hit flag, warm on any
incremental reuse, cold, disabled) plus cache.warmth (mean of subsystem
reuse ratios) make cold vs incremental vs full-replay runs queryable in
Sentry alongside the per-subsystem drill-down dims.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/telemetry-cache-temperature.md     |   5 +
 .../src/cli/utils/build-run-event.ts          |  95 ++++++++++++--
 .../src/cli/utils/scan-result-cache.ts        |  13 +-
 packages/react-doctor/src/inspect.ts          |  11 ++
 .../tests/build-run-event.test.ts             | 122 ++++++++++++++++++
 5 files changed, 235 insertions(+), 11 deletions(-)
 create mode 100644 .changeset/telemetry-cache-temperature.md

diff --git a/.changeset/telemetry-cache-temperature.md b/.changeset/telemetry-cache-temperature.md
new file mode 100644
index 0000000000..de22f34714
--- /dev/null
+++ b/.changeset/telemetry-cache-temperature.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": patch
+---
+
+Added cache-temperature telemetry to the per-scan Sentry wide event, so cache effectiveness is queryable at a glance instead of being inferred from per-subsystem dims. `cache.temperature` classifies every scan as `turbo` (whole-repo scan-result replay — now marked by an explicit `wholeRepoCacheHit` flag on the replay path, never inferred from absent dims), `warm` (any incremental reuse across the per-file lint, sidecar, or dead-code caches), `cold` (caches on, zero reuse), or `disabled` (the global `REACT_DOCTOR_NO_CACHE` off-switch). `cache.warmth` is the numeric headline magnitude in [0, 1] — the plain mean of the known subsystem reuse fractions, skipping subsystems that never consulted a cache. The existing per-subsystem dims (`lint.cacheHitRatio`, `lint.sidecarReplayRatio`, `deadCode.cacheHit`, `deadCode.summaryCacheHits/Misses`) are unchanged. Telemetry-only: no new counters, no JSON-report or cache-schema changes.
diff --git a/packages/react-doctor/src/cli/utils/build-run-event.ts b/packages/react-doctor/src/cli/utils/build-run-event.ts
index 00ea8d5ddc..26a55d2de7 100644
--- a/packages/react-doctor/src/cli/utils/build-run-event.ts
+++ b/packages/react-doctor/src/cli/utils/build-run-event.ts
@@ -14,6 +14,7 @@ import { buildRuleBlastRadii } from "./diagnostic-grouping.js";
 import { ACTION_INPUT_ENVIRONMENT_VARIABLES, detectRunnerOs } from "./is-ci-environment.js";
 import { summarizeRuleFirings } from "./record-scan-metrics.js";
 import { isValidBlockingLevel } from "./resolve-blocking-level.js";
+import { isCacheGloballyDisabled } from "./scan-result-cache.js";
 import { shouldBlockCi } from "./should-block-ci.js";
 import { toCategoryKey } from "./to-category-key.js";
 import { toSpanAttributes } from "./to-span-attributes.js";
@@ -101,6 +102,14 @@ export interface RunEventInput {
    * (100+ rules would blow up the attribute set). Omitted on the failure path.
    */
   readonly suppressedRuleCounts?: ReadonlyArray<SuppressedRuleCount>;
+  /**
+   * `true` only when this run replayed a whole-repo scan-result payload (the
+   * "turbo" path, where no lint / dead-code / score work ran). The explicit
+   * marker for `cache.temperature = "turbo"` — never inferred from the
+   * per-subsystem cache dims being null, which is also what a cache-off run
+   * looks like. Omitted on the failure path.
+   */
+  readonly wholeRepoCacheHit?: boolean;
   /** Present only when the scan threw. */
   readonly error?: unknown;
 }
@@ -111,6 +120,76 @@ const readEnvBoolean = (name: string): boolean | null => {
   return value.toLowerCase() === "true" || value === "1";
 };
 
+// Reuse fraction of one cache subsystem; `null` (an absent signal, not 0%)
+// when the subsystem never consulted its cache this run.
+const ratioOf = (
+  numerator: number | null | undefined,
+  denominator: number | null | undefined,
+): number | null =>
+  denominator != null && denominator > 0 ? (numerator ?? 0) / denominator : null;
+
+// The dead-code pass's reuse fraction: a whole-result replay is total reuse;
+// a fresh analysis reuses whatever fraction of its file summaries the
+// incremental store served; a consulted-but-missed result cache with no
+// summary stats is zero reuse. `null` when the pass never consulted a cache.
+const resolveDeadCodeReuseRatio = (result: InspectResult): number | null => {
+  if (result.deadCodeCacheHit === true) return 1;
+  const summaryTotal =
+    (result.deadCodeSummaryCacheHits ?? 0) + (result.deadCodeSummaryCacheMisses ?? 0);
+  if (summaryTotal > 0) return (result.deadCodeSummaryCacheHits ?? 0) / summaryTotal;
+  return result.deadCodeCacheHit === false ? 0 : null;
+};
+
+/**
+ * One queryable cache temperature per scan, derived from the whole stack:
+ *
+ *   - `"turbo"`    — whole-repo scan-result replay (the explicit
+ *                    `wholeRepoCacheHit` flag from the CLI's cachedPayload
+ *                    branch; no scan work ran).
+ *   - `"warm"`     — any incremental reuse: per-file lint hits, sidecar
+ *                    replays, a dead-code whole-result hit, or dead-code
+ *                    summary-cache hits.
+ *   - `"disabled"` — zero reuse because the global `REACT_DOCTOR_NO_CACHE`
+ *                    off-switch is on. Granular per-cache opt-outs
+ *                    (`REACT_DOCTOR_NO_FILE_CACHE`, …) still read warm/cold,
+ *                    since the other subsystems stay live.
+ *   - `"cold"`     — caches on, zero reuse (first scan / everything changed).
+ *
+ * `cache.warmth` is the headline reuse magnitude in [0, 1]: the plain mean of
+ * the subsystem reuse fractions known this run (lint hit ratio, sidecar
+ * replay ratio, dead-code reuse), skipping subsystems that never consulted a
+ * cache; `1` on turbo, dropped when nothing consulted any cache. Deliberately
+ * unweighted — the per-subsystem dims stay the precise signal; warmth is the
+ * p50/p90-able summary. Emitted only on the success path.
+ */
+const buildCacheAttributes = (input: RunEventInput): RunEventAttributes => {
+  if (input.result === undefined) return {};
+  if (input.wholeRepoCacheHit) {
+    return withNamespace("cache", { wholeRepoHit: true, temperature: "turbo", warmth: 1 });
+  }
+  const result = input.result;
+  const subsystemReuseRatios = [
+    ratioOf(result.lintCacheHitFileCount, result.lintCacheTotalFileCount),
+    ratioOf(result.lintSidecarReplayedFileCount, result.lintSidecarTotalFileCount),
+    resolveDeadCodeReuseRatio(result),
+  ];
+  let knownSubsystemCount = 0;
+  let reuseRatioSum = 0;
+  for (const reuseRatio of subsystemReuseRatios) {
+    if (reuseRatio === null) continue;
+    knownSubsystemCount += 1;
+    reuseRatioSum += reuseRatio;
+  }
+  const warmth = knownSubsystemCount > 0 ? reuseRatioSum / knownSubsystemCount : null;
+  const temperature =
+    warmth !== null && warmth > 0 ? "warm" : isCacheGloballyDisabled() ? "disabled" : "cold";
+  return withNamespace("cache", {
+    wholeRepoHit: input.wholeRepoCacheHit ?? null,
+    temperature,
+    warmth,
+  });
+};
+
 // How the official action's `version` input was pinned, derived from the
 // forwarded value: `latest`, a local path spec, or an explicit version.
 const resolveVersionPin = (versionInput: string | undefined): string | null => {
@@ -276,18 +355,15 @@ const buildOutcomeAttributes = (input: RunEventInput): RunEventAttributes => {
       // from a 0% hit rate (`toSpanAttributes` drops the nulls).
       cacheHitFiles: result.lintCacheHitFileCount ?? null,
       cacheTotalFiles: result.lintCacheTotalFileCount ?? null,
-      cacheHitRatio:
-        result.lintCacheTotalFileCount != null && result.lintCacheTotalFileCount > 0
-          ? (result.lintCacheHitFileCount ?? 0) / result.lintCacheTotalFileCount
-          : null,
+      cacheHitRatio: ratioOf(result.lintCacheHitFileCount, result.lintCacheTotalFileCount),
       // Sidecar lint cache outcome — same shape as the per-file cache dims;
       // all `null` when the sidecar cache was off/bypassed.
       sidecarReplayedFiles: result.lintSidecarReplayedFileCount ?? null,
       sidecarTotalFiles: result.lintSidecarTotalFileCount ?? null,
-      sidecarReplayRatio:
-        result.lintSidecarTotalFileCount != null && result.lintSidecarTotalFileCount > 0
-          ? (result.lintSidecarReplayedFileCount ?? 0) / result.lintSidecarTotalFileCount
-          : null,
+      sidecarReplayRatio: ratioOf(
+        result.lintSidecarReplayedFileCount,
+        result.lintSidecarTotalFileCount,
+      ),
     }),
     ...withNamespace("deadCode", {
       failed: input.didDeadCodeFail ?? null,
@@ -386,7 +462,7 @@ const buildScanAttributes = (input: RunEventInput): RunEventAttributes => {
  * Projects a scan into the namespaced attribute set for its root span — the
  * canonical per-scan "wide event". Every attribute carries a dotted namespace
  * that groups it by concept (`scan.*` config, `action.*` CI knobs, `outcome.*`
- * verdict, `diag.*` findings, `score.*`, `lint.*`, `deadCode.*`,
+ * verdict, `diag.*` findings, `score.*`, `lint.*`, `deadCode.*`, `cache.*`,
  * `supplyChain.*`, `timing.*`, `migration.*`, `baseline.*`) so the attributes
  * tree up in Sentry's attribute browser and stay filter-/group-/aggregate-able
  * in the Spans dataset. Pure and exported so the projection (outcome
@@ -404,6 +480,7 @@ export const buildRunEventAttributes = (
     ...buildScanAttributes(input),
     ...buildActionAttributes(),
     ...buildOutcomeAttributes(input),
+    ...buildCacheAttributes(input),
   });
 
 /**
diff --git a/packages/react-doctor/src/cli/utils/scan-result-cache.ts b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
index 4d416d8799..9d03f83162 100644
--- a/packages/react-doctor/src/cli/utils/scan-result-cache.ts
+++ b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
@@ -330,7 +330,16 @@ const writePersistedCache = (cacheFilePath: string, cache: PersistedScanResultCa
   }
 };
 
-const isScanResultCacheDisabled = (): boolean =>
+/**
+ * The global cache off-switch (`REACT_DOCTOR_NO_CACHE`), which disables every
+ * cache subsystem: this whole-repo scan cache plus core's per-file lint,
+ * sidecar, and dead-code caches (their `Context.Reference` defaults read the
+ * same variable). Exported for the wide event's `cache.temperature`
+ * derivation, which reports `"disabled"` instead of `"cold"` when the switch
+ * is on. Granular knobs (`REACT_DOCTOR_NO_FILE_CACHE`, …) are deliberately
+ * not consulted — they leave the other subsystems live.
+ */
+export const isCacheGloballyDisabled = (): boolean =>
   CACHE_DISABLED_VALUES.has(process.env.REACT_DOCTOR_NO_CACHE?.toLowerCase() ?? "");
 
 const resolveProjectIdentity = (projectDirectory: string): string => {
@@ -369,7 +378,7 @@ const resolveToolchainFingerprint = (nodeBinaryPath: string | null): ReadonlyArr
 };
 
 export const buildScanResultCacheKey = (input: ScanResultCacheKeyInput): string | null => {
-  if (isScanResultCacheDisabled()) return null;
+  if (isCacheGloballyDisabled()) return null;
   // Assume-unchanged / skip-worktree hide tracked-file state from `git
   // status`, so no fingerprint built from it can see those changes.
   if (hasHiddenTrackedFileState(input.projectDirectory)) return null;
diff --git a/packages/react-doctor/src/inspect.ts b/packages/react-doctor/src/inspect.ts
index 962edc43bd..7e79125f19 100644
--- a/packages/react-doctor/src/inspect.ts
+++ b/packages/react-doctor/src/inspect.ts
@@ -570,6 +570,7 @@ const runInspectWithRuntime = async (
       rootSentrySpan,
       scanMode: cachedPayload.baselineDelta ? "baseline" : isDiffMode ? "diff" : "full",
       baselineDegraded,
+      wholeRepoCacheHit: true,
     });
     recordOnboardingCompletion(options);
     return result;
@@ -790,6 +791,7 @@ const runInspectWithRuntime = async (
     rootSentrySpan,
     scanMode: baselineDelta ? "baseline" : isDiffMode ? "diff" : "full",
     baselineDegraded,
+    wholeRepoCacheHit: false,
     lintCacheHitFileCount: output.lintCacheHitFileCount,
     lintCacheTotalFileCount: output.lintCacheTotalFileCount,
     lintSidecarReplayedFileCount: output.lintSidecarReplayedFileCount,
@@ -844,6 +846,14 @@ interface RenderAndRecordScanInput {
   readonly rootSentrySpan: SentryRootSpan;
   readonly scanMode: "full" | "diff" | "baseline";
   readonly baselineDegraded: boolean;
+  /**
+   * `true` only on the whole-repo scan-result replay path (the exact-key
+   * `cachedPayload` branch, where no lint / dead-code / score work ran).
+   * Required so both call sites state it explicitly — the wide event's
+   * `cache.temperature = "turbo"` derives from this flag, never from the
+   * execution dims below happening to be null.
+   */
+  readonly wholeRepoCacheHit: boolean;
   /**
    * Per-file lint cache outcome for THIS scan's lint pass. Threaded outside
    * `CachedScanPayload` on purpose — it's telemetry about the lint that ran in
@@ -960,6 +970,7 @@ const renderAndRecordScan = async (input: RenderAndRecordScanInput): Promise<Ins
     result,
     mode: input.scanMode,
     gateExempt: input.baselineDegraded,
+    wholeRepoCacheHit: input.wholeRepoCacheHit,
     didLintFail: input.payload.didLintFail,
     lintFailureReasonKind: input.payload.lintFailureReasonKind,
     lintPartialFailureCount: input.payload.lintPartialFailures.length,
diff --git a/packages/react-doctor/tests/build-run-event.test.ts b/packages/react-doctor/tests/build-run-event.test.ts
index 067da7f1c8..60331038d4 100644
--- a/packages/react-doctor/tests/build-run-event.test.ts
+++ b/packages/react-doctor/tests/build-run-event.test.ts
@@ -12,6 +12,7 @@ const ENV_VARS = [
   "GITHUB_EVENT_PATH",
   "RUNNER_OS",
   "REACT_DOCTOR_GITHUB_ACTION",
+  "REACT_DOCTOR_NO_CACHE",
   ...Object.values(ACTION_INPUT_ENVIRONMENT_VARIABLES),
 ] as const;
 
@@ -395,6 +396,127 @@ describe("buildRunEventAttributes", () => {
     expect(withoutTallies["diag.suppressed"]).toBeUndefined();
   });
 
+  it("marks a whole-repo replay turbo with full warmth and no subsystem dims", () => {
+    // The cachedPayload branch passes the explicit flag and none of the
+    // execution dims (no lint / dead-code ran), so the subsystem dims stay
+    // absent while the temperature is still unambiguous.
+    const attributes = buildRunEventAttributes(
+      baseInput({ result: buildResult(), wholeRepoCacheHit: true }),
+    );
+    expect(attributes["cache.temperature"]).toBe("turbo");
+    expect(attributes["cache.warmth"]).toBe(1);
+    expect(attributes["cache.wholeRepoHit"]).toBe(true);
+    expect(attributes["lint.cacheHitRatio"]).toBeUndefined();
+    expect(attributes["lint.sidecarReplayRatio"]).toBeUndefined();
+    expect(attributes["deadCode.cacheHit"]).toBeUndefined();
+    expect(attributes["deadCode.summaryCacheHits"]).toBeUndefined();
+  });
+
+  it("marks a fresh scan with zero reuse cold, with warmth 0", () => {
+    const attributes = buildRunEventAttributes(
+      baseInput({
+        result: buildResult({ lintCacheHitFileCount: 0, lintCacheTotalFileCount: 40 }),
+        wholeRepoCacheHit: false,
+      }),
+    );
+    expect(attributes["cache.temperature"]).toBe("cold");
+    expect(attributes["cache.warmth"]).toBe(0);
+    expect(attributes["cache.wholeRepoHit"]).toBe(false);
+    expect(attributes["lint.cacheHitRatio"]).toBe(0);
+  });
+
+  it("marks a REACT_DOCTOR_NO_CACHE run disabled, not cold, and drops warmth", () => {
+    process.env.REACT_DOCTOR_NO_CACHE = "1";
+    const attributes = buildRunEventAttributes(
+      baseInput({ result: buildResult(), wholeRepoCacheHit: false }),
+    );
+    expect(attributes["cache.temperature"]).toBe("disabled");
+    expect(attributes["cache.warmth"]).toBeUndefined();
+
+    process.env.REACT_DOCTOR_NO_CACHE = "true";
+    expect(
+      buildRunEventAttributes(baseInput({ result: buildResult(), wholeRepoCacheHit: false }))[
+        "cache.temperature"
+      ],
+    ).toBe("disabled");
+  });
+
+  it("marks a run warm when any single subsystem reused work", () => {
+    const warmScenarios: Array<{ overrides: Partial<InspectResult>; expectedWarmth: number }> = [
+      {
+        overrides: { lintCacheHitFileCount: 30, lintCacheTotalFileCount: 100 },
+        expectedWarmth: 0.3,
+      },
+      {
+        overrides: { lintSidecarReplayedFileCount: 5, lintSidecarTotalFileCount: 10 },
+        expectedWarmth: 0.5,
+      },
+      { overrides: { deadCodeCacheHit: true }, expectedWarmth: 1 },
+      {
+        overrides: { deadCodeSummaryCacheHits: 8, deadCodeSummaryCacheMisses: 2 },
+        expectedWarmth: 0.8,
+      },
+    ];
+    for (const { overrides, expectedWarmth } of warmScenarios) {
+      const attributes = buildRunEventAttributes(
+        baseInput({ result: buildResult(overrides), wholeRepoCacheHit: false }),
+      );
+      expect(attributes["cache.temperature"]).toBe("warm");
+      expect(attributes["cache.warmth"]).toBeCloseTo(expectedWarmth, 10);
+    }
+  });
+
+  it("computes warmth as the mean of the known subsystem ratios, skipping absent ones", () => {
+    // Sidecar dims absent -> skipped, not counted as 0: (0.5 + 0.8) / 2.
+    const attributes = buildRunEventAttributes(
+      baseInput({
+        result: buildResult({
+          lintCacheHitFileCount: 50,
+          lintCacheTotalFileCount: 100,
+          deadCodeSummaryCacheHits: 8,
+          deadCodeSummaryCacheMisses: 2,
+        }),
+        wholeRepoCacheHit: false,
+      }),
+    );
+    expect(attributes["cache.temperature"]).toBe("warm");
+    expect(attributes["cache.warmth"]).toBeCloseTo(0.65, 10);
+  });
+
+  it("counts a consulted-but-missed dead-code result cache as zero reuse", () => {
+    // deadCodeCacheHit false with no summary stats means the analysis ran
+    // fully fresh: (1.0 + 0) / 2, still warm because lint reused everything.
+    const attributes = buildRunEventAttributes(
+      baseInput({
+        result: buildResult({
+          lintCacheHitFileCount: 100,
+          lintCacheTotalFileCount: 100,
+          deadCodeCacheHit: false,
+        }),
+        wholeRepoCacheHit: false,
+      }),
+    );
+    expect(attributes["cache.temperature"]).toBe("warm");
+    expect(attributes["cache.warmth"]).toBeCloseTo(0.5, 10);
+  });
+
+  it("reads the legacy no-dims shape as cold and drops warmth and the flag", () => {
+    // No wholeRepoCacheHit flag and no subsystem dims (a caller predating the
+    // fields): nothing was reused, so the temperature still reads cold, while
+    // the magnitude and the flag stay absent rather than asserted.
+    const attributes = buildRunEventAttributes(baseInput({ result: buildResult() }));
+    expect(attributes["cache.temperature"]).toBe("cold");
+    expect(attributes["cache.warmth"]).toBeUndefined();
+    expect(attributes["cache.wholeRepoHit"]).toBeUndefined();
+  });
+
+  it("emits no cache dims on the failure path", () => {
+    const attributes = buildRunEventAttributes(baseInput({ error: new Error("boom") }));
+    expect(attributes["cache.temperature"]).toBeUndefined();
+    expect(attributes["cache.warmth"]).toBeUndefined();
+    expect(attributes["cache.wholeRepoHit"]).toBeUndefined();
+  });
+
   it("captures config shape and drops null/undefined-valued attributes", () => {
     const attributes = buildRunEventAttributes(
       baseInput({

From ced746f518f11e8283d488c4ff31c44e478bb0e5 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 00:34:01 -0500
Subject: [PATCH 23/33] fix(core): make the cache stack survive CI checkouts
 and the action cache (#1060)

The whole-repo scan cache escaped the action's cached path entirely (own
tmpdir resolution) and three key inputs (config/dotenv/toolchain stats)
rotated on every fresh checkout; the dead-code caches were stat-keyed so
re-cloned trees never hit. Route every cache through the shared cache-dir
resolution, content-hash the checkout-sensitive key inputs, add ninja-style
mtime repair to both dead-code caches, TTL-prune the supply-chain store,
and stop the PR baseline sub-scan from minting orphan cache dirs.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/perf-ci-action-cache.md            |   6 +
 action.yml                                    |  43 ++--
 packages/core/src/check-dead-code.ts          |  51 +++--
 packages/core/src/check-supply-chain.ts       |  25 +++
 packages/core/src/constants.ts                |   5 +-
 .../src/dead-code/dead-code-result-cache.ts   | 166 ++++++++++++----
 packages/core/src/index.ts                    |   1 +
 .../src/utils/compute-config-fingerprint.ts   |  16 +-
 .../tests/check-supply-chain-cache.test.ts    |  18 ++
 .../core/tests/dead-code-result-cache.test.ts | 186 ++++++++++++------
 packages/deslop-js/src/constants.ts           |   3 +-
 packages/deslop-js/src/summary-cache.ts       | 108 ++++++++--
 .../deslop-js/tests/summary-cache.test.ts     |  62 ++++++
 .../react-doctor/src/cli/utils/constants.ts   |   5 +-
 .../src/cli/utils/scan-result-cache.ts        |  54 +++--
 packages/react-doctor/src/inspect.ts          |   8 +
 .../tests/scan-result-cache.test.ts           |  44 +++++
 17 files changed, 616 insertions(+), 185 deletions(-)
 create mode 100644 .changeset/perf-ci-action-cache.md

diff --git a/.changeset/perf-ci-action-cache.md b/.changeset/perf-ci-action-cache.md
new file mode 100644
index 0000000000..48b7f11b3b
--- /dev/null
+++ b/.changeset/perf-ci-action-cache.md
@@ -0,0 +1,6 @@
+---
+"deslop-js": patch
+"react-doctor": patch
+---
+
+The whole cache stack now survives CI's fresh checkouts, so the GitHub Action's persisted `REACT_DOCTOR_CACHE_DIR` actually warms every layer instead of only the content-addressed ones. The whole-repo scan-result cache moves under the shared per-project cache root (honoring `REACT_DOCTOR_CACHE_DIR` like the lint, sidecar, dead-code, and supply-chain caches — previously it silently escaped the action's cache into `node_modules/.cache` or the OS temp dir), and its key drops every stat-based fingerprint that a re-clone rotates: config files and gitignored dotenv files are now content-hashed, and the toolchain is keyed by package versions (matching the lint ruleset hash) rather than install mtimes. The stat-fingerprinted dead-code caches gain mtime repair (the ninja/restat pattern): entries carry a content-hash witness, and a stat mismatch over identical bytes — every file after a fresh checkout — re-hashes once, accepts the entry, and persists the refreshed stat so the cost is paid once per checkout, not per run. This covers core's whole-project dead-code result cache (per-file `(mtime, size, hash)` records replacing the stats-in-key fingerprint) and deslop-js's incremental summary store (parse summaries, package-reference facts, and the manifest/bundler-config fingerprints feeding the collect/resolution hashes). Expired supply-chain score entries are also pruned past their TTL so restored cache directories stop accumulating dead purls. Everything stays fail-open and byte-identical to an uncached scan; on a re-cloned repo with one changed file, a warm scan now replays ~100% of lint, sidecar, and parse work instead of starting cold.
diff --git a/action.yml b/action.yml
index a2e4562244..055a0939c9 100644
--- a/action.yml
+++ b/action.yml
@@ -85,25 +85,30 @@ runs:
         path: ${{ runner.temp }}/react-doctor-toolchain
         key: react-doctor-toolchain-${{ steps.resolve-version.outputs.resolved }}-node${{ inputs.node-version }}-${{ runner.os }}-${{ runner.arch }}
 
-    # Restore react-doctor's scan caches (the per-file content-addressed lint
-    # cache + the supply-chain cache) from the most recent previous run. In CI
-    # every commit is a fresh, SHA-scoped checkout, so the project-local
-    # `node_modules/.cache` never survives between commits — pointing
-    # REACT_DOCTOR_CACHE_DIR (set on the scan step) at a stable
-    # `${runner.temp}` path lets actions/cache carry it across runs. Restore +
-    # explicit save (after the scan) instead of the combined action: the
-    # combined post-job save is skipped when the job fails, and a blocking PR
-    # scan with findings fails the job BY DESIGN — exactly the runs whose
-    # fix-and-push retry needs a warm cache. The key is unique per run (an
-    # exact hit would suppress the save), so every run persists its refreshed
-    # state instead of freezing the first snapshot under an immutable key;
-    # restore falls back by prefix to the newest same-version save, then to
-    # ANY version. Cross-version restore is sound because every cached
-    # artifact re-validates internally (content hash + ruleset hash for lint
-    # entries — the bucket is LRU-pruned — schema version for scan results,
-    # TTL for supply-chain scores): a stale entry just misses and re-computes,
-    # while the version-independent supply-chain cache keeps a react-doctor
-    # release from cold-starting every repo's network checks at once.
+    # Restore react-doctor's scan caches (the whole-repo scan-result cache,
+    # the per-file content-addressed lint cache, the cross-file sidecar cache,
+    # the dead-code result + incremental summary caches, and the supply-chain
+    # cache) from the most recent previous run. In CI every commit is a fresh,
+    # SHA-scoped checkout, so the project-local `node_modules/.cache` never
+    # survives between commits — pointing REACT_DOCTOR_CACHE_DIR (set on the
+    # scan step) at a stable `${runner.temp}` path lets actions/cache carry it
+    # across runs. Restore + explicit save (after the scan) instead of the
+    # combined action: the combined post-job save is skipped when the job
+    # fails, and a blocking PR scan with findings fails the job BY DESIGN —
+    # exactly the runs whose fix-and-push retry needs a warm cache. The key is
+    # unique per run (an exact hit would suppress the save), so every run
+    # persists its refreshed state instead of freezing the first snapshot
+    # under an immutable key; restore falls back by prefix to the newest
+    # same-version save, then to ANY version. Cross-version restore is sound
+    # because every cached artifact re-validates internally (content hash +
+    # ruleset hash for lint entries — the bucket is LRU-pruned — schema
+    # version + per-file content hashes for scan results and the dead-code
+    # caches, TTL for supply-chain scores): a stale entry just misses and
+    # re-computes, while the version-independent supply-chain cache keeps a
+    # react-doctor release from cold-starting every repo's network checks at
+    # once. The stat-fingerprinted caches carry content-hash repair witnesses,
+    # so the fresh checkout's bumped mtimes are repaired in place instead of
+    # missing every run.
     - id: scan-cache
       if: ${{ steps.resolve-version.outputs.cacheable == 'true' }}
       uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
diff --git a/packages/core/src/check-dead-code.ts b/packages/core/src/check-dead-code.ts
index 9f643f971e..332373ee72 100644
--- a/packages/core/src/check-dead-code.ts
+++ b/packages/core/src/check-dead-code.ts
@@ -7,6 +7,7 @@ import {
   collectDeadCodeIgnorePatterns,
 } from "./dead-code/collect-dead-code-patterns.js";
 import {
+  collectAnalyzedFileStats,
   computeDeadCodeCacheKey,
   lookupDeadCodeResultCache,
   storeDeadCodeResultCache,
@@ -575,24 +576,30 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
     options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js");
 
   // Result cache: replay the last complete pass when nothing the analysis
-  // reads changed. The key snapshot is taken BEFORE the (long) analysis so a
-  // stored result is keyed by the tree it started from — an edit racing the
-  // analysis lands a stale key that the next run's fresh snapshot misses.
-  const cacheKey = options.cacheEnabled
-    ? computeDeadCodeCacheKey({
-        rootDirectory,
-        entryPatterns,
-        ignorePatterns,
-        tsConfigPath,
-        deslopJsModuleSpecifier,
-        coreVersion: CORE_PACKAGE_VERSION,
-      })
-    : null;
-  if (cacheKey !== null) {
-    const cachedDiagnostics = lookupDeadCodeResultCache(
-      resolveReactDoctorCacheDir(rootDirectory),
+  // reads changed. The stat snapshot is taken BEFORE the (long) analysis so a
+  // stored result is verified — and stored — against the tree it started
+  // from; `storeDeadCodeResultCache` re-verifies the stats at store time so
+  // an edit racing the analysis skips the store instead of landing a stale
+  // entry.
+  const fileStatsSnapshot = options.cacheEnabled ? collectAnalyzedFileStats(rootDirectory) : null;
+  const cacheKey =
+    fileStatsSnapshot === null
+      ? null
+      : computeDeadCodeCacheKey({
+          rootDirectory,
+          entryPatterns,
+          ignorePatterns,
+          tsConfigPath,
+          deslopJsModuleSpecifier,
+          coreVersion: CORE_PACKAGE_VERSION,
+        });
+  if (cacheKey !== null && fileStatsSnapshot !== null) {
+    const cachedDiagnostics = lookupDeadCodeResultCache({
+      cacheDirectory: resolveReactDoctorCacheDir(rootDirectory),
       cacheKey,
-    );
+      rootDirectory,
+      currentFileStats: fileStatsSnapshot,
+    });
     options.onCacheOutcome?.(cachedDiagnostics !== null);
     if (cachedDiagnostics !== null) return [...cachedDiagnostics];
   }
@@ -717,8 +724,14 @@ export const checkDeadCode = async (options: CheckDeadCodeOptions): Promise<Diag
   // Only a COMPLETE successful pass reaches this line — a crashed, timed-out,
   // or aborted worker rejects above — so a stored entry never replays a
   // truncated result (mirroring `shouldStoreScanPayload`).
-  if (cacheKey !== null) {
-    storeDeadCodeResultCache(resolveReactDoctorCacheDir(rootDirectory), cacheKey, diagnostics);
+  if (cacheKey !== null && fileStatsSnapshot !== null) {
+    storeDeadCodeResultCache({
+      cacheDirectory: resolveReactDoctorCacheDir(rootDirectory),
+      cacheKey,
+      rootDirectory,
+      snapshotFileStats: fileStatsSnapshot,
+      diagnostics,
+    });
   }
 
   return diagnostics;
diff --git a/packages/core/src/check-supply-chain.ts b/packages/core/src/check-supply-chain.ts
index bdea00bcad..e36efcd258 100644
--- a/packages/core/src/check-supply-chain.ts
+++ b/packages/core/src/check-supply-chain.ts
@@ -405,6 +405,30 @@ const writeCachedSocketBody = (cacheFile: string, body: string): void => {
   }
 };
 
+// Drops cache files past the TTL. A live dependency's expired entry would
+// re-fetch anyway; without this, entries for purls that stop being looked up
+// (version bumps, removed dependencies) accumulate forever — a slow monotonic
+// leak in CI, where the whole cache directory is persisted and restored across
+// runs. File mtime stands in for `fetchedAtMs` (same clock: the file is
+// written when the entry is fetched, and both local disks and the CI cache's
+// tar round-trip preserve it), so pruning stats instead of parsing every file.
+const pruneExpiredSocketCache = (cacheDirectory: string): void => {
+  try {
+    const supplyChainCacheDirectory = path.join(cacheDirectory, SUPPLY_CHAIN_CACHE_SUBDIR);
+    const expiryThresholdMs = Date.now() - SUPPLY_CHAIN_CACHE_TTL_MS;
+    for (const entryName of fs.readdirSync(supplyChainCacheDirectory)) {
+      const entryPath = path.join(supplyChainCacheDirectory, entryName);
+      try {
+        if (fs.statSync(entryPath).mtimeMs < expiryThresholdMs) fs.rmSync(entryPath);
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    // A prune failure must never sink the scan.
+  }
+};
+
 // Fetches the free, keyless Socket artifact (score + alerts) for one
 // dependency — the same `firewall-api.socket.dev/purl/<encoded-purl>` endpoint
 // Socket Firewall's free tier hits. `Effect.tryPromise` hands `fetch` an
@@ -676,6 +700,7 @@ export const checkSupplyChain = (input: SupplyChainCheckInput): Effect.Effect<Di
     const cacheDirectory = isSupplyChainCacheDisabled()
       ? null
       : resolveReactDoctorCacheDir(input.rootDirectory);
+    if (cacheDirectory !== null) pruneExpiredSocketCache(cacheDirectory);
 
     const artifacts = yield* Effect.forEach(
       dependencies,
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index dd3e6e7172..fd4c461672 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -650,7 +650,10 @@ export const CORE_PACKAGE_VERSION = process.env.REACT_DOCTOR_CORE_VERSION ?? "0.
 // Whole-project dead-code result cache (`dead-code/dead-code-result-cache.ts`).
 // Replays deslop's diagnostics — skipping the analysis worker entirely — when
 // nothing the analysis reads has changed since the stored run.
-export const DEAD_CODE_CACHE_SCHEMA_VERSION = 1;
+// Bumped to 2: entries carry a per-file `files` map (mtime, size, content
+// hash) instead of folding the file stats into the key, so a fresh checkout's
+// bumped mtimes can be repaired against unchanged content.
+export const DEAD_CODE_CACHE_SCHEMA_VERSION = 2;
 
 export const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 
diff --git a/packages/core/src/dead-code/dead-code-result-cache.ts b/packages/core/src/dead-code/dead-code-result-cache.ts
index bba528edc9..dd12c11203 100644
--- a/packages/core/src/dead-code/dead-code-result-cache.ts
+++ b/packages/core/src/dead-code/dead-code-result-cache.ts
@@ -9,28 +9,37 @@ import { DEAD_CODE_CACHE_FILENAME, DEAD_CODE_CACHE_SCHEMA_VERSION } from "../con
 import { Diagnostic as DiagnosticSchema } from "../schemas.js";
 import { atomicWriteJson } from "../utils/atomic-write-json.js";
 import { failOpenReadJson } from "../utils/fail-open-read-json.js";
+import { hashFileContents } from "../utils/hash-file-contents.js";
 import { isRecord } from "../utils/is-record.js";
 import { walkSourceTreeFiles } from "../utils/walk-source-tree-files.js";
 
 /**
  * Whole-project dead-code result cache. Dead-code reachability is a
  * whole-project property, so the cache holds ONE entry: the diagnostics of the
- * last complete, successful pass, keyed by a fingerprint over everything the
- * analysis reads. Any input change mints a new key, which makes the stored
- * entry unreachable — so there is nothing to gain from keeping history.
+ * last complete, successful pass, keyed by everything the analysis reads. Any
+ * input change makes the stored entry unreachable — so there is nothing to
+ * gain from keeping history.
  *
- * The key fingerprints files by (path, mtime, size) — the same stat-based
- * invalidation the plugin's `parse-source-file` cache uses — rather than
- * content-hashing the whole tree, because statting ~9k files costs
- * ~100-200 ms while hashing them costs seconds. The accepted tradeoff, shared
- * with that precedent: an edit that preserves BOTH a file's byte size and its
- * mtime is invisible to the fingerprint. Additions and deletions always
- * invalidate — the sorted path list itself is part of the hash.
+ * The entry records every analyzed file as (mtime, size, content hash). A
+ * lookup verifies files by stat first — ~100-200 ms to stat ~9k files versus
+ * seconds to hash them — and REPAIRS a stat mismatch by hashing the file's
+ * current content: identical content accepts the entry and refreshes the
+ * stored stat (the ninja/restat pattern), so a fresh CI checkout — where every
+ * mtime is checkout time but content is unchanged — pays the hash once per
+ * checkout, not a full re-analysis (and not once per run). Additions and
+ * deletions always invalidate — path-set equality is checked both ways. The
+ * accepted blind spot, shared with deslop's summary cache: an edit DURING the
+ * analysis that lands between store-time hash and stat re-verification.
  *
  * Every operation fails open: a missing or corrupt cache degrades to a fresh
  * analysis, never to a wrong result.
  */
 
+interface AnalyzedFileStat {
+  readonly mtimeMs: number;
+  readonly size: number;
+}
+
 interface DeadCodeCacheKeyInput {
   /** Canonicalized project root (`checkDeadCode` realpaths it first). */
   readonly rootDirectory: string;
@@ -47,9 +56,13 @@ interface DeadCodeCacheKeyInput {
   readonly coreVersion: string;
 }
 
+/** Persisted per-file identity: `[mtimeMs, size, contentHash]`. */
+type PersistedFileIdentity = readonly [number, number, string];
+
 interface PersistedDeadCodeResultCache {
   readonly version: number;
   readonly key: string;
+  readonly files: Record<string, PersistedFileIdentity>;
   readonly diagnostics: ReadonlyArray<unknown>;
 }
 
@@ -84,19 +97,26 @@ const isFingerprintedFile = (fileName: string): boolean =>
   ANALYZED_MANIFEST_NAMES.has(fileName) ||
   isTsConfigLikeFile(fileName);
 
-const collectAnalyzedFileFingerprints = (rootDirectory: string): string[] => {
-  const fingerprints: string[] = [];
+/**
+ * Stat snapshot of every file the analysis reads, keyed by root-relative
+ * `/`-separated path. Taken BEFORE the (long) analysis so a stored result is
+ * verified against the tree it started from.
+ */
+export const collectAnalyzedFileStats = (
+  rootDirectory: string,
+): ReadonlyMap<string, AnalyzedFileStat> => {
+  const statByRelativePath = new Map<string, AnalyzedFileStat>();
   for (const { absolutePath, name } of walkSourceTreeFiles(rootDirectory)) {
     if (!isFingerprintedFile(name)) continue;
     try {
       const fileStat = fs.statSync(absolutePath);
       const relativePath = path.relative(rootDirectory, absolutePath).replace(/\\/g, "/");
-      fingerprints.push(`${relativePath}:${fileStat.mtimeMs}:${fileStat.size}`);
+      statByRelativePath.set(relativePath, { mtimeMs: fileStat.mtimeMs, size: fileStat.size });
     } catch {
-      // Vanished between walk and stat — same key contribution as deleted.
+      // Vanished between walk and stat — same contribution as deleted.
     }
   }
-  return fingerprints.sort();
+  return statByRelativePath;
 };
 
 const bundledRequire = createRequire(import.meta.url);
@@ -114,6 +134,9 @@ const resolveDeslopVersion = (): string => {
   }
 };
 
+// Everything that changes what a stored entry MEANS besides the analyzed
+// files themselves, which are carried per-entry (see `files`) so they can be
+// verified — and mtime-repaired — file by file.
 export const computeDeadCodeCacheKey = (input: DeadCodeCacheKeyInput): string =>
   crypto
     .createHash("sha1")
@@ -125,13 +148,12 @@ export const computeDeadCodeCacheKey = (input: DeadCodeCacheKeyInput): string =>
         deslopJsModuleSpecifier: input.deslopJsModuleSpecifier,
         entryPatterns: input.entryPatterns,
         ignorePatterns: input.ignorePatterns,
-        // Which tsconfig filename resolved (its CONTENT rides in the file
-        // fingerprints below; existence/choice is what this captures).
+        // Which tsconfig filename resolved (its CONTENT rides in the per-file
+        // identities; existence/choice is what this captures).
         tsConfigFile:
           input.tsConfigPath === undefined
             ? null
             : path.relative(input.rootDirectory, input.tsConfigPath).replace(/\\/g, "/"),
-        files: collectAnalyzedFileFingerprints(input.rootDirectory),
       }),
     )
     .digest("hex");
@@ -151,34 +173,110 @@ const decodeCachedDiagnostics = (raw: ReadonlyArray<unknown>): ReadonlyArray<Dia
   }
 };
 
+const isPersistedFileIdentity = (value: unknown): value is PersistedFileIdentity =>
+  Array.isArray(value) &&
+  value.length === 3 &&
+  typeof value[0] === "number" &&
+  typeof value[1] === "number" &&
+  typeof value[2] === "string";
+
+export interface DeadCodeResultCacheLookupInput {
+  readonly cacheDirectory: string;
+  readonly cacheKey: string;
+  readonly rootDirectory: string;
+  /** The pre-analysis stat snapshot (`collectAnalyzedFileStats`). */
+  readonly currentFileStats: ReadonlyMap<string, AnalyzedFileStat>;
+}
+
 export const lookupDeadCodeResultCache = (
-  cacheDirectory: string,
-  cacheKey: string,
+  input: DeadCodeResultCacheLookupInput,
 ): ReadonlyArray<Diagnostic> | null => {
-  const persisted = failOpenReadJson<PersistedDeadCodeResultCache | null>(
-    path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME),
-    null,
-  );
+  const cacheFilePath = path.join(input.cacheDirectory, DEAD_CODE_CACHE_FILENAME);
+  const persisted = failOpenReadJson<PersistedDeadCodeResultCache | null>(cacheFilePath, null);
   if (
     persisted === null ||
     !isRecord(persisted) ||
     persisted.version !== DEAD_CODE_CACHE_SCHEMA_VERSION ||
-    persisted.key !== cacheKey ||
+    persisted.key !== input.cacheKey ||
+    !isRecord(persisted.files) ||
     !Array.isArray(persisted.diagnostics)
   ) {
     return null;
   }
-  return decodeCachedDiagnostics(persisted.diagnostics);
+  const storedFileEntries = Object.entries(persisted.files);
+  // Path-set equality both ways: equal counts plus every stored path present
+  // means neither additions nor deletions can slip through.
+  if (storedFileEntries.length !== input.currentFileStats.size) return null;
+  const repairedFiles: Record<string, PersistedFileIdentity> = {};
+  let repairedCount = 0;
+  for (const [relativePath, storedIdentity] of storedFileEntries) {
+    if (!isPersistedFileIdentity(storedIdentity)) return null;
+    const currentStat = input.currentFileStats.get(relativePath);
+    if (currentStat === undefined) return null;
+    const [storedMtimeMs, storedSize, storedContentHash] = storedIdentity;
+    if (currentStat.mtimeMs === storedMtimeMs && currentStat.size === storedSize) {
+      repairedFiles[relativePath] = storedIdentity;
+      continue;
+    }
+    // A size change is a content change; only a same-size stat mismatch (the
+    // fresh-checkout case) is worth the hash-and-repair read.
+    if (currentStat.size !== storedSize) return null;
+    const currentContentHash = hashFileContents(path.join(input.rootDirectory, relativePath));
+    if (currentContentHash === null || currentContentHash !== storedContentHash) return null;
+    repairedFiles[relativePath] = [currentStat.mtimeMs, currentStat.size, storedContentHash];
+    repairedCount += 1;
+  }
+  const diagnostics = decodeCachedDiagnostics(persisted.diagnostics);
+  if (diagnostics === null) return null;
+  if (repairedCount > 0) {
+    // Persist the refreshed stats so the repair cost is paid once per
+    // checkout: the next lookup takes the stat fast path.
+    atomicWriteJson(cacheFilePath, {
+      version: DEAD_CODE_CACHE_SCHEMA_VERSION,
+      key: input.cacheKey,
+      files: repairedFiles,
+      diagnostics: persisted.diagnostics,
+    });
+  }
+  return diagnostics;
 };
 
-export const storeDeadCodeResultCache = (
-  cacheDirectory: string,
-  cacheKey: string,
-  diagnostics: ReadonlyArray<Diagnostic>,
-): void => {
-  atomicWriteJson(path.join(cacheDirectory, DEAD_CODE_CACHE_FILENAME), {
+export interface DeadCodeResultCacheStoreInput {
+  readonly cacheDirectory: string;
+  readonly cacheKey: string;
+  readonly rootDirectory: string;
+  /** The pre-analysis stat snapshot (`collectAnalyzedFileStats`). */
+  readonly snapshotFileStats: ReadonlyMap<string, AnalyzedFileStat>;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+export const storeDeadCodeResultCache = (input: DeadCodeResultCacheStoreInput): void => {
+  const persistedFiles: Record<string, PersistedFileIdentity> = {};
+  for (const [relativePath, snapshotStat] of input.snapshotFileStats) {
+    const absolutePath = path.join(input.rootDirectory, relativePath);
+    // Hash first, stat second: a file edited during the analysis either fails
+    // the stat re-verification below (edit before the hash) or changed after
+    // the hash captured it — in which case the recorded hash matches the
+    // pre-edit content and the next lookup misses on it. Either way a racing
+    // edit can't produce a repairable stale entry. (Files added during the
+    // analysis need no handling: they miss the lookup's path-set equality.)
+    const contentHash = hashFileContents(absolutePath);
+    if (contentHash === null) return;
+    let currentStat: fs.Stats;
+    try {
+      currentStat = fs.statSync(absolutePath);
+    } catch {
+      return;
+    }
+    if (currentStat.mtimeMs !== snapshotStat.mtimeMs || currentStat.size !== snapshotStat.size) {
+      return;
+    }
+    persistedFiles[relativePath] = [snapshotStat.mtimeMs, snapshotStat.size, contentHash];
+  }
+  atomicWriteJson(path.join(input.cacheDirectory, DEAD_CODE_CACHE_FILENAME), {
     version: DEAD_CODE_CACHE_SCHEMA_VERSION,
-    key: cacheKey,
-    diagnostics,
+    key: input.cacheKey,
+    files: persistedFiles,
+    diagnostics: input.diagnostics,
   });
 };
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index ee613d5181..36df50c25f 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -101,6 +101,7 @@ export * from "./utils/remaining-deadline-budget-ms.js";
 export * from "./utils/resolve-auto-scan-concurrency.js";
 export * from "./utils/resolve-github-actions-score-metadata.js";
 export * from "./utils/resolve-lint-batch-ordering.js";
+export * from "./utils/resolve-react-doctor-cache-dir.js";
 export * from "./utils/resolve-scan-concurrency.js";
 export * from "./utils/sort-diagnostics-stable.js";
 export * from "./utils/to-relative-path.js";
diff --git a/packages/core/src/utils/compute-config-fingerprint.ts b/packages/core/src/utils/compute-config-fingerprint.ts
index 465fa62783..0116ff5f14 100644
--- a/packages/core/src/utils/compute-config-fingerprint.ts
+++ b/packages/core/src/utils/compute-config-fingerprint.ts
@@ -1,19 +1,21 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
 import path from "node:path";
 import { CONFIG_FINGERPRINT_FILENAMES } from "../constants.js";
+import { hashFileContents } from "./hash-file-contents.js";
 
+// Content-hashed (not stat-fingerprinted) so the fingerprint survives a fresh
+// CI checkout, where every file's mtime is checkout time: identical config
+// content keys identically across re-clones. The files are configs and
+// manifests — small enough that hashing the chain costs single-digit
+// milliseconds per scan (lockfiles are the largest, and hashing is far
+// cheaper than the scan they key).
 export const computeConfigFingerprint = (projectDirectory: string, version: string): string => {
   const parts: string[] = [`v=${version}`];
   let directory = projectDirectory;
   for (;;) {
     for (const filename of CONFIG_FINGERPRINT_FILENAMES) {
-      try {
-        const stat = fs.statSync(path.join(directory, filename));
-        parts.push(`${directory}/${filename}=${stat.mtimeMs}:${stat.size}`);
-      } catch {
-        continue;
-      }
+      const contentHash = hashFileContents(path.join(directory, filename));
+      if (contentHash !== null) parts.push(`${directory}/${filename}=${contentHash}`);
     }
     const parent = path.dirname(directory);
     if (parent === directory) break;
diff --git a/packages/core/tests/check-supply-chain-cache.test.ts b/packages/core/tests/check-supply-chain-cache.test.ts
index 98ffc92e6b..334c1e98d6 100644
--- a/packages/core/tests/check-supply-chain-cache.test.ts
+++ b/packages/core/tests/check-supply-chain-cache.test.ts
@@ -105,6 +105,24 @@ describe("supply-chain on-disk cache", () => {
     expect(second).toEqual(first); // advisory still produced from the fresh fetch
   });
 
+  it("prunes cache files past the TTL so stale purls don't accumulate across CI restores", async () => {
+    stubSocketFetch();
+    await runCheck();
+    const cacheFiles = walkCacheFiles(cacheDirectory);
+    expect(cacheFiles.length).toBeGreaterThan(0);
+
+    // Simulate an entry for a purl no run looks up anymore (a bumped or
+    // removed dependency) whose mtime is past the 24h TTL.
+    const staleFile = path.join(path.dirname(cacheFiles[0]), "stale-purl.json");
+    fs.writeFileSync(staleFile, JSON.stringify({ fetchedAtMs: 0, body: "{}" }));
+    const expiredDate = new Date(Date.now() - 48 * 60 * 60 * 1_000);
+    fs.utimesSync(staleFile, expiredDate, expiredDate);
+
+    await runCheck();
+    expect(fs.existsSync(staleFile)).toBe(false);
+    expect(walkCacheFiles(cacheDirectory).length).toBeGreaterThan(0); // live entries survive
+  });
+
   it("re-fetches every run when REACT_DOCTOR_NO_CACHE is set (cache bypassed)", async () => {
     process.env["REACT_DOCTOR_NO_CACHE"] = "1";
     const fetchMock = stubSocketFetch();
diff --git a/packages/core/tests/dead-code-result-cache.test.ts b/packages/core/tests/dead-code-result-cache.test.ts
index c37a616640..776e2661c6 100644
--- a/packages/core/tests/dead-code-result-cache.test.ts
+++ b/packages/core/tests/dead-code-result-cache.test.ts
@@ -6,7 +6,10 @@ import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analy
 import { afterAll, beforeAll, describe, expect, it } from "vite-plus/test";
 import type { Diagnostic } from "../src/types/index.js";
 import { checkDeadCode } from "../src/check-dead-code.js";
-import { computeDeadCodeCacheKey } from "../src/dead-code/dead-code-result-cache.js";
+import {
+  collectAnalyzedFileStats,
+  computeDeadCodeCacheKey,
+} from "../src/dead-code/dead-code-result-cache.js";
 import { DeadCodeResultCacheEnabled } from "../src/refs.js";
 
 const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dead-code-cache-"));
@@ -90,49 +93,13 @@ describe("computeDeadCodeCacheKey", () => {
     );
   });
 
-  it("changes when a source file is touched (mtime)", () => {
-    const directory = setupProject("key-touch", {
-      "src/index.ts": "export const used = 1;\n",
-    });
-    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
-    const later = new Date(Date.now() + 5_000);
-    fs.utimesSync(path.join(directory, "src", "index.ts"), later, later);
-    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
-  });
-
-  it("changes when a source file is added", () => {
-    const directory = setupProject("key-add", {
+  it("is unaffected by file changes (files are verified per-entry, not keyed)", () => {
+    const directory = setupProject("key-file-independent", {
       "src/index.ts": "export const used = 1;\n",
     });
     const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
     fs.writeFileSync(path.join(directory, "src", "added.ts"), "export const added = 1;\n");
-    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
-  });
-
-  it("changes when a source file is deleted", () => {
-    const directory = setupProject("key-delete", {
-      "src/index.ts": "export const used = 1;\n",
-      "src/doomed.ts": "export const doomed = 1;\n",
-    });
-    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
-    fs.rmSync(path.join(directory, "src", "doomed.ts"));
-    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
-  });
-
-  it("changes when a manifest (package.json) changes", () => {
-    const directory = setupProject("key-manifest", {
-      "src/index.ts": "export const used = 1;\n",
-    });
-    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
-    fs.writeFileSync(
-      path.join(directory, "package.json"),
-      JSON.stringify({
-        name: "key-manifest",
-        type: "module",
-        dependencies: { react: "^19.0.0", "left-pad": "^1.0.0" },
-      }),
-    );
-    expect(computeDeadCodeCacheKey(keyInput(directory))).not.toBe(keyBefore);
+    expect(computeDeadCodeCacheKey(keyInput(directory))).toBe(keyBefore);
   });
 
   it("changes with entry / ignore patterns and the resolved tsconfig", () => {
@@ -154,15 +121,6 @@ describe("computeDeadCodeCacheKey", () => {
     ).not.toBe(baseKey);
   });
 
-  it("ignores files the analysis never reads (scratch text files)", () => {
-    const directory = setupProject("key-scratch", {
-      "src/index.ts": "export const used = 1;\n",
-    });
-    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
-    fs.writeFileSync(path.join(directory, "scratch.txt"), "not part of the graph\n");
-    expect(computeDeadCodeCacheKey(keyInput(directory))).toBe(keyBefore);
-  });
-
   it("changes when the core package version changes", () => {
     const directory = setupProject("key-core-version", {
       "src/index.ts": "export const used = 1;\n",
@@ -174,34 +132,45 @@ describe("computeDeadCodeCacheKey", () => {
 });
 
 describe("fingerprinted file sets (imported from deslop-js/analyzed-inputs)", () => {
-  it("fingerprints a file for every extension deslop's walk parses", () => {
-    const directory = setupProject("key-extension-coverage", {
+  it("stats a file for every extension deslop's walk parses", () => {
+    const directory = setupProject("stat-extension-coverage", {
       "src/index.ts": "export const used = 1;\n",
     });
-    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
     for (const extension of DEFAULT_EXTENSIONS) {
       const probePath = path.join(directory, "probe", `probe${extension}`);
       fs.mkdirSync(path.dirname(probePath), { recursive: true });
       fs.writeFileSync(probePath, "probe\n");
-      expect(computeDeadCodeCacheKey(keyInput(directory)), extension).not.toBe(keyBefore);
+      expect(collectAnalyzedFileStats(directory).has(`probe/probe${extension}`), extension).toBe(
+        true,
+      );
       fs.rmSync(probePath);
     }
   });
 
-  it("fingerprints every manifest name deslop's analysis reads", () => {
-    const directory = setupProject("key-manifest-coverage", {
+  it("stats every manifest name deslop's analysis reads", () => {
+    const directory = setupProject("stat-manifest-coverage", {
       "src/index.ts": "export const used = 1;\n",
     });
-    const keyBefore = computeDeadCodeCacheKey(keyInput(directory));
     for (const manifestName of ANALYZED_MANIFEST_FILENAMES) {
       const probePath = path.join(directory, "probe", manifestName);
       fs.mkdirSync(path.dirname(probePath), { recursive: true });
       fs.writeFileSync(probePath, "probe\n");
-      expect(computeDeadCodeCacheKey(keyInput(directory)), manifestName).not.toBe(keyBefore);
+      expect(collectAnalyzedFileStats(directory).has(`probe/${manifestName}`), manifestName).toBe(
+        true,
+      );
       fs.rmSync(probePath);
     }
   });
 
+  it("ignores files the analysis never reads (scratch text files)", () => {
+    const directory = setupProject("stat-scratch", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    fs.writeFileSync(path.join(directory, "scratch.txt"), "not part of the graph\n");
+    expect(collectAnalyzedFileStats(directory).has("scratch.txt")).toBe(false);
+    expect(collectAnalyzedFileStats(directory).has("src/index.ts")).toBe(true);
+  });
+
   // Not a redundant copy: a NEW extension or manifest in a deslop-js upgrade
   // widens what the cache fingerprints, so it must land here as a conscious,
   // reviewed choice rather than silently.
@@ -277,7 +246,7 @@ describe("checkDeadCode result cache", () => {
     expect(secondRun).toEqual(firstRun);
   });
 
-  it("misses after a source file changes, and re-analyzes", async () => {
+  it("misses after a source file's content changes, and re-analyzes", async () => {
     const directory = setupProject("miss-on-change", {
       "src/index.ts": "export const used = 1;\n",
     });
@@ -293,18 +262,117 @@ describe("checkDeadCode result cache", () => {
       cacheEnabled: true,
       onCacheOutcome,
     });
+    fs.writeFileSync(path.join(directory, "src", "index.ts"), "export const used = 12;\n");
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome,
+    });
+    expect(spyWorker.callCount()).toBe(2);
+    expect(cacheOutcomes).toEqual([false, false]);
+  });
+
+  it("misses when content changes but the byte size is preserved", async () => {
+    const directory = setupProject("miss-on-same-size-change", {
+      "src/index.ts": "export const used = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "index.ts"));
+    const cacheOutcomes: boolean[] = [];
+
+    await checkDeadCode({
+      rootDirectory: directory,
+      createWorker: spyWorker.factory,
+      cacheEnabled: true,
+      onCacheOutcome: (didHitCache) => {
+        cacheOutcomes.push(didHitCache);
+      },
+    });
+    // Same length, different bytes, and a bumped mtime: the repair path must
+    // reject it on the content hash, not accept it on the size.
+    fs.writeFileSync(path.join(directory, "src", "index.ts"), "export const used = 2;\n");
     const later = new Date(Date.now() + 5_000);
     fs.utimesSync(path.join(directory, "src", "index.ts"), later, later);
     await checkDeadCode({
       rootDirectory: directory,
       createWorker: spyWorker.factory,
       cacheEnabled: true,
-      onCacheOutcome,
+      onCacheOutcome: (didHitCache) => {
+        cacheOutcomes.push(didHitCache);
+      },
     });
     expect(spyWorker.callCount()).toBe(2);
     expect(cacheOutcomes).toEqual([false, false]);
   });
 
+  it("misses when a file is added or deleted", async () => {
+    const directory = setupProject("miss-on-add-delete", {
+      "src/index.ts": "export const used = 1;\n",
+      "src/doomed.ts": "export const doomed = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "index.ts"));
+    const cacheOutcomes: boolean[] = [];
+    const runOnce = (): Promise<Diagnostic[]> =>
+      checkDeadCode({
+        rootDirectory: directory,
+        createWorker: spyWorker.factory,
+        cacheEnabled: true,
+        onCacheOutcome: (didHitCache) => {
+          cacheOutcomes.push(didHitCache);
+        },
+      });
+
+    await runOnce();
+    fs.writeFileSync(path.join(directory, "src", "added.ts"), "export const added = 1;\n");
+    await runOnce();
+    fs.rmSync(path.join(directory, "src", "doomed.ts"));
+    await runOnce();
+    expect(spyWorker.callCount()).toBe(3);
+    expect(cacheOutcomes).toEqual([false, false, false]);
+  });
+
+  it("repairs an mtime-only bump over identical content and replays (fresh CI checkout)", async () => {
+    const directory = setupProject("repair-mtime-bump", {
+      "src/index.ts": "export const used = 1;\n",
+      "src/orphan.ts": "export const orphan = 1;\n",
+    });
+    const spyWorker = createSpyWorker(path.join(directory, "src", "orphan.ts"));
+    const cacheOutcomes: boolean[] = [];
+    const runOnce = (): Promise<Diagnostic[]> =>
+      checkDeadCode({
+        rootDirectory: directory,
+        createWorker: spyWorker.factory,
+        cacheEnabled: true,
+        onCacheOutcome: (didHitCache) => {
+          cacheOutcomes.push(didHitCache);
+        },
+      });
+
+    const coldRun = await runOnce();
+
+    // Simulate a fresh checkout: every fingerprinted file's mtime changes,
+    // content stays byte-identical.
+    const bumpedDate = new Date(Date.now() + 60_000);
+    for (const relativePath of collectAnalyzedFileStats(directory).keys()) {
+      fs.utimesSync(path.join(directory, relativePath), bumpedDate, bumpedDate);
+    }
+    const repairedRun = await runOnce();
+    expect(spyWorker.callCount()).toBe(1);
+    expect(cacheOutcomes).toEqual([false, true]);
+    expect(repairedRun).toEqual(coldRun);
+
+    // The repair must persist the refreshed stats so the next lookup takes
+    // the stat fast path (no re-hash, and a hit even if hashing broke).
+    const persisted = JSON.parse(fs.readFileSync(cacheFilePath(directory), "utf8"));
+    const storedIndexEntry = persisted.files["src/index.ts"];
+    expect(storedIndexEntry[0]).toBe(fs.statSync(path.join(directory, "src", "index.ts")).mtimeMs);
+
+    const fastPathRun = await runOnce();
+    expect(spyWorker.callCount()).toBe(1);
+    expect(cacheOutcomes).toEqual([false, true, true]);
+    expect(fastPathRun).toEqual(coldRun);
+  });
+
   it("never stores a failed pass", async () => {
     const directory = setupProject("store-barred-on-failure", {
       "src/index.ts": "export const used = 1;\n",
diff --git a/packages/deslop-js/src/constants.ts b/packages/deslop-js/src/constants.ts
index 2f0a902cec..a8309d1030 100644
--- a/packages/deslop-js/src/constants.ts
+++ b/packages/deslop-js/src/constants.ts
@@ -334,7 +334,8 @@ export const MAX_ANALYSIS_ERRORS = 5000;
 
 export const MAX_ERROR_DETAIL_LENGTH = 1000;
 
-export const SUMMARY_CACHE_SCHEMA_VERSION = 1;
+// Bumped to 2: per-file entries carry a content-hash repair witness (`h`).
+export const SUMMARY_CACHE_SCHEMA_VERSION = 2;
 
 export const SUMMARY_CACHE_MAX_BYTES = 256 * 1024 * 1024;
 
diff --git a/packages/deslop-js/src/summary-cache.ts b/packages/deslop-js/src/summary-cache.ts
index 73c03a9e6e..83a2e6268c 100644
--- a/packages/deslop-js/src/summary-cache.ts
+++ b/packages/deslop-js/src/summary-cache.ts
@@ -1,19 +1,25 @@
 // The incremental analysis cache behind `DeslopConfig.incrementalCachePath`.
 // One tree walk per run is the single change detector; from it four layers are
 // validated independently:
-//   1. per-file parse summaries (`ParsedSource`) keyed by (mtimeMs, size);
+//   1. per-file parse summaries (`ParsedSource`) keyed by (mtimeMs, size) with
+//      a content-hash REPAIR path: a stat mismatch over identical bytes (a
+//      fresh CI checkout bumps every mtime) re-hashes the file, accepts the
+//      entry, and refreshes the stored stat — so the hash cost is paid once
+//      per checkout, not once per run (the ninja/restat pattern);
 //   2. the collected file LIST keyed by `collectHash` (sorted file names, with
-//      manifest-like files stat-fingerprinted). Entry RESOLUTION is
+//      manifest-like files content-hashed so a re-clone of identical content
+//      keys identically). Entry RESOLUTION is
 //      deliberately NOT cached: `resolveEntries` reads an unbounded content
 //      set (bundler/test-runner config strings, workflow yml, HTML, tsconfig
 //      contents, even sibling-workspace sources), so no name-based fingerprint
 //      can validate it — it re-runs live every scan, overlapped with parsing;
 //   3. the `fromDir::specifier → ResolvedImport` map keyed by `resolutionHash`
-//      (`collectHash` ⊕ bundler-config stats — module resolution depends on the
-//      file SET, so summaries cache raw specifiers only and any add/delete/
-//      rename drops the whole resolution map);
+//      (`collectHash` ⊕ bundler-config content hashes — module resolution
+//      depends on the file SET, so summaries cache raw specifiers only and any
+//      add/delete/rename drops the whole resolution map);
 //   4. per-file package-reference facts for `detectStalePackages`' content
-//      scans, keyed by (mtimeMs, size, queried-name-set hash).
+//      scans, keyed by (mtimeMs, size, queried-name-set hash), with the same
+//      content-hash repair as the summaries.
 // Every read fails open (corrupt / missing / version- or scope-mismatched data
 // degrades to a fresh computation, never a wrong result), saves are atomic
 // (temp file + rename) and skipped when nothing changed. The accepted blind
@@ -119,6 +125,8 @@ interface PersistedParsedSource {
 }
 
 interface PersistedSummaryEntry extends FileStatFingerprint {
+  /** SHA-1 of the file's bytes at store time — the mtime-repair witness. */
+  h: string;
   p: PersistedParsedSource;
 }
 
@@ -128,6 +136,8 @@ interface PersistedPackageFactMatch {
 }
 
 interface PersistedPackageFactEntry extends FileStatFingerprint {
+  /** SHA-1 of the file's decoded content at store time — the mtime-repair witness. */
+  h: string;
   substring?: PersistedPackageFactMatch;
   importReference?: PersistedPackageFactMatch;
 }
@@ -184,6 +194,14 @@ const isResolverConfigFileName = (fileName: string): boolean =>
 
 const sha1Hex = (text: string): string => crypto.createHash("sha1").update(text).digest("hex");
 
+const sha1OfFileBytes = (filePath: string): string | null => {
+  try {
+    return crypto.createHash("sha1").update(readFileSync(filePath)).digest("hex");
+  } catch {
+    return null;
+  }
+};
+
 const fileNameOfPosixPath = (posixPath: string): string =>
   posixPath.slice(posixPath.lastIndexOf("/") + 1);
 
@@ -272,12 +290,20 @@ const countPathSegments = (relativePath: string): number => {
   return segmentCount;
 };
 
+// Content identity for the few files whose CONTENT feeds a layer hash
+// (manifests, bundler configs). Hashed — not stat-fingerprinted — so a fresh
+// CI checkout of identical content keys identically; the set is small, so the
+// per-run hash cost is milliseconds. An unreadable file falls back to the
+// conservative stat identity (it can never spuriously match a hash).
+const contentFingerprintOf = (filePath: string, fileStat: FileStatFingerprint): string =>
+  `${filePath}:${fileStat.s}:${sha1OfFileBytes(filePath) ?? `stat-${fileStat.m}`}`;
+
 const computeCollectHash = (walkedStats: Map<string, FileStatFingerprint>): string => {
   const fingerprintLines: string[] = [];
   for (const [filePath, fileStat] of walkedStats) {
     fingerprintLines.push(
       isManifestLikeFileName(fileNameOfPosixPath(filePath))
-        ? `${filePath}:${fileStat.m}:${fileStat.s}`
+        ? contentFingerprintOf(filePath, fileStat)
         : filePath,
     );
   }
@@ -292,7 +318,7 @@ const computeResolutionHash = (
   const fingerprintLines: string[] = [];
   for (const [filePath, fileStat] of walkedStats) {
     if (isResolverConfigFileName(fileNameOfPosixPath(filePath))) {
-      fingerprintLines.push(`${filePath}:${fileStat.m}:${fileStat.s}`);
+      fingerprintLines.push(contentFingerprintOf(filePath, fileStat));
     }
   }
   fingerprintLines.sort();
@@ -501,9 +527,7 @@ const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCac
   const activeFactPaths = new Set<string>();
   const sortedNameSetMemo = new WeakMap<ReadonlySet<string>, SortedNameSet>();
 
-  const statOf = (filePath: string): FileStatFingerprint | null => {
-    const walked = walkedStats.get(filePath);
-    if (walked) return walked;
+  const statOfLive = (filePath: string): FileStatFingerprint | null => {
     try {
       const fileStat = statSync(filePath);
       return { m: fileStat.mtimeMs, s: fileStat.size };
@@ -512,6 +536,9 @@ const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCac
     }
   };
 
+  const statOf = (filePath: string): FileStatFingerprint | null =>
+    walkedStats.get(filePath) ?? statOfLive(filePath);
+
   return {
     lookupFileList: () => {
       const cachedFileList = store.fileList;
@@ -540,8 +567,18 @@ const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCac
       const cachedSummary = store.summaries[filePath];
       if (!isRecordValue(cachedSummary)) return null;
       const fileStat = statOf(filePath);
-      if (!fileStat || fileStat.m !== cachedSummary.m || fileStat.s !== cachedSummary.s) {
-        return null;
+      if (!fileStat) return null;
+      if (fileStat.m !== cachedSummary.m || fileStat.s !== cachedSummary.s) {
+        // Mtime repair: a fresh checkout bumps every mtime over identical
+        // bytes. A size change is a content change (skip the read); a
+        // same-size stat mismatch re-hashes, and a hash match accepts the
+        // entry and refreshes the stored stat so the next run stats through.
+        if (fileStat.s !== cachedSummary.s || typeof cachedSummary.h !== "string") return null;
+        const contentHash = sha1OfFileBytes(filePath);
+        if (contentHash === null || contentHash !== cachedSummary.h) return null;
+        cachedSummary.m = fileStat.m;
+        cachedSummary.s = fileStat.s;
+        isDirty = true;
       }
       const revived = reviveParsedSource(cachedSummary.p);
       if (revived === null) return null;
@@ -550,11 +587,21 @@ const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCac
     },
 
     storeSummary: (filePath, parsed) => {
-      const fileStat = statOf(filePath);
-      if (!fileStat) return;
+      const walkStat = statOf(filePath);
+      if (!walkStat) return;
+      // Hash first, then re-stat: an edit racing the parse either changed the
+      // stat (skip the store) or landed after the hash captured the parsed
+      // content (the next lookup's hash check misses on it). Without the
+      // re-verification, a racing edit could pair walk-time stats with
+      // post-edit content and mint a repairable stale entry.
+      const contentHash = sha1OfFileBytes(filePath);
+      if (contentHash === null) return;
+      const liveStat = statOfLive(filePath);
+      if (liveStat === null || liveStat.m !== walkStat.m || liveStat.s !== walkStat.s) return;
       store.summaries[filePath] = {
-        m: fileStat.m,
-        s: fileStat.s,
+        m: walkStat.m,
+        s: walkStat.s,
+        h: contentHash,
         p: serializeParsedSource(parsed, shouldPersistDryPatternFields),
       };
       activeSummaryPaths.add(filePath);
@@ -595,10 +642,12 @@ const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCac
       }
       activeFactPaths.add(filePath);
       const fileStat = statOf(filePath);
-      const existingEntry = store.packageFacts[filePath];
-      const validEntry =
+      const existingEntry = isRecordValue(store.packageFacts[filePath])
+        ? store.packageFacts[filePath]
+        : null;
+      let validEntry =
         fileStat !== null &&
-        isRecordValue(existingEntry) &&
+        existingEntry !== null &&
         existingEntry.m === fileStat.m &&
         existingEntry.s === fileStat.s
           ? existingEntry
@@ -612,11 +661,28 @@ const createSummaryCache = (cachePath: string, config: DeslopConfig): SummaryCac
         return existingMatch.matched;
       }
       const content = readFileSync(filePath, "utf-8");
+      const contentHash = sha1Hex(content);
+      if (validEntry === null && fileStat !== null && existingEntry?.h === contentHash) {
+        // Mtime repair: the fact-scan read the content anyway, so a hash match
+        // revalidates the whole entry (both kinds) under the fresh stat.
+        existingEntry.m = fileStat.m;
+        existingEntry.s = fileStat.s;
+        isDirty = true;
+        validEntry = existingEntry;
+        const repairedMatch = validEntry[kind];
+        if (
+          isRecordValue(repairedMatch) &&
+          repairedMatch.h === nameSet.hash &&
+          isStringArray(repairedMatch.matched)
+        ) {
+          return repairedMatch.matched;
+        }
+      }
       const matchedNames = nameSet.sortedNames.filter((packageName) =>
         matcher(content, packageName),
       );
       if (fileStat !== null) {
-        const factEntry = validEntry ?? { m: fileStat.m, s: fileStat.s };
+        const factEntry = validEntry ?? { m: fileStat.m, s: fileStat.s, h: contentHash };
         factEntry[kind] = { h: nameSet.hash, matched: matchedNames };
         store.packageFacts[filePath] = factEntry;
         isDirty = true;
diff --git a/packages/deslop-js/tests/summary-cache.test.ts b/packages/deslop-js/tests/summary-cache.test.ts
index 09a82f1db1..9324a58402 100644
--- a/packages/deslop-js/tests/summary-cache.test.ts
+++ b/packages/deslop-js/tests/summary-cache.test.ts
@@ -486,6 +486,68 @@ describe("summary cache", () => {
     assert.ok(unusedExportNames(control).includes("ab"), "an uncached run sees the edit");
   });
 
+  it("repairs a fresh-checkout mtime bump over identical content and persists the refreshed stats", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+
+    // Simulate a fresh CI checkout: every file's mtime is checkout time,
+    // content is byte-identical.
+    const bumpedTime = new Date(Date.now() + 60_000);
+    const bumpTreeMtimes = (directory: string): void => {
+      for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const entryPath = join(directory, entry.name);
+        if (entry.isDirectory()) bumpTreeMtimes(entryPath);
+        else utimesSync(entryPath, bumpedTime, bumpedTime);
+      }
+    };
+    bumpTreeMtimes(workspace.projectDirectory);
+
+    const repaired = await scan(workspace, { cached: true });
+    assert.deepEqual(
+      repaired.incrementalCacheStats,
+      { summaryHits: 4, summaryMisses: 0 },
+      "every summary must repair-hit, none re-parse",
+    );
+    assert.equal(
+      resultSignature(repaired, workspace.projectDirectory),
+      resultSignature(cold, workspace.projectDirectory),
+    );
+
+    // The repair run persists the refreshed stats, so the next run takes the
+    // stat fast path end to end — nothing dirties, and the save is skipped.
+    const cacheBytesAfterRepair = readFileSync(workspace.cachePath, "utf-8");
+    const cacheMtimeAfterRepair = statSync(workspace.cachePath).mtimeMs;
+    const fastPath = await scan(workspace, { cached: true });
+    assert.deepEqual(fastPath.incrementalCacheStats, { summaryHits: 4, summaryMisses: 0 });
+    assert.equal(readFileSync(workspace.cachePath, "utf-8"), cacheBytesAfterRepair);
+    assert.equal(statSync(workspace.cachePath).mtimeMs, cacheMtimeAfterRepair);
+  });
+
+  it("misses an mtime-bumped file whose content changed at the same byte size", async () => {
+    const workspace = buildFixture();
+    const cold = await scan(workspace, { cached: true });
+    assert.ok(unusedExportNames(cold).includes("staleExport"));
+
+    // Same byte length, different content, new mtime: the repair path must
+    // reject on the content hash and re-parse.
+    const editedPath = join(workspace.projectDirectory, "src/used.ts");
+    writeFileSync(
+      editedPath,
+      readFileSync(editedPath, "utf-8").replace("staleExport", "staleXport2"),
+    );
+    utimesSync(editedPath, new Date(Date.now() + 60_000), new Date(Date.now() + 60_000));
+
+    const warm = await scan(workspace, { cached: true });
+    assert.deepEqual(warm.incrementalCacheStats, { summaryHits: 3, summaryMisses: 1 });
+    assert.ok(unusedExportNames(warm).includes("staleXport2"));
+    assert.ok(!unusedExportNames(warm).includes("staleExport"));
+    const control = await scan(workspace, { cached: false });
+    assert.equal(
+      resultSignature(warm, workspace.projectDirectory),
+      resultSignature(control, workspace.projectDirectory),
+    );
+  });
+
   it("round-trips redundancy findings at full fidelity, and slims them when disabled", async () => {
     const duplicateTypeFiles = {
       "src/shape-a.ts":
diff --git a/packages/react-doctor/src/cli/utils/constants.ts b/packages/react-doctor/src/cli/utils/constants.ts
index 66f8263c40..ea2960d5ed 100644
--- a/packages/react-doctor/src/cli/utils/constants.ts
+++ b/packages/react-doctor/src/cli/utils/constants.ts
@@ -29,14 +29,13 @@ export const BASELINE_FILES_TEMP_DIR_PREFIX = "react-doctor-baseline-";
 // Bumped to 3: gained the required `suppressedRuleCounts` field (suppression telemetry).
 export const SCAN_RESULT_CACHE_SCHEMA_VERSION = 3;
 export const SCAN_RESULT_CACHE_MAX_ENTRY_COUNT = 20;
-export const CACHE_FILENAME_HASH_LENGTH_CHARS = 16;
+export const SCAN_RESULT_CACHE_FILENAME = "scan-cache.json";
 // The dirty-worktree cache-key fingerprint content-hashes every path `git
 // status` reports; past this many entries the hashing could cost more than a
 // cache hit saves, so the key builder bails to null (cache off) — the same
 // worst case as the old clean-tree-only gate.
 export const SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT = 300;
-// Dirty files larger than this are fingerprinted by `mtimeMs:size` (the same
-// stat identity `computeConfigFingerprint` trusts for config files) instead of
+// Dirty files larger than this are fingerprinted by `mtimeMs:size` instead of
 // a content hash, bounding the key builder's read cost and memory.
 export const SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 
diff --git a/packages/react-doctor/src/cli/utils/scan-result-cache.ts b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
index 9d03f83162..fc75b1d0f1 100644
--- a/packages/react-doctor/src/cli/utils/scan-result-cache.ts
+++ b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
@@ -1,12 +1,12 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import { createRequire } from "node:module";
-import os from "node:os";
 import path from "node:path";
 import {
   computeConfigFingerprint,
   hashFileContents,
   resolveLintBatchOrdering,
+  resolveReactDoctorCacheDir,
 } from "@react-doctor/core";
 import type {
   Diagnostic,
@@ -17,7 +17,7 @@ import type {
   SuppressedRuleCount,
 } from "@react-doctor/core";
 import {
-  CACHE_FILENAME_HASH_LENGTH_CHARS,
+  SCAN_RESULT_CACHE_FILENAME,
   SCAN_RESULT_CACHE_MAX_DIRTY_STATUS_ENTRY_COUNT,
   SCAN_RESULT_CACHE_MAX_ENTRY_COUNT,
   SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES,
@@ -93,14 +93,17 @@ interface ScanResultCacheKeyInput {
 
 const CACHE_DISABLED_VALUES = new Set(["1", "true"]);
 const TOOLCHAIN_PACKAGE_SPECIFIERS = [
-  "oxlint",
   "oxlint/package.json",
-  "oxlint-plugin-react-doctor",
+  "oxlint-plugin-react-doctor/package.json",
   "deslop-js/package.json",
   "eslint-plugin-react-hooks/package.json",
 ] as const;
 const bundledRequire = createRequire(import.meta.url);
 
+interface PackageVersionView {
+  readonly version?: unknown;
+}
+
 const normalizeForStableJson = (value: unknown): unknown => {
   if (value === null) return null;
   if (value === undefined) return undefined;
@@ -260,8 +263,10 @@ const buildWorktreeFingerprint = (
 const DOTENV_FILE_NAME_PATTERN = /^\.env(\.|$)/;
 
 // The security scan reads dotenv files even when they're gitignored — a state
-// `git status` can never surface — so their stat identity is keyed explicitly,
-// the same coverage `computeConfigFingerprint` gives gitignored config files.
+// `git status` can never surface — so their content is keyed explicitly, the
+// same coverage `computeConfigFingerprint` gives gitignored config files.
+// Content-hashed (dotenv files are tiny) rather than stat-fingerprinted so a
+// fresh CI checkout of identical content keys identically.
 const resolveDotenvFingerprint = (projectDirectory: string): ReadonlyArray<string> => {
   try {
     return fs
@@ -270,7 +275,7 @@ const resolveDotenvFingerprint = (projectDirectory: string): ReadonlyArray<strin
       .sort()
       .map(
         (entryName) =>
-          `${entryName}=${fileFingerprint(path.join(projectDirectory, entryName)) ?? "unreadable"}`,
+          `${entryName}=${hashFileContents(path.join(projectDirectory, entryName)) ?? "unreadable"}`,
       );
   } catch {
     return [];
@@ -283,14 +288,13 @@ const hasHiddenTrackedFileState = (projectDirectory: string): boolean => {
   return output.split("\n").some((line) => line.length > 0 && line[0] !== "H");
 };
 
-const resolveCacheFilePath = (projectDirectory: string): string => {
-  const nodeModulesDirectory = path.join(projectDirectory, "node_modules");
-  if (fs.existsSync(nodeModulesDirectory)) {
-    return path.join(nodeModulesDirectory, ".cache", "react-doctor", "scan-cache.json");
-  }
-  const projectHash = hashString(projectDirectory).slice(0, CACHE_FILENAME_HASH_LENGTH_CHARS);
-  return path.join(os.tmpdir(), "react-doctor-cache", `scan-${projectHash}.json`);
-};
+// Sits beside the per-file lint / sidecar / dead-code caches under the shared
+// cache root, so the `REACT_DOCTOR_CACHE_DIR` override the GitHub Action sets
+// (a `${runner.temp}` path persisted by `actions/cache`) carries the whole-repo
+// scan cache across CI runs too — the project-local `node_modules/.cache`
+// default never survives a fresh, SHA-scoped checkout.
+const resolveCacheFilePath = (projectDirectory: string): string =>
+  path.join(resolveReactDoctorCacheDir(projectDirectory), SCAN_RESULT_CACHE_FILENAME);
 
 const readPersistedCache = (cacheFilePath: string): PersistedScanResultCache => {
   try {
@@ -359,19 +363,27 @@ const fileFingerprint = (filePath: string): string | null => {
   }
 };
 
+// Versioned (not file-fingerprinted) like the lint ruleset hash, so the key
+// survives a restored/re-extracted install in CI — extraction mtimes are an
+// implementation detail of the installer, not toolchain identity. The one
+// exception: a foreign oxlint Node (the nvm fallback) keeps the conservative
+// stat identity rather than paying a version-probe subprocess here.
 const resolveToolchainFingerprint = (nodeBinaryPath: string | null): ReadonlyArray<string> => {
   const fingerprints: string[] = [];
   if (nodeBinaryPath !== null) {
-    const fingerprint = fileFingerprint(nodeBinaryPath);
-    if (fingerprint !== null) fingerprints.push(`node=${fingerprint}`);
+    fingerprints.push(
+      nodeBinaryPath === process.execPath
+        ? `node=${process.version}`
+        : `node=${fileFingerprint(nodeBinaryPath) ?? "unreadable"}`,
+    );
   }
   for (const specifier of TOOLCHAIN_PACKAGE_SPECIFIERS) {
     try {
-      const resolvedPath = bundledRequire.resolve(specifier);
-      const fingerprint = fileFingerprint(resolvedPath);
-      if (fingerprint !== null) fingerprints.push(`${specifier}=${fingerprint}`);
+      const packageJson = bundledRequire(specifier) as PackageVersionView;
+      const version = typeof packageJson.version === "string" ? packageJson.version : "unknown";
+      fingerprints.push(`${specifier}=${version}`);
     } catch {
-      continue;
+      fingerprints.push(`${specifier}=missing`);
     }
   }
   return fingerprints;
diff --git a/packages/react-doctor/src/inspect.ts b/packages/react-doctor/src/inspect.ts
index 7e79125f19..5bb468452e 100644
--- a/packages/react-doctor/src/inspect.ts
+++ b/packages/react-doctor/src/inspect.ts
@@ -11,9 +11,11 @@ import {
   filterDiagnosticsForSurface,
   highlighter,
   OXLINT_NODE_REQUIREMENT,
+  PerFileLintCacheEnabled,
   resolveScanTarget,
   restoreLegacyThrow,
   runInspect as runInspectEffect,
+  SidecarLintCacheEnabled,
 } from "@react-doctor/core";
 import { applyObservability } from "./cli/utils/apply-observability.js";
 import { buildRuntimeLayers } from "./cli/utils/build-runtime-layers.js";
@@ -482,6 +484,12 @@ const runBaselineComparison = async (
       restoreLegacyThrow(
         baseProgram.pipe(
           Effect.provide(baseLayers),
+          // The base snapshot lints in a per-run-unique temp dir, so its
+          // on-disk cache identity can never hit — writing would only mint an
+          // orphan per-run subdir inside the CI-persisted cache directory
+          // (unbounded growth across the action's restore→save cycles).
+          Effect.provideService(PerFileLintCacheEnabled, false),
+          Effect.provideService(SidecarLintCacheEnabled, false),
           Effect.provideService(Console.Console, silentConsole),
         ),
       ),
diff --git a/packages/react-doctor/tests/scan-result-cache.test.ts b/packages/react-doctor/tests/scan-result-cache.test.ts
index bb03a5c6e7..8c8f47d365 100644
--- a/packages/react-doctor/tests/scan-result-cache.test.ts
+++ b/packages/react-doctor/tests/scan-result-cache.test.ts
@@ -146,6 +146,50 @@ describe("scan result cache", () => {
     expect(cache.lookup(key)?.diagnostics).toEqual([diagnostic(projectDirectory)]);
   });
 
+  it("honors REACT_DOCTOR_CACHE_DIR so the action-persisted dir carries the scan cache", () => {
+    const projectDirectory = setupReactProject(tempDirectory, "cache-dir-override", {
+      files: { "src/App.tsx": "export const App = () => <div />;\n" },
+    });
+    initGitRepo(projectDirectory, { commit: true });
+    const overrideDirectory = path.join(tempDirectory, "ci-cache");
+    const previousValue = process.env.REACT_DOCTOR_CACHE_DIR;
+    try {
+      process.env.REACT_DOCTOR_CACHE_DIR = overrideDirectory;
+      const key = cacheKey(projectDirectory, baseOptions());
+      expect(key).not.toBeNull();
+      if (key === null) return;
+      createScanResultCache(projectDirectory).store(key, basePayload(projectDirectory));
+
+      const persistedFiles = fs.readdirSync(overrideDirectory, { recursive: true });
+      expect(persistedFiles.some((entry) => String(entry).endsWith("scan-cache.json"))).toBe(true);
+      expect(createScanResultCache(projectDirectory).lookup(key)).not.toBeNull();
+    } finally {
+      if (previousValue === undefined) delete process.env.REACT_DOCTOR_CACHE_DIR;
+      else process.env.REACT_DOCTOR_CACHE_DIR = previousValue;
+    }
+  });
+
+  it("keys identically across a fresh-checkout mtime bump of config and dotenv files", () => {
+    const projectDirectory = setupReactProject(tempDirectory, "fresh-checkout", {
+      files: {
+        "src/App.tsx": "export const App = () => <div />;\n",
+        "doctor.config.json": JSON.stringify({ warnings: true }),
+        ".gitignore": ".env\n",
+        ".env": "API_KEY=value\n",
+      },
+    });
+    initGitRepo(projectDirectory, { commit: true });
+    const keyBefore = cacheKey(projectDirectory, baseOptions());
+    expect(keyBefore).not.toBeNull();
+
+    // A fresh CI checkout re-creates every file: same bytes, new mtimes.
+    const bumpedDate = new Date(Date.now() + 60_000);
+    for (const fileName of ["package.json", "doctor.config.json", ".env"]) {
+      fs.utimesSync(path.join(projectDirectory, fileName), bumpedDate, bumpedDate);
+    }
+    expect(cacheKey(projectDirectory, baseOptions())).toBe(keyBefore);
+  });
+
   // The cache is deliberately NOT keyed on `--max-duration`: it's safe to serve
   // a stored payload to a budgeted run because only COMPLETE scans are ever
   // stored. A budget-truncated run (lint partial or dead-code skipped) must be

From 574cba6e94b99776cfad671fe6709a24ea919624 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 4 Jul 2026 00:39:30 -0500
Subject: [PATCH 24/33] chore: version packages (#1055)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
---
 .changeset/perf-ci-action-cache.md            |  6 ----
 .../perf-dead-code-cache-key-hardening.md     |  6 ----
 .changeset/perf-dead-code-cache.md            |  5 ----
 .../perf-dead-code-incremental-cache.md       |  8 ------
 .changeset/perf-dirty-tree-cache-key.md       |  5 ----
 .changeset/perf-scan-cache-maxbuffer.md       |  7 -----
 .changeset/perf-sidecar-lint-cache.md         |  5 ----
 .changeset/telemetry-cache-temperature.md     |  5 ----
 packages/api/CHANGELOG.md                     |  7 +++++
 packages/api/package.json                     |  2 +-
 packages/core/CHANGELOG.md                    |  8 ++++++
 packages/core/package.json                    |  2 +-
 packages/deslop-cli/CHANGELOG.md              |  7 +++++
 packages/deslop-cli/package.json              |  2 +-
 packages/deslop-js/CHANGELOG.md               | 14 ++++++++++
 packages/deslop-js/package.json               |  2 +-
 .../eslint-plugin-react-doctor/CHANGELOG.md   |  7 +++++
 .../eslint-plugin-react-doctor/package.json   |  2 +-
 packages/fuzz/CHANGELOG.md                    |  7 +++++
 packages/fuzz/package.json                    |  2 +-
 packages/language-server/CHANGELOG.md         |  7 +++++
 packages/language-server/package.json         |  2 +-
 .../oxlint-plugin-react-doctor/CHANGELOG.md   |  2 ++
 .../oxlint-plugin-react-doctor/package.json   |  2 +-
 packages/react-doctor/CHANGELOG.md            | 28 +++++++++++++++++++
 packages/react-doctor/package.json            |  2 +-
 26 files changed, 96 insertions(+), 56 deletions(-)
 delete mode 100644 .changeset/perf-ci-action-cache.md
 delete mode 100644 .changeset/perf-dead-code-cache-key-hardening.md
 delete mode 100644 .changeset/perf-dead-code-cache.md
 delete mode 100644 .changeset/perf-dead-code-incremental-cache.md
 delete mode 100644 .changeset/perf-dirty-tree-cache-key.md
 delete mode 100644 .changeset/perf-scan-cache-maxbuffer.md
 delete mode 100644 .changeset/perf-sidecar-lint-cache.md
 delete mode 100644 .changeset/telemetry-cache-temperature.md

diff --git a/.changeset/perf-ci-action-cache.md b/.changeset/perf-ci-action-cache.md
deleted file mode 100644
index 48b7f11b3b..0000000000
--- a/.changeset/perf-ci-action-cache.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"deslop-js": patch
-"react-doctor": patch
----
-
-The whole cache stack now survives CI's fresh checkouts, so the GitHub Action's persisted `REACT_DOCTOR_CACHE_DIR` actually warms every layer instead of only the content-addressed ones. The whole-repo scan-result cache moves under the shared per-project cache root (honoring `REACT_DOCTOR_CACHE_DIR` like the lint, sidecar, dead-code, and supply-chain caches — previously it silently escaped the action's cache into `node_modules/.cache` or the OS temp dir), and its key drops every stat-based fingerprint that a re-clone rotates: config files and gitignored dotenv files are now content-hashed, and the toolchain is keyed by package versions (matching the lint ruleset hash) rather than install mtimes. The stat-fingerprinted dead-code caches gain mtime repair (the ninja/restat pattern): entries carry a content-hash witness, and a stat mismatch over identical bytes — every file after a fresh checkout — re-hashes once, accepts the entry, and persists the refreshed stat so the cost is paid once per checkout, not per run. This covers core's whole-project dead-code result cache (per-file `(mtime, size, hash)` records replacing the stats-in-key fingerprint) and deslop-js's incremental summary store (parse summaries, package-reference facts, and the manifest/bundler-config fingerprints feeding the collect/resolution hashes). Expired supply-chain score entries are also pruned past their TTL so restored cache directories stop accumulating dead purls. Everything stays fail-open and byte-identical to an uncached scan; on a re-cloned repo with one changed file, a warm scan now replays ~100% of lint, sidecar, and parse work instead of starting cold.
diff --git a/.changeset/perf-dead-code-cache-key-hardening.md b/.changeset/perf-dead-code-cache-key-hardening.md
deleted file mode 100644
index 5b16d7a4e1..0000000000
--- a/.changeset/perf-dead-code-cache-key-hardening.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"react-doctor": patch
-"deslop-js": patch
----
-
-Hardened the dead-code result cache key against two silent-staleness classes. The fingerprinted extension and manifest name lists are now imported from `deslop-js/analyzed-inputs` — a new dependency-free subpath export assembled from the same constants deslop's own readers consume — so a deslop upgrade that widens its walk can never under-invalidate the cache. And the key now includes `@react-doctor/core`'s own version, so upgrading react-doctor re-analyzes instead of replaying cached diagnostics shaped by an older core's post-processing. The cache schema-version constant remains for cache-format changes only.
diff --git a/.changeset/perf-dead-code-cache.md b/.changeset/perf-dead-code-cache.md
deleted file mode 100644
index 2cc3d4b2e7..0000000000
--- a/.changeset/perf-dead-code-cache.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"react-doctor": patch
----
-
-Rescans now skip the dead-code analysis entirely when nothing it reads has changed. The pass persists its diagnostics keyed by a fingerprint over the analyzed source tree (stat-based, so additions, deletions, and edits all invalidate), the project's manifests, tsconfigs, lockfiles, knip/entry/ignore configuration, and the analyzer version — on an unchanged-input rerun the stored result replays instead of re-walking the whole import graph, cutting several seconds off warm rescans of large repos. Only complete, successful passes are stored; `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
diff --git a/.changeset/perf-dead-code-incremental-cache.md b/.changeset/perf-dead-code-incremental-cache.md
deleted file mode 100644
index 6f9e0e6c24..0000000000
--- a/.changeset/perf-dead-code-incremental-cache.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-"deslop-js": minor
-"react-doctor": patch
----
-
-Dead-code analysis is now incremental across scans. deslop-js gains an opt-in `incrementalCachePath` config field: one stat walk per run (following directory symlinks, like the glob scans it stands in for) validates four independently keyed layers — per-file parse summaries (mtime+size), the collected file list, the module-resolution map (dropped whenever the file set or a bundler/tsconfig-like config changes, since resolution is file-set-dependent), and the per-file package-reference facts behind the unused-dependency content scans. The same walk also answers the stale-package file-discovery globs (config/docs/rescue/package.json/nx/tsconfig scans, verified byte-identical against fast-glob), so a cached run never re-walks the tree for them. Entry resolution deliberately stays live every run (it reads config/doc/sibling-source content no fingerprint can validate); on cached runs it moves to a dedicated worker thread so its filesystem work overlaps the main-thread analysis instead of serializing after it. Every layer fails open — corrupt, truncated, or version/config-mismatched stores degrade to a fresh computation, never a wrong result — writes are atomic and skipped when clean, and results are byte-identical to an uncached run. Unused-export detection also indexes re-export edges by source module, dropping an O(entry points × edges) scan that dominated the detector on large repos.
-
-react-doctor points the analysis worker at a per-project summary store next to the existing whole-result dead-code cache, so a changed-files rescan of a large repo re-parses only what changed (sentry, 9k files: ~8.0s → ~3.2s with 0-10 files edited; ~4.0s after adding a file; the cache-fill run costs the same as an uncached scan). The worker also stops running the discarded DRY-pattern redundancy detectors (`reportRedundancy: false`), which shrinks the summary store by dropping fields only those detectors read, and reports the cache outcome as `deadCode.summaryCacheHits` / `deadCode.summaryCacheMisses` in anonymized telemetry (absent whenever no analysis consulted the store). `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
diff --git a/.changeset/perf-dirty-tree-cache-key.md b/.changeset/perf-dirty-tree-cache-key.md
deleted file mode 100644
index 836618ea37..0000000000
--- a/.changeset/perf-dirty-tree-cache-key.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"react-doctor": patch
----
-
-Instant reruns now also work with uncommitted changes: the whole-repo scan-result cache no longer requires a clean worktree — it keys on the exact dirty state (every modified, staged, renamed, deleted, and untracked path plus a hash of its content), so rescanning the same work-in-progress tree hits the cache while any edit still invalidates it.
diff --git a/.changeset/perf-scan-cache-maxbuffer.md b/.changeset/perf-scan-cache-maxbuffer.md
deleted file mode 100644
index 99ab18a163..0000000000
--- a/.changeset/perf-scan-cache-maxbuffer.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"react-doctor": patch
----
-
-Restore instant reruns on large repos: raise `runGit`'s output cap so the whole-repo scan-result cache works past ~15k tracked files.
-
-The cache's clean-worktree gates shell out to git through a helper that used Node's default 1 MiB `maxBuffer`. On repos with roughly 15-25k tracked files (getsentry/sentry: 20,343), `git ls-files -v` alone exceeds that, `execFileSync` throws ENOBUFS, the helper swallows it into `null`, and the gates read `null` as "hidden tracked state" — so the cache silently never stored or served a scan on exactly the repos where the instant-rerun path saves the most time. The helper now runs with an explicit 64 MiB cap, which clears monorepos with hundreds of thousands of files while still bounding a pathological child process.
diff --git a/.changeset/perf-sidecar-lint-cache.md b/.changeset/perf-sidecar-lint-cache.md
deleted file mode 100644
index 59e3a0aeea..0000000000
--- a/.changeset/perf-sidecar-lint-cache.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"react-doctor": patch
----
-
-Warm rescans now skip the cross-file lint sidecar for files whose dependencies are unchanged. Previously the per-file lint cache replayed most rules but re-linted EVERY file with the cross-file ruleset (`no-barrel-import`, the Next.js metadata/Suspense rules, `no-mutating-reducer-state`, the React Native text rules) on every scan, because a sibling edit can flip an unchanged file's verdict. Each file now carries a dependency fingerprint — the exact set of filesystem probes (resolved import targets, barrel chains, ancestor layouts, nearest package.json/tsconfig, and the negative resolution candidates that catch shadowing) its cross-file rules consulted — and the sidecar replays the stored diagnostics when every probe still answers the same, re-linting only files whose dependency set changed. Every entry fails open (corrupt store, unparseable file, partial lint → fresh re-lint), a cross-file rule without a registered dependency collector re-lints everywhere, and `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_SIDECAR_CACHE`) disables it.
diff --git a/.changeset/telemetry-cache-temperature.md b/.changeset/telemetry-cache-temperature.md
deleted file mode 100644
index de22f34714..0000000000
--- a/.changeset/telemetry-cache-temperature.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"react-doctor": patch
----
-
-Added cache-temperature telemetry to the per-scan Sentry wide event, so cache effectiveness is queryable at a glance instead of being inferred from per-subsystem dims. `cache.temperature` classifies every scan as `turbo` (whole-repo scan-result replay — now marked by an explicit `wholeRepoCacheHit` flag on the replay path, never inferred from absent dims), `warm` (any incremental reuse across the per-file lint, sidecar, or dead-code caches), `cold` (caches on, zero reuse), or `disabled` (the global `REACT_DOCTOR_NO_CACHE` off-switch). `cache.warmth` is the numeric headline magnitude in [0, 1] — the plain mean of the known subsystem reuse fractions, skipping subsystems that never consulted a cache. The existing per-subsystem dims (`lint.cacheHitRatio`, `lint.sidecarReplayRatio`, `deadCode.cacheHit`, `deadCode.summaryCacheHits/Misses`) are unchanged. Telemetry-only: no new counters, no JSON-report or cache-schema changes.
diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md
index f35474c083..345b727cd8 100644
--- a/packages/api/CHANGELOG.md
+++ b/packages/api/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/api
 
+## 0.7.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @react-doctor/core@0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/api/package.json b/packages/api/package.json
index efe9e81adb..05e7a16e61 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/api",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "private": true,
   "description": "Programmatic API for React Doctor.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index ad718b2b78..496a6200b1 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @react-doctor/core
 
+## 0.7.0
+
+### Patch Changes
+
+- Updated dependencies [[`ced746f`](https://github.com/millionco/react-doctor/commit/ced746f518f11e8283d488c4ff31c44e478bb0e5), [`20d81f6`](https://github.com/millionco/react-doctor/commit/20d81f6f26dc8f0562118076f835da2468591d5f), [`ce49250`](https://github.com/millionco/react-doctor/commit/ce4925008d37d7c86a234e6b9c7c2c3afe873405)]:
+  - deslop-js@0.7.0
+  - oxlint-plugin-react-doctor@0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/core/package.json b/packages/core/package.json
index 48fd9b7bf8..c62b31dbad 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/core",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "private": true,
   "description": "Diagnostic engine for React Doctor.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/deslop-cli/CHANGELOG.md b/packages/deslop-cli/CHANGELOG.md
index 090aedcb65..b586d5358f 100644
--- a/packages/deslop-cli/CHANGELOG.md
+++ b/packages/deslop-cli/CHANGELOG.md
@@ -1,5 +1,12 @@
 # deslop-cli
 
+## 0.7.0
+
+### Patch Changes
+
+- Updated dependencies [[`ced746f`](https://github.com/millionco/react-doctor/commit/ced746f518f11e8283d488c4ff31c44e478bb0e5), [`20d81f6`](https://github.com/millionco/react-doctor/commit/20d81f6f26dc8f0562118076f835da2468591d5f), [`ce49250`](https://github.com/millionco/react-doctor/commit/ce4925008d37d7c86a234e6b9c7c2c3afe873405)]:
+  - deslop-js@0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/deslop-cli/package.json b/packages/deslop-cli/package.json
index 87496cb5b1..5a10df0077 100644
--- a/packages/deslop-cli/package.json
+++ b/packages/deslop-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deslop-cli",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "CLI to remove AI slop from JavaScript codebases.",
   "keywords": [
     "cli",
diff --git a/packages/deslop-js/CHANGELOG.md b/packages/deslop-js/CHANGELOG.md
index ee3b53c6fd..236d6a0415 100644
--- a/packages/deslop-js/CHANGELOG.md
+++ b/packages/deslop-js/CHANGELOG.md
@@ -1,5 +1,19 @@
 # deslop-js
 
+## 0.7.0
+
+### Minor Changes
+
+- [#1057](https://github.com/millionco/react-doctor/pull/1057) [`ce49250`](https://github.com/millionco/react-doctor/commit/ce4925008d37d7c86a234e6b9c7c2c3afe873405) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Dead-code analysis is now incremental across scans. deslop-js gains an opt-in `incrementalCachePath` config field: one stat walk per run (following directory symlinks, like the glob scans it stands in for) validates four independently keyed layers — per-file parse summaries (mtime+size), the collected file list, the module-resolution map (dropped whenever the file set or a bundler/tsconfig-like config changes, since resolution is file-set-dependent), and the per-file package-reference facts behind the unused-dependency content scans. The same walk also answers the stale-package file-discovery globs (config/docs/rescue/package.json/nx/tsconfig scans, verified byte-identical against fast-glob), so a cached run never re-walks the tree for them. Entry resolution deliberately stays live every run (it reads config/doc/sibling-source content no fingerprint can validate); on cached runs it moves to a dedicated worker thread so its filesystem work overlaps the main-thread analysis instead of serializing after it. Every layer fails open — corrupt, truncated, or version/config-mismatched stores degrade to a fresh computation, never a wrong result — writes are atomic and skipped when clean, and results are byte-identical to an uncached run. Unused-export detection also indexes re-export edges by source module, dropping an O(entry points × edges) scan that dominated the detector on large repos.
+
+  react-doctor points the analysis worker at a per-project summary store next to the existing whole-result dead-code cache, so a changed-files rescan of a large repo re-parses only what changed (sentry, 9k files: ~8.0s → ~3.2s with 0-10 files edited; ~4.0s after adding a file; the cache-fill run costs the same as an uncached scan). The worker also stops running the discarded DRY-pattern redundancy detectors (`reportRedundancy: false`), which shrinks the summary store by dropping fields only those detectors read, and reports the cache outcome as `deadCode.summaryCacheHits` / `deadCode.summaryCacheMisses` in anonymized telemetry (absent whenever no analysis consulted the store). `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
+
+### Patch Changes
+
+- [#1060](https://github.com/millionco/react-doctor/pull/1060) [`ced746f`](https://github.com/millionco/react-doctor/commit/ced746f518f11e8283d488c4ff31c44e478bb0e5) Thanks [@rayhanadev](https://github.com/rayhanadev)! - The whole cache stack now survives CI's fresh checkouts, so the GitHub Action's persisted `REACT_DOCTOR_CACHE_DIR` actually warms every layer instead of only the content-addressed ones. The whole-repo scan-result cache moves under the shared per-project cache root (honoring `REACT_DOCTOR_CACHE_DIR` like the lint, sidecar, dead-code, and supply-chain caches — previously it silently escaped the action's cache into `node_modules/.cache` or the OS temp dir), and its key drops every stat-based fingerprint that a re-clone rotates: config files and gitignored dotenv files are now content-hashed, and the toolchain is keyed by package versions (matching the lint ruleset hash) rather than install mtimes. The stat-fingerprinted dead-code caches gain mtime repair (the ninja/restat pattern): entries carry a content-hash witness, and a stat mismatch over identical bytes — every file after a fresh checkout — re-hashes once, accepts the entry, and persists the refreshed stat so the cost is paid once per checkout, not per run. This covers core's whole-project dead-code result cache (per-file `(mtime, size, hash)` records replacing the stats-in-key fingerprint) and deslop-js's incremental summary store (parse summaries, package-reference facts, and the manifest/bundler-config fingerprints feeding the collect/resolution hashes). Expired supply-chain score entries are also pruned past their TTL so restored cache directories stop accumulating dead purls. Everything stays fail-open and byte-identical to an uncached scan; on a re-cloned repo with one changed file, a warm scan now replays ~100% of lint, sidecar, and parse work instead of starting cold.
+
+- [#1056](https://github.com/millionco/react-doctor/pull/1056) [`20d81f6`](https://github.com/millionco/react-doctor/commit/20d81f6f26dc8f0562118076f835da2468591d5f) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Hardened the dead-code result cache key against two silent-staleness classes. The fingerprinted extension and manifest name lists are now imported from `deslop-js/analyzed-inputs` — a new dependency-free subpath export assembled from the same constants deslop's own readers consume — so a deslop upgrade that widens its walk can never under-invalidate the cache. And the key now includes `@react-doctor/core`'s own version, so upgrading react-doctor re-analyzes instead of replaying cached diagnostics shaped by an older core's post-processing. The cache schema-version constant remains for cache-format changes only.
+
 ## 0.6.3
 
 ## 0.6.2
diff --git a/packages/deslop-js/package.json b/packages/deslop-js/package.json
index 031ac61100..74cf86ef72 100644
--- a/packages/deslop-js/package.json
+++ b/packages/deslop-js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deslop-js",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Remove AI slop from JavaScript code.",
   "keywords": [
     "dead-code",
diff --git a/packages/eslint-plugin-react-doctor/CHANGELOG.md b/packages/eslint-plugin-react-doctor/CHANGELOG.md
index 79f7efc811..1edf0402b0 100644
--- a/packages/eslint-plugin-react-doctor/CHANGELOG.md
+++ b/packages/eslint-plugin-react-doctor/CHANGELOG.md
@@ -1,5 +1,12 @@
 # eslint-plugin-react-doctor
 
+## 0.7.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - oxlint-plugin-react-doctor@0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/eslint-plugin-react-doctor/package.json b/packages/eslint-plugin-react-doctor/package.json
index b3a3df3ade..d49a290493 100644
--- a/packages/eslint-plugin-react-doctor/package.json
+++ b/packages/eslint-plugin-react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-doctor",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "React Doctor rules for ESLint.",
   "keywords": [
     "accessibility",
diff --git a/packages/fuzz/CHANGELOG.md b/packages/fuzz/CHANGELOG.md
index aaadb05190..b345826db3 100644
--- a/packages/fuzz/CHANGELOG.md
+++ b/packages/fuzz/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/fuzz
 
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies []:
+  - oxlint-plugin-react-doctor@0.7.0
+
 ## 0.0.3
 
 ### Patch Changes
diff --git a/packages/fuzz/package.json b/packages/fuzz/package.json
index e3a75799e9..9219acfef6 100644
--- a/packages/fuzz/package.json
+++ b/packages/fuzz/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/fuzz",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "private": true,
   "description": "Adversarial fuzzing harness for React Doctor rules.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/language-server/CHANGELOG.md b/packages/language-server/CHANGELOG.md
index e457efd3fb..1722a4f6ad 100644
--- a/packages/language-server/CHANGELOG.md
+++ b/packages/language-server/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/language-server
 
+## 0.7.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @react-doctor/core@0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/language-server/package.json b/packages/language-server/package.json
index 3161b515ab..0701b6ac95 100644
--- a/packages/language-server/package.json
+++ b/packages/language-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/language-server",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "private": true,
   "description": "Language server for React Doctor editor integrations.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/oxlint-plugin-react-doctor/CHANGELOG.md b/packages/oxlint-plugin-react-doctor/CHANGELOG.md
index 9e2adc9b19..a1dbbd2b4f 100644
--- a/packages/oxlint-plugin-react-doctor/CHANGELOG.md
+++ b/packages/oxlint-plugin-react-doctor/CHANGELOG.md
@@ -1,5 +1,7 @@
 # oxlint-plugin-react-doctor
 
+## 0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/oxlint-plugin-react-doctor/package.json b/packages/oxlint-plugin-react-doctor/package.json
index 0438116480..65c3dba29d 100644
--- a/packages/oxlint-plugin-react-doctor/package.json
+++ b/packages/oxlint-plugin-react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",
diff --git a/packages/react-doctor/CHANGELOG.md b/packages/react-doctor/CHANGELOG.md
index 3f6fde87bc..bdec97c83d 100644
--- a/packages/react-doctor/CHANGELOG.md
+++ b/packages/react-doctor/CHANGELOG.md
@@ -1,5 +1,33 @@
 # react-doctor
 
+## 0.7.0
+
+### Patch Changes
+
+- [#1060](https://github.com/millionco/react-doctor/pull/1060) [`ced746f`](https://github.com/millionco/react-doctor/commit/ced746f518f11e8283d488c4ff31c44e478bb0e5) Thanks [@rayhanadev](https://github.com/rayhanadev)! - The whole cache stack now survives CI's fresh checkouts, so the GitHub Action's persisted `REACT_DOCTOR_CACHE_DIR` actually warms every layer instead of only the content-addressed ones. The whole-repo scan-result cache moves under the shared per-project cache root (honoring `REACT_DOCTOR_CACHE_DIR` like the lint, sidecar, dead-code, and supply-chain caches — previously it silently escaped the action's cache into `node_modules/.cache` or the OS temp dir), and its key drops every stat-based fingerprint that a re-clone rotates: config files and gitignored dotenv files are now content-hashed, and the toolchain is keyed by package versions (matching the lint ruleset hash) rather than install mtimes. The stat-fingerprinted dead-code caches gain mtime repair (the ninja/restat pattern): entries carry a content-hash witness, and a stat mismatch over identical bytes — every file after a fresh checkout — re-hashes once, accepts the entry, and persists the refreshed stat so the cost is paid once per checkout, not per run. This covers core's whole-project dead-code result cache (per-file `(mtime, size, hash)` records replacing the stats-in-key fingerprint) and deslop-js's incremental summary store (parse summaries, package-reference facts, and the manifest/bundler-config fingerprints feeding the collect/resolution hashes). Expired supply-chain score entries are also pruned past their TTL so restored cache directories stop accumulating dead purls. Everything stays fail-open and byte-identical to an uncached scan; on a re-cloned repo with one changed file, a warm scan now replays ~100% of lint, sidecar, and parse work instead of starting cold.
+
+- [#1056](https://github.com/millionco/react-doctor/pull/1056) [`20d81f6`](https://github.com/millionco/react-doctor/commit/20d81f6f26dc8f0562118076f835da2468591d5f) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Hardened the dead-code result cache key against two silent-staleness classes. The fingerprinted extension and manifest name lists are now imported from `deslop-js/analyzed-inputs` — a new dependency-free subpath export assembled from the same constants deslop's own readers consume — so a deslop upgrade that widens its walk can never under-invalidate the cache. And the key now includes `@react-doctor/core`'s own version, so upgrading react-doctor re-analyzes instead of replaying cached diagnostics shaped by an older core's post-processing. The cache schema-version constant remains for cache-format changes only.
+
+- [#1053](https://github.com/millionco/react-doctor/pull/1053) [`e257a5e`](https://github.com/millionco/react-doctor/commit/e257a5ed3fb17286a9f55dfec0772ab8a91574b1) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Rescans now skip the dead-code analysis entirely when nothing it reads has changed. The pass persists its diagnostics keyed by a fingerprint over the analyzed source tree (stat-based, so additions, deletions, and edits all invalidate), the project's manifests, tsconfigs, lockfiles, knip/entry/ignore configuration, and the analyzer version — on an unchanged-input rerun the stored result replays instead of re-walking the whole import graph, cutting several seconds off warm rescans of large repos. Only complete, successful passes are stored; `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
+
+- [#1057](https://github.com/millionco/react-doctor/pull/1057) [`ce49250`](https://github.com/millionco/react-doctor/commit/ce4925008d37d7c86a234e6b9c7c2c3afe873405) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Dead-code analysis is now incremental across scans. deslop-js gains an opt-in `incrementalCachePath` config field: one stat walk per run (following directory symlinks, like the glob scans it stands in for) validates four independently keyed layers — per-file parse summaries (mtime+size), the collected file list, the module-resolution map (dropped whenever the file set or a bundler/tsconfig-like config changes, since resolution is file-set-dependent), and the per-file package-reference facts behind the unused-dependency content scans. The same walk also answers the stale-package file-discovery globs (config/docs/rescue/package.json/nx/tsconfig scans, verified byte-identical against fast-glob), so a cached run never re-walks the tree for them. Entry resolution deliberately stays live every run (it reads config/doc/sibling-source content no fingerprint can validate); on cached runs it moves to a dedicated worker thread so its filesystem work overlaps the main-thread analysis instead of serializing after it. Every layer fails open — corrupt, truncated, or version/config-mismatched stores degrade to a fresh computation, never a wrong result — writes are atomic and skipped when clean, and results are byte-identical to an uncached run. Unused-export detection also indexes re-export edges by source module, dropping an O(entry points × edges) scan that dominated the detector on large repos.
+
+  react-doctor points the analysis worker at a per-project summary store next to the existing whole-result dead-code cache, so a changed-files rescan of a large repo re-parses only what changed (sentry, 9k files: ~8.0s → ~3.2s with 0-10 files edited; ~4.0s after adding a file; the cache-fill run costs the same as an uncached scan). The worker also stops running the discarded DRY-pattern redundancy detectors (`reportRedundancy: false`), which shrinks the summary store by dropping fields only those detectors read, and reports the cache outcome as `deadCode.summaryCacheHits` / `deadCode.summaryCacheMisses` in anonymized telemetry (absent whenever no analysis consulted the store). `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_DEAD_CODE_CACHE`) disables it.
+
+- [#1054](https://github.com/millionco/react-doctor/pull/1054) [`8c004f0`](https://github.com/millionco/react-doctor/commit/8c004f07fa69fdbed5f2f2ad19cfabfbf9d670e3) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Instant reruns now also work with uncommitted changes: the whole-repo scan-result cache no longer requires a clean worktree — it keys on the exact dirty state (every modified, staged, renamed, deleted, and untracked path plus a hash of its content), so rescanning the same work-in-progress tree hits the cache while any edit still invalidates it.
+
+- [#1052](https://github.com/millionco/react-doctor/pull/1052) [`1571119`](https://github.com/millionco/react-doctor/commit/157111917d2e4d4834c70cfdd18ed7858f33b632) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Restore instant reruns on large repos: raise `runGit`'s output cap so the whole-repo scan-result cache works past ~15k tracked files.
+
+  The cache's clean-worktree gates shell out to git through a helper that used Node's default 1 MiB `maxBuffer`. On repos with roughly 15-25k tracked files (getsentry/sentry: 20,343), `git ls-files -v` alone exceeds that, `execFileSync` throws ENOBUFS, the helper swallows it into `null`, and the gates read `null` as "hidden tracked state" — so the cache silently never stored or served a scan on exactly the repos where the instant-rerun path saves the most time. The helper now runs with an explicit 64 MiB cap, which clears monorepos with hundreds of thousands of files while still bounding a pathological child process.
+
+- [#1058](https://github.com/millionco/react-doctor/pull/1058) [`ea9a775`](https://github.com/millionco/react-doctor/commit/ea9a77511760635f09022d48b29fefb5602c07e8) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Warm rescans now skip the cross-file lint sidecar for files whose dependencies are unchanged. Previously the per-file lint cache replayed most rules but re-linted EVERY file with the cross-file ruleset (`no-barrel-import`, the Next.js metadata/Suspense rules, `no-mutating-reducer-state`, the React Native text rules) on every scan, because a sibling edit can flip an unchanged file's verdict. Each file now carries a dependency fingerprint — the exact set of filesystem probes (resolved import targets, barrel chains, ancestor layouts, nearest package.json/tsconfig, and the negative resolution candidates that catch shadowing) its cross-file rules consulted — and the sidecar replays the stored diagnostics when every probe still answers the same, re-linting only files whose dependency set changed. Every entry fails open (corrupt store, unparseable file, partial lint → fresh re-lint), a cross-file rule without a registered dependency collector re-lints everywhere, and `REACT_DOCTOR_NO_CACHE` (or the granular `REACT_DOCTOR_NO_SIDECAR_CACHE`) disables it.
+
+- [#1059](https://github.com/millionco/react-doctor/pull/1059) [`bdf8074`](https://github.com/millionco/react-doctor/commit/bdf80748eb0d186456b30aee30dbe731c06293b3) Thanks [@rayhanadev](https://github.com/rayhanadev)! - Added cache-temperature telemetry to the per-scan Sentry wide event, so cache effectiveness is queryable at a glance instead of being inferred from per-subsystem dims. `cache.temperature` classifies every scan as `turbo` (whole-repo scan-result replay — now marked by an explicit `wholeRepoCacheHit` flag on the replay path, never inferred from absent dims), `warm` (any incremental reuse across the per-file lint, sidecar, or dead-code caches), `cold` (caches on, zero reuse), or `disabled` (the global `REACT_DOCTOR_NO_CACHE` off-switch). `cache.warmth` is the numeric headline magnitude in [0, 1] — the plain mean of the known subsystem reuse fractions, skipping subsystems that never consulted a cache. The existing per-subsystem dims (`lint.cacheHitRatio`, `lint.sidecarReplayRatio`, `deadCode.cacheHit`, `deadCode.summaryCacheHits/Misses`) are unchanged. Telemetry-only: no new counters, no JSON-report or cache-schema changes.
+
+- Updated dependencies [[`ced746f`](https://github.com/millionco/react-doctor/commit/ced746f518f11e8283d488c4ff31c44e478bb0e5), [`20d81f6`](https://github.com/millionco/react-doctor/commit/20d81f6f26dc8f0562118076f835da2468591d5f), [`ce49250`](https://github.com/millionco/react-doctor/commit/ce4925008d37d7c86a234e6b9c7c2c3afe873405)]:
+  - deslop-js@0.7.0
+  - oxlint-plugin-react-doctor@0.7.0
+
 ## 0.6.3
 
 ### Patch Changes
diff --git a/packages/react-doctor/package.json b/packages/react-doctor/package.json
index d296f33670..c5b48ebc9c 100644
--- a/packages/react-doctor/package.json
+++ b/packages/react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-doctor",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Your agent writes bad React. This catches it",
   "keywords": [
     "accessibility",

From 6b21b70d1acf50c23df170f3751479b2cb295909 Mon Sep 17 00:00:00 2001
From: "devin-ai-integration[bot]"
 <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 4 Jul 2026 01:42:13 -0700
Subject: [PATCH 25/33] feat(core): surface reactDetected so a gated-off scan
 can't pass for clean (#1062)

Co-authored-by: Aiden Bai <aiden.bai05@gmail.com>
---
 .changeset/react-detected-signal.md           |  9 ++
 packages/api/src/diagnose.ts                  | 11 ++-
 packages/api/src/index.ts                     |  2 +-
 packages/api/tests/diagnose.test.ts           | 42 +++++++++
 packages/core/src/build-json-report.ts        |  4 +
 packages/core/src/index.ts                    |  1 +
 .../core/src/runners/oxlint/capabilities.ts   |  3 +-
 packages/core/src/schemas.ts                  | 12 +++
 packages/core/src/types/diagnose.ts           | 18 ++++
 packages/core/src/types/inspect.ts            | 11 +++
 packages/core/src/utils/has-react-runtime.ts  | 10 ++
 packages/core/tests/build-json-report.test.ts | 93 +++++++++++++++++++
 .../react-doctor/src/cli/commands/inspect.ts  |  8 ++
 .../react-doctor/src/cli/utils/constants.ts   |  5 +
 packages/react-doctor/src/index.ts            |  1 +
 15 files changed, 225 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/react-detected-signal.md
 create mode 100644 packages/core/src/utils/has-react-runtime.ts

diff --git a/.changeset/react-detected-signal.md b/.changeset/react-detected-signal.md
new file mode 100644
index 0000000000..a8b7a3bb65
--- /dev/null
+++ b/.changeset/react-detected-signal.md
@@ -0,0 +1,9 @@
+---
+"react-doctor": patch
+---
+
+Surface when a scan target had no discoverable React project, so a gated-off run can't pass for a clean one.
+
+- The JSON report now carries `reactDetected: false` (additive optional field on schemaVersion 1 and 2) when no scanned project resolved a React or Preact runtime — the case where every React-runtime rule family gates off and the report would otherwise be byte-indistinguishable from a genuinely clean scan. It's `true` when any project resolved a runtime, and absent when nothing was scanned or the run errored. Consumers gating on the report (CI, verifiers, pre-commit hooks) should treat `reactDetected === false` as "wrong scan target", not "all clear"; per-project detail is already available via `projects[].project.reactVersion` / `preactVersion`.
+- The CLI prints a stderr warning in the same case: "No React project detected at <path> — React rules were gated off; this is not the same as a clean scan."
+- The programmatic API mirrors the signal: `diagnose()` results carry `reactDetected` (`DiagnoseResult.reactDetected`, per-project on `ProjectResultOk`, aggregate on `DiagnoseProjectsResult` — absent when no project scanned successfully), and the `hasReactRuntime(project)` predicate is exported from `react-doctor/api` and `@react-doctor/api`.
diff --git a/packages/api/src/diagnose.ts b/packages/api/src/diagnose.ts
index 757d121249..55ae8cf6cf 100644
--- a/packages/api/src/diagnose.ts
+++ b/packages/api/src/diagnose.ts
@@ -9,6 +9,7 @@ import {
   detectAiTrainingEnvironment,
   Files,
   Git,
+  hasReactRuntime,
   layerOtlp,
   Linter,
   LintPartialFailures,
@@ -125,6 +126,7 @@ const outputToDiagnoseResult = (
     skippedChecks,
     ...(Object.keys(skippedCheckReasons).length > 0 ? { skippedCheckReasons } : {}),
     project: output.project,
+    reactDetected: hasReactRuntime(output.project),
     elapsedMilliseconds,
   };
 };
@@ -236,12 +238,15 @@ const diagnoseProjectBatch = async (
     (projectDefinition) => diagnoseProject(projectDefinition, baseOptions, batchConfig),
   );
 
+  const succeededProjects = projectResults.filter((projectResult) => projectResult.ok);
+
   return {
     projects: projectResults,
-    diagnostics: projectResults.flatMap((projectResult) =>
-      projectResult.ok ? projectResult.diagnostics : [],
-    ),
+    diagnostics: succeededProjects.flatMap((projectResult) => projectResult.diagnostics),
     score: findWorstScore(projectResults),
+    ...(succeededProjects.length > 0
+      ? { reactDetected: succeededProjects.some((projectResult) => projectResult.reactDetected) }
+      : {}),
     elapsedMilliseconds: globalThis.performance.now() - startTime,
   };
 };
diff --git a/packages/api/src/index.ts b/packages/api/src/index.ts
index 3a5e2eed9e..06950f41c7 100644
--- a/packages/api/src/index.ts
+++ b/packages/api/src/index.ts
@@ -1,5 +1,5 @@
 export { diagnose } from "./diagnose.js";
-export { defineConfig } from "@react-doctor/core";
+export { defineConfig, hasReactRuntime } from "@react-doctor/core";
 
 export type {
   DiagnoseOptions,
diff --git a/packages/api/tests/diagnose.test.ts b/packages/api/tests/diagnose.test.ts
index 61d2d91938..2845772664 100644
--- a/packages/api/tests/diagnose.test.ts
+++ b/packages/api/tests/diagnose.test.ts
@@ -69,6 +69,32 @@ describe("diagnose", () => {
     }
   });
 
+  it("sets reactDetected true on a React project and false on a non-React one", async () => {
+    const reactResult = await diagnose(path.join(FIXTURES_DIRECTORY, "basic-react"), {
+      deadCode: false,
+      lint: false,
+    });
+    expect(reactResult.reactDetected).toBe(true);
+
+    const nonReactDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "rdc-nonreact-"));
+    fs.writeFileSync(
+      path.join(nonReactDirectory, "package.json"),
+      JSON.stringify({ name: "non-react-tool", dependencies: { lodash: "^4.0.0" } }),
+    );
+    fs.mkdirSync(path.join(nonReactDirectory, "src"));
+    fs.writeFileSync(
+      path.join(nonReactDirectory, "src", "index.ts"),
+      "export const add = (firstNumber: number, secondNumber: number): number => firstNumber + secondNumber;\n",
+    );
+    try {
+      const nonReactResult = await diagnose(nonReactDirectory, { deadCode: false, lint: false });
+      expect(nonReactResult.reactDetected).toBe(false);
+      expect(nonReactResult.project.reactVersion).toBeNull();
+    } finally {
+      fs.rmSync(nonReactDirectory, { recursive: true, force: true });
+    }
+  });
+
   it("elapsedMilliseconds is non-negative", async () => {
     const result = await diagnose(path.join(FIXTURES_DIRECTORY, "basic-react"), {
       deadCode: false,
@@ -201,9 +227,25 @@ describe("diagnose({ projects })", () => {
     expect(result.projects).toHaveLength(0);
     expect(result.diagnostics).toHaveLength(0);
     expect(result.score).toBeNull();
+    expect(result.reactDetected).toBeUndefined();
     expect(result.elapsedMilliseconds).toBeGreaterThanOrEqual(0);
   });
 
+  it("aggregates reactDetected across succeeded projects", async () => {
+    const result = await diagnose({
+      projects: [
+        { directory: path.join(FIXTURES_DIRECTORY, "basic-react") },
+        { directory: noReactTempDirectory },
+      ],
+      deadCode: false,
+      lint: false,
+    });
+
+    expect(result.reactDetected).toBe(true);
+    const succeeded = result.projects.find((projectResult) => projectResult.ok);
+    expect(succeeded?.ok && succeeded.reactDetected).toBe(true);
+  });
+
   it("clamps concurrency: 0 to 1 without hanging", async () => {
     const result = await diagnose({
       projects: [{ directory: path.join(FIXTURES_DIRECTORY, "basic-react") }],
diff --git a/packages/core/src/build-json-report.ts b/packages/core/src/build-json-report.ts
index fdf60ff117..786f314ef7 100644
--- a/packages/core/src/build-json-report.ts
+++ b/packages/core/src/build-json-report.ts
@@ -7,6 +7,7 @@ import type {
   InspectResult,
 } from "./types/index.js";
 import { summarizeDiagnostics } from "./summarize-diagnostics.js";
+import { hasReactRuntime } from "./utils/has-react-runtime.js";
 
 interface BuildJsonReportInput {
   version: string;
@@ -81,6 +82,9 @@ export const buildJsonReport = (input: BuildJsonReportInput): JsonReport => {
   );
 
   const shared = {
+    ...(input.scans.length > 0
+      ? { reactDetected: input.scans.some((scan) => hasReactRuntime(scan.result.project)) }
+      : {}),
     version: input.version,
     ok: true as const,
     directory: input.directory,
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 36df50c25f..e2d35b586d 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -89,6 +89,7 @@ export * from "./utils/detect-ai-training-environment.js";
 export * from "./utils/group-by.js";
 export * from "./utils/hash-file-contents.js";
 export * from "./utils/has-published-fix-recipe.js";
+export * from "./utils/has-react-runtime.js";
 export * from "./utils/is-errno-exception.js";
 export * from "./utils/is-large-minified-file.js";
 export * from "./utils/list-source-files.js";
diff --git a/packages/core/src/runners/oxlint/capabilities.ts b/packages/core/src/runners/oxlint/capabilities.ts
index 99c4d64929..e1a8837b76 100644
--- a/packages/core/src/runners/oxlint/capabilities.ts
+++ b/packages/core/src/runners/oxlint/capabilities.ts
@@ -5,6 +5,7 @@ import {
   LATEST_KNOWN_PREACT_MAJOR,
   LATEST_KNOWN_REACT_MAJOR,
 } from "../../constants.js";
+import { hasReactRuntime } from "../../utils/has-react-runtime.js";
 import {
   isReactAtLeast,
   isTailwindAtLeast,
@@ -25,7 +26,7 @@ export const buildCapabilities = (project: ProjectInfo): ReadonlySet<string> =>
   // React-family rules are equally applicable there. Framework-agnostic
   // rules (security, architecture, bundle-size, js-performance, zod, …)
   // never require this and keep running on non-React codebases.
-  if (project.reactVersion !== null || project.preactVersion !== null) {
+  if (hasReactRuntime(project)) {
     capabilities.add("react");
   }
   if (
diff --git a/packages/core/src/schemas.ts b/packages/core/src/schemas.ts
index f4d867d537..b0720f46be 100644
--- a/packages/core/src/schemas.ts
+++ b/packages/core/src/schemas.ts
@@ -120,6 +120,16 @@ export class JsonReportV1 extends Schema.Class<JsonReportV1>("JsonReportV1")({
    * successful `baseline` run (`schemaVersion: 2`) and on non-compare scopes.
    */
   baselineDegraded: Schema.optional(Schema.Boolean),
+  /**
+   * Whether any scanned project resolved a React-compatible runtime (React
+   * or Preact). `false` means every React-runtime rule family was gated off,
+   * so an empty `diagnostics` array is vacuous — NOT the same as a clean
+   * React scan. Consumers gating on the report (CI, verifiers, hooks) should
+   * treat `reactDetected === false` as "wrong scan target", not "all clear".
+   * Absent when nothing was scanned (`projects` is empty), on error reports,
+   * and on reports from older CLI versions.
+   */
+  reactDetected: Schema.optional(Schema.Boolean),
   diff: Schema.NullOr(JsonReportDiffInfo),
   projects: Schema.Array(JsonReportProjectEntry),
   diagnostics: Schema.Array(Diagnostic),
@@ -147,6 +157,8 @@ export class JsonReportV2 extends Schema.Class<JsonReportV2>("JsonReportV2")({
   ok: Schema.Boolean,
   directory: Schema.String,
   mode: JsonReportMode,
+  /** See `JsonReportV1.reactDetected`. */
+  reactDetected: Schema.optional(Schema.Boolean),
   diff: Schema.NullOr(JsonReportDiffInfo),
   baseline: JsonReportBaseline,
   projects: Schema.Array(JsonReportProjectEntry),
diff --git a/packages/core/src/types/diagnose.ts b/packages/core/src/types/diagnose.ts
index a2e4b3c685..98b9f9fd43 100644
--- a/packages/core/src/types/diagnose.ts
+++ b/packages/core/src/types/diagnose.ts
@@ -34,6 +34,17 @@ export interface DiagnoseResult {
   /** See `InspectResult.skippedCheckReasons`. */
   skippedCheckReasons?: Record<string, string>;
   project: ProjectInfo;
+  /**
+   * Whether the scanned project resolved a React-compatible runtime (React
+   * or Preact). `false` means every React-runtime rule family was gated
+   * off, so an empty `diagnostics` array is vacuous — NOT the same as a
+   * clean React scan. Consumers gating on the result should treat
+   * `reactDetected === false` as "wrong scan target", not "all clear".
+   * Mirrors `JsonReport.reactDetected`; same predicate as
+   * `hasReactRuntime(result.project)`. Always set by `diagnose()`;
+   * optional so hand-constructed results keep compiling.
+   */
+  reactDetected?: boolean;
   elapsedMilliseconds: number;
 }
 
@@ -89,5 +100,12 @@ export interface DiagnoseProjectsResult {
   projects: ProjectResult[];
   diagnostics: Diagnostic[];
   score: ScoreResult | null;
+  /**
+   * Whether any successfully scanned project resolved a React-compatible
+   * runtime (React or Preact). Absent when no project scanned successfully.
+   * See `DiagnoseResult.reactDetected` for gating guidance; per-project
+   * detail is on each `ProjectResultOk.reactDetected`.
+   */
+  reactDetected?: boolean;
   elapsedMilliseconds: number;
 }
diff --git a/packages/core/src/types/inspect.ts b/packages/core/src/types/inspect.ts
index 2fec8f51fd..35c2e3130c 100644
--- a/packages/core/src/types/inspect.ts
+++ b/packages/core/src/types/inspect.ts
@@ -338,6 +338,17 @@ export interface JsonReportV1 {
   ok: boolean;
   directory: string;
   mode: JsonReportMode;
+  /**
+   * Whether any scanned project resolved a React-compatible runtime (React
+   * or Preact). `false` means every React-runtime rule family was gated off,
+   * so an empty `diagnostics` array is vacuous — NOT the same as a clean
+   * React scan. Consumers gating on the report (CI, verifiers, hooks) should
+   * treat `reactDetected === false` as "wrong scan target", not "all clear"
+   * (per project, `projects[].project.reactVersion` / `preactVersion` say
+   * which roots were non-React). Absent when nothing was scanned (`projects`
+   * is empty), on error reports, and on reports from older CLI versions.
+   */
+  reactDetected?: boolean;
   diff: JsonReportDiffInfo | null;
   projects: JsonReportProjectEntry[];
   /**
diff --git a/packages/core/src/utils/has-react-runtime.ts b/packages/core/src/utils/has-react-runtime.ts
new file mode 100644
index 0000000000..e31bccd028
--- /dev/null
+++ b/packages/core/src/utils/has-react-runtime.ts
@@ -0,0 +1,10 @@
+import type { ProjectInfo } from "../types/index.js";
+
+/**
+ * Whether project discovery resolved a React-compatible runtime (React or
+ * Preact, which ships the same hooks + JSX model). This is the same
+ * predicate that grants the `react` capability, so `false` means every
+ * React-runtime rule family was gated off for the project.
+ */
+export const hasReactRuntime = (project: ProjectInfo): boolean =>
+  project.reactVersion !== null || project.preactVersion !== null;
diff --git a/packages/core/tests/build-json-report.test.ts b/packages/core/tests/build-json-report.test.ts
index dbcca34303..85b88ffd32 100644
--- a/packages/core/tests/build-json-report.test.ts
+++ b/packages/core/tests/build-json-report.test.ts
@@ -78,6 +78,99 @@ describe("buildJsonReport", () => {
     expect(report.baselineDegraded).toBe(true);
   });
 
+  it("marks reactDetected true on a scan that resolved a React runtime", () => {
+    const report = buildJsonReport({
+      version: "1.2.3",
+      directory: "/repo",
+      mode: "full",
+      diff: null,
+      scans: [{ directory: "/repo", result: result() }],
+      totalElapsedMilliseconds: 1200,
+    });
+    expect(report.reactDetected).toBe(true);
+  });
+
+  it("marks reactDetected false when no scanned project resolved React or Preact", () => {
+    const nonReactProject: ProjectInfo = {
+      ...projectInfo,
+      reactVersion: null,
+      reactMajorVersion: null,
+      preactVersion: null,
+      preactMajorVersion: null,
+      framework: "unknown",
+    };
+    const report = buildJsonReport({
+      version: "1.2.3",
+      directory: "/repo",
+      mode: "full",
+      diff: null,
+      scans: [
+        { directory: "/repo", result: result({ diagnostics: [], project: nonReactProject }) },
+      ],
+      totalElapsedMilliseconds: 1200,
+    });
+    expect(report.reactDetected).toBe(false);
+    expect(report.ok).toBe(true);
+    expect(report.diagnostics).toHaveLength(0);
+  });
+
+  it("marks reactDetected true in a workspace where only some roots are React", () => {
+    const nonReactProject: ProjectInfo = {
+      ...projectInfo,
+      rootDirectory: "/repo/packages/tooling",
+      reactVersion: null,
+      reactMajorVersion: null,
+      framework: "unknown",
+    };
+    const report = buildJsonReport({
+      version: "1.2.3",
+      directory: "/repo",
+      mode: "full",
+      diff: null,
+      scans: [
+        {
+          directory: "/repo/packages/tooling",
+          result: result({ diagnostics: [], project: nonReactProject }),
+        },
+        { directory: "/repo/packages/app", result: result() },
+      ],
+      totalElapsedMilliseconds: 1200,
+    });
+    expect(report.reactDetected).toBe(true);
+  });
+
+  it("marks reactDetected true when a Preact runtime satisfies the react capability", () => {
+    const preactProject: ProjectInfo = {
+      ...projectInfo,
+      reactVersion: null,
+      reactMajorVersion: null,
+      preactVersion: "10.19.2",
+      preactMajorVersion: 10,
+      framework: "vite",
+    };
+    const report = buildJsonReport({
+      version: "1.2.3",
+      directory: "/repo",
+      mode: "full",
+      diff: null,
+      scans: [{ directory: "/repo", result: result({ project: preactProject }) }],
+      totalElapsedMilliseconds: 1200,
+    });
+    expect(report.reactDetected).toBe(true);
+  });
+
+  it("omits reactDetected when nothing was scanned", () => {
+    const report = buildJsonReport({
+      version: "1.2.3",
+      directory: "/repo",
+      mode: "staged",
+      diff: null,
+      scans: [],
+      totalElapsedMilliseconds: 1200,
+    });
+    expect("reactDetected" in report).toBe(false);
+  });
+
   it("emits a v2 baseline report carrying the new/fixed delta and head score", () => {
     const report = buildJsonReport({
       version: "1.2.3",
diff --git a/packages/react-doctor/src/cli/commands/inspect.ts b/packages/react-doctor/src/cli/commands/inspect.ts
index 694a638e7f..645b42964b 100644
--- a/packages/react-doctor/src/cli/commands/inspect.ts
+++ b/packages/react-doctor/src/cli/commands/inspect.ts
@@ -8,6 +8,7 @@ import {
   DEFAULT_PROJECT_SCAN_CONCURRENCY,
   getChangedLineRanges,
   getDiffInfo,
+  hasReactRuntime,
   highlighter,
   mapWithConcurrency,
   mergeReactDoctorConfigs,
@@ -155,6 +156,13 @@ const finalizeScans = (input: FinalizeScansInput): void => {
     input.completedScans.every((scan) => scan.result.baselineDelta !== undefined);
   const baselineDegraded = input.baselineIntended && !baselineComputed;
   const mode: JsonReportMode = baselineDegraded ? "diff" : input.mode;
+  const isReactDetected = input.completedScans.some((scan) => hasReactRuntime(scan.result.project));
+  if (input.completedScans.length > 0 && !isReactDetected) {
+    recordCount(METRIC.scanNoReactDetected, 1);
+    logger.warn(
+      `No React project detected at ${input.resolvedDirectory} — React rules were gated off; this is not the same as a clean scan.`,
+    );
+  }
   const jsonCompletedScans = filterCompletedScansByCategories(
     input.completedScans,
     input.categoryFilters,
diff --git a/packages/react-doctor/src/cli/utils/constants.ts b/packages/react-doctor/src/cli/utils/constants.ts
index ea2960d5ed..b7f8578b62 100644
--- a/packages/react-doctor/src/cli/utils/constants.ts
+++ b/packages/react-doctor/src/cli/utils/constants.ts
@@ -184,6 +184,11 @@ export const METRIC = {
   scanScore: "scan.score",
   scanClean: "scan.clean",
   scanCheckSkipped: "scan.check_skipped",
+  // One count per completed scan where no project resolved a React /
+  // Preact runtime — the JSON report's `reactDetected: false` case. The
+  // kill metric for the vacuous-clean-scan signal: if it never fires,
+  // nobody points react-doctor at non-React targets and the surface can go.
+  scanNoReactDetected: "scan.no_react_detected",
   baselineDegraded: "baseline.degraded",
   ruleFired: "rule.fired",
   // Rule-rejection telemetry, both keyed by `rule` + `source` attributes:
diff --git a/packages/react-doctor/src/index.ts b/packages/react-doctor/src/index.ts
index 85230854b6..8a4b205c0f 100644
--- a/packages/react-doctor/src/index.ts
+++ b/packages/react-doctor/src/index.ts
@@ -57,6 +57,7 @@ export {
   filterSourceFiles,
   summarizeDiagnostics,
   defineConfig,
+  hasReactRuntime,
 } from "@react-doctor/core";
 export { buildJsonReport, buildJsonReportError };
 // `ReactDoctorError` is the tagged Schema class from

From c0c3fc170972876c8bbc2419b32e66b9c864df85 Mon Sep 17 00:00:00 2001
From: "devin-ai-integration[bot]"
 <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 4 Jul 2026 02:05:05 -0700
Subject: [PATCH 26/33] =?UTF-8?q?fix(core):=20CI-gate=20FP=20=E2=80=94=20m?=
 =?UTF-8?q?atch=20structural=20findings=20by=20occurrence=20in=20computeDi?=
 =?UTF-8?q?agnosticDelta=20(#1061)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Aiden Bai <aiden.bai05@gmail.com>
---
 .changeset/hungry-shirts-repair.md            |  6 ++
 packages/core/src/compute-diagnostic-delta.ts | 16 +++-
 packages/core/src/constants.ts                |  9 ++
 .../core/src/runners/oxlint/parse-output.ts   | 17 +++-
 packages/core/src/schemas.ts                  |  1 +
 packages/core/src/types/diagnostic.ts         | 11 +++
 .../tests/compute-diagnostic-delta.test.ts    | 82 +++++++++++++++++++
 .../react-builtins/iframe-missing-sandbox.ts  |  1 +
 .../src/plugin/utils/rule.ts                  | 11 +++
 9 files changed, 151 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/hungry-shirts-repair.md

diff --git a/.changeset/hungry-shirts-repair.md b/.changeset/hungry-shirts-repair.md
new file mode 100644
index 0000000000..76c24cbebe
--- /dev/null
+++ b/.changeset/hungry-shirts-repair.md
@@ -0,0 +1,6 @@
+---
+"@react-doctor/core": patch
+"oxlint-plugin-react-doctor": patch
+---
+
+Fix a CI-gate false positive in the baseline delta: pre-existing element-level findings (Accessibility-category rules, plus rules flagged `matchByOccurrence` like `iframe-missing-sandbox`) are now matched by `(file, rule)` occurrence count instead of the flagged line's text, so reformatting the flagged line (reindentation, prettier reflow, collapsing a multi-line JSX element) no longer reports the finding as newly introduced. The flag is resolved at diagnostic creation and carried on the diagnostic as an optional `matchByOccurrence` field (also present in the JSON report). Expression-level rules keep line-text-sensitive matching, and a genuinely new extra occurrence still surfaces.
diff --git a/packages/core/src/compute-diagnostic-delta.ts b/packages/core/src/compute-diagnostic-delta.ts
index a341875c74..a471002a7d 100644
--- a/packages/core/src/compute-diagnostic-delta.ts
+++ b/packages/core/src/compute-diagnostic-delta.ts
@@ -25,7 +25,10 @@ export interface ComputeDiagnosticDeltaInput {
 
 const fingerprintDiagnostic = (diagnostic: Diagnostic, lineText: string | null): string => {
   const ruleKey = `${diagnostic.plugin}/${diagnostic.rule}`;
-  const snippet = lineText === null ? "" : createHash("sha1").update(lineText.trim()).digest("hex");
+  const snippet =
+    lineText === null || diagnostic.matchByOccurrence
+      ? ""
+      : createHash("sha1").update(lineText.trim()).digest("hex");
   return `${diagnostic.filePath}\u0000${ruleKey}\u0000${snippet}`;
 };
 
@@ -37,6 +40,17 @@ const fingerprintDiagnostic = (diagnostic: Diagnostic, lineText: string | null):
  * look new, while a genuinely new occurrence (new line text, or one more of
  * the same) surfaces. Identical repeated findings are matched by count.
  *
+ * Diagnostics carrying `matchByOccurrence` (resolved at diagnostic creation:
+ * every Accessibility-category finding, plus rules opting in via their
+ * `matchByOccurrence` metadata flag) drop the line-text snippet and match by
+ * `(filePath, plugin/rule)` occurrence count alone. Their identity is the
+ * flagged element, not the line's text, so editing the line (reindentation,
+ * prettier reflow, collapsing a multi-line JSX element) doesn't reclassify a
+ * pre-existing finding as new — while one MORE occurrence of the same rule in
+ * the file still surfaces. Expression-level rules keep the line-text snippet:
+ * there the flagged expression IS the finding, so changed text means new +
+ * fixed.
+ *
  * v1 limitation: the fingerprint keys on the head-relative `filePath`, and base
  * content is read at that same path. A file renamed by the change therefore has
  * no base match, so its pre-existing findings are reported as new. This
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index fd4c461672..81389263d1 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -458,6 +458,15 @@ export const DIAGNOSTIC_CATEGORY_BUCKETS = [
   "Maintainability",
 ] as const;
 
+// Categories whose findings are matched by occurrence in the CI baseline
+// delta — the finding's identity is the flagged element (a missing
+// attribute, a wrong element), not the flagged line's text — so the delta
+// matches them by `(file, rule)` occurrence count instead of a line-text
+// hash. Every Accessibility rule is element-level; rules in other
+// categories opt in individually via their per-rule `matchByOccurrence`
+// flag (see `resolveMatchByOccurrence` in `runners/oxlint/parse-output`).
+export const OCCURRENCE_MATCHED_CATEGORIES: ReadonlySet<string> = new Set(["Accessibility"]);
+
 // Rules whose heuristic only makes sense in application code. A published
 // library deliberately exposes flexible primitives (components built in
 // render to capture closures, many `render*` slots for composition), so these
diff --git a/packages/core/src/runners/oxlint/parse-output.ts b/packages/core/src/runners/oxlint/parse-output.ts
index c6b21a3aa2..a3db7b8373 100644
--- a/packages/core/src/runners/oxlint/parse-output.ts
+++ b/packages/core/src/runners/oxlint/parse-output.ts
@@ -7,7 +7,7 @@ import type {
   OxlintOutput,
   ProjectInfo,
 } from "../../types/index.js";
-import { ERROR_PREVIEW_LENGTH_CHARS } from "../../constants.js";
+import { ERROR_PREVIEW_LENGTH_CHARS, OCCURRENCE_MATCHED_CATEGORIES } from "../../constants.js";
 import { isLintableSourceFile } from "../../utils/is-lintable-source-file.js";
 import { isMinifiedSource } from "../../utils/is-minified-source.js";
 import { OxlintOutputUnparseable, ReactDoctorError } from "../../errors.js";
@@ -201,6 +201,17 @@ const parseRuleCode = (code: string): { plugin: string; rule: string } => {
 const resolveDiagnosticCategory = (plugin: string, rule: string): string =>
   getRuleCategory(rule) ?? lookupOwnString(PLUGIN_CATEGORY_MAP, plugin) ?? "Bugs";
 
+// Whether the finding's identity is the flagged element rather than the
+// flagged line's text, so `computeDiagnosticDelta` matches it by
+// `(file, rule)` occurrence count. Resolved here — the one place that
+// already consults rule metadata — so the delta stays a pure function of
+// its `Diagnostic` inputs. Every Accessibility-category finding qualifies
+// (element-level by nature, including adopted third-party a11y rules);
+// rules in other categories opt in via their `matchByOccurrence` flag.
+const resolveMatchByOccurrence = (rule: string, category: string): boolean =>
+  OCCURRENCE_MATCHED_CATEGORIES.has(category) ||
+  Boolean(reactDoctorPlugin.rules[rule]?.matchByOccurrence);
+
 /**
  * Maps oxlint's non-primary labels (`labels[1..]`) into related source
  * locations. Editors surface these as a diagnostic's
@@ -328,6 +339,7 @@ export const parseOxlintOutput = (
       // for everything else; offset / length are additive.
       const primarySpan = primaryLabel?.span;
       const relatedLocations = buildRelatedLocations(diagnostic.labels, normalizedFilePath);
+      const category = resolveDiagnosticCategory(plugin, rule);
       return {
         filePath: normalizedFilePath,
         plugin,
@@ -340,7 +352,8 @@ export const parseOxlintOutput = (
         line: primarySpan?.line ?? 0,
         column: primarySpan?.column ?? 0,
         ...(primarySpan ? { offset: primarySpan.offset, length: primarySpan.length } : {}),
-        category: resolveDiagnosticCategory(plugin, rule),
+        category,
+        ...(resolveMatchByOccurrence(rule, category) ? { matchByOccurrence: true } : {}),
         ...(relatedLocations.length > 0 ? { relatedLocations } : {}),
       };
     });
diff --git a/packages/core/src/schemas.ts b/packages/core/src/schemas.ts
index b0720f46be..1c49e81b0a 100644
--- a/packages/core/src/schemas.ts
+++ b/packages/core/src/schemas.ts
@@ -32,6 +32,7 @@ export class Diagnostic extends Schema.Class<Diagnostic>("Diagnostic")({
   endLine: Schema.optional(Schema.Number),
   endColumn: Schema.optional(Schema.Number),
   category: Schema.String,
+  matchByOccurrence: Schema.optional(Schema.Boolean),
   fileContext: Schema.optional(Schema.Literals(["test", "story"])),
   suppressionHint: Schema.optional(Schema.String),
   relatedLocations: Schema.optional(Schema.Array(DiagnosticRelatedLocation)),
diff --git a/packages/core/src/types/diagnostic.ts b/packages/core/src/types/diagnostic.ts
index 3108ca0aa8..2e8b6d26bf 100644
--- a/packages/core/src/types/diagnostic.ts
+++ b/packages/core/src/types/diagnostic.ts
@@ -79,6 +79,17 @@ export interface Diagnostic {
   /** 1-indexed end column of the primary span, when derivable. */
   endColumn?: number;
   category: string;
+  /**
+   * Set when the finding's identity is the flagged element itself (a missing
+   * attribute, a wrong element) rather than the flagged line's text — every
+   * Accessibility-category finding, plus rules that opt in via their
+   * `matchByOccurrence` metadata flag. `computeDiagnosticDelta` matches these
+   * by `(filePath, plugin/rule)` occurrence count, so reformatting the flagged
+   * line doesn't reclassify a pre-existing finding as new. Resolved at
+   * diagnostic creation, where rule metadata is available. Absent means
+   * line-text-sensitive matching (the default).
+   */
+  matchByOccurrence?: boolean;
   /**
    * Set when the file never ships to users (`"test"` / `"story"`), so
    * renderers can label the site instead of implying production impact.
diff --git a/packages/core/tests/compute-diagnostic-delta.test.ts b/packages/core/tests/compute-diagnostic-delta.test.ts
index ac7a1fbee8..9bf1ba460a 100644
--- a/packages/core/tests/compute-diagnostic-delta.test.ts
+++ b/packages/core/tests/compute-diagnostic-delta.test.ts
@@ -91,6 +91,88 @@ describe("computeDiagnosticDelta", () => {
     expect(delta.fixedCount).toBe(1);
   });
 
+  it("matches a pre-existing occurrence-matched finding whose flagged line was reformatted", () => {
+    const base = [
+      makeDiagnostic({
+        plugin: "react-doctor",
+        rule: "iframe-has-title",
+        category: "Accessibility",
+        matchByOccurrence: true,
+        line: 10,
+      }),
+    ];
+    const head = [
+      makeDiagnostic({
+        plugin: "react-doctor",
+        rule: "iframe-has-title",
+        category: "Accessibility",
+        matchByOccurrence: true,
+        line: 12,
+      }),
+    ];
+    const delta = computeDiagnosticDelta({
+      headDiagnostics: head,
+      baseDiagnostics: base,
+      // Prettier reflowed the multi-line <iframe> onto one line; the iframe
+      // still lacks a title, so the finding is pre-existing, not new.
+      readHeadLine: lineReaderFrom({ "src/App.tsx:12": '<iframe src={url} className="embed" />' }),
+      readBaseLine: lineReaderFrom({ "src/App.tsx:10": "<iframe" }),
+    });
+    expect(delta.newDiagnostics).toHaveLength(0);
+    expect(delta.fixedCount).toBe(0);
+  });
+
+  it("matches a non-Accessibility rule carrying matchByOccurrence even when the line text changed", () => {
+    const base = [
+      makeDiagnostic({
+        plugin: "react-doctor",
+        rule: "iframe-missing-sandbox",
+        category: "Security",
+        matchByOccurrence: true,
+        line: 10,
+      }),
+    ];
+    const head = [
+      makeDiagnostic({
+        plugin: "react-doctor",
+        rule: "iframe-missing-sandbox",
+        category: "Security",
+        matchByOccurrence: true,
+        line: 10,
+      }),
+    ];
+    const delta = computeDiagnosticDelta({
+      headDiagnostics: head,
+      baseDiagnostics: base,
+      readHeadLine: lineReaderFrom({ "src/App.tsx:10": '<iframe src={url} title="Embed" />' }),
+      readBaseLine: lineReaderFrom({ "src/App.tsx:10": "<iframe src={url} />" }),
+    });
+    expect(delta.newDiagnostics).toHaveLength(0);
+    expect(delta.fixedCount).toBe(0);
+  });
+
+  it("still surfaces a genuinely new extra occurrence of an occurrence-matched finding", () => {
+    const occurrenceMatched = (line: number): Diagnostic =>
+      makeDiagnostic({
+        plugin: "react-doctor",
+        rule: "iframe-has-title",
+        category: "Accessibility",
+        matchByOccurrence: true,
+        line,
+      });
+    const delta = computeDiagnosticDelta({
+      headDiagnostics: [occurrenceMatched(10), occurrenceMatched(42)],
+      baseDiagnostics: [occurrenceMatched(10)],
+      readHeadLine: lineReaderFrom({
+        "src/App.tsx:10": "<iframe src={a} />",
+        "src/App.tsx:42": "<iframe src={b} />",
+      }),
+      readBaseLine: lineReaderFrom({ "src/App.tsx:10": "<iframe src={a} />" }),
+    });
+    expect(delta.newDiagnostics).toHaveLength(1);
+    expect(delta.fixedCount).toBe(0);
+  });
+
   it("falls back to (file, rule) order matching when line text is unreadable", () => {
     const base = [makeDiagnostic({ line: 10 })];
     const head = [makeDiagnostic({ line: 99 })];
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/iframe-missing-sandbox.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/iframe-missing-sandbox.ts
index 5699975367..a35b388de1 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/iframe-missing-sandbox.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/iframe-missing-sandbox.ts
@@ -77,6 +77,7 @@ export const iframeMissingSandbox = defineRule({
   recommendation:
     'Add `sandbox=""` or a curated value so embedded pages cannot get full access to your site by default.',
   category: "Security",
+  matchByOccurrence: true,
   create: skipNonProductionFiles((context) => ({
     JSXOpeningElement(node: EsTreeNodeOfType<"JSXOpeningElement">) {
       if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "iframe") return;
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/rule.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/rule.ts
index 97e6869830..bd5cf0f79f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/utils/rule.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/rule.ts
@@ -59,6 +59,17 @@ export interface Rule {
   // `--ignore-tag` / `shouldEnableRule` to opt families of rules in
   // or out of a scan independently of the framework gate.
   tags?: ReadonlyArray<string>;
+  // When `true`, a finding's identity is the flagged element itself (a
+  // missing attribute, a wrong element) rather than the flagged line's
+  // text, so reformatting the line doesn't change the finding. The CI
+  // baseline delta (`computeDiagnosticDelta` in @react-doctor/core)
+  // then matches these by `(file, rule)` occurrence count instead of a
+  // line-text hash. Rules in the `Accessibility` category get this
+  // behavior implicitly; set the flag only on element-level rules
+  // outside that category. Leave unset for expression-level rules, where
+  // the flagged expression IS the finding and a text change means a new
+  // one.
+  matchByOccurrence?: boolean;
   // When `false`, the rule is registered in the plugin (importable,
   // configurable, testable) but NOT enabled by default — users must
   // opt in via `severityControls.rules["react-doctor/<id>"]`. Used for

From 160f84c6ccaf36312ef44a585547bb32b72c2aa6 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 4 Jul 2026 02:07:38 -0700
Subject: [PATCH 27/33] chore: version packages (#1063)

---
 .changeset/hungry-shirts-repair.md               |  6 ------
 .changeset/react-detected-signal.md              |  9 ---------
 packages/api/CHANGELOG.md                        |  7 +++++++
 packages/api/package.json                        |  2 +-
 packages/core/CHANGELOG.md                       | 10 ++++++++++
 packages/core/package.json                       |  2 +-
 packages/deslop-cli/CHANGELOG.md                 |  7 +++++++
 packages/deslop-cli/package.json                 |  2 +-
 packages/deslop-js/CHANGELOG.md                  |  2 ++
 packages/deslop-js/package.json                  |  2 +-
 packages/eslint-plugin-react-doctor/CHANGELOG.md |  7 +++++++
 packages/eslint-plugin-react-doctor/package.json |  2 +-
 packages/fuzz/CHANGELOG.md                       |  7 +++++++
 packages/fuzz/package.json                       |  2 +-
 packages/language-server/CHANGELOG.md            |  7 +++++++
 packages/language-server/package.json            |  2 +-
 packages/oxlint-plugin-react-doctor/CHANGELOG.md |  6 ++++++
 packages/oxlint-plugin-react-doctor/package.json |  2 +-
 packages/react-doctor/CHANGELOG.md               | 14 ++++++++++++++
 packages/react-doctor/package.json               |  2 +-
 20 files changed, 76 insertions(+), 24 deletions(-)
 delete mode 100644 .changeset/hungry-shirts-repair.md
 delete mode 100644 .changeset/react-detected-signal.md

diff --git a/.changeset/hungry-shirts-repair.md b/.changeset/hungry-shirts-repair.md
deleted file mode 100644
index 76c24cbebe..0000000000
--- a/.changeset/hungry-shirts-repair.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"@react-doctor/core": patch
-"oxlint-plugin-react-doctor": patch
----
-
-Fix a CI-gate false positive in the baseline delta: pre-existing element-level findings (Accessibility-category rules, plus rules flagged `matchByOccurrence` like `iframe-missing-sandbox`) are now matched by `(file, rule)` occurrence count instead of the flagged line's text, so reformatting the flagged line (reindentation, prettier reflow, collapsing a multi-line JSX element) no longer reports the finding as newly introduced. The flag is resolved at diagnostic creation and carried on the diagnostic as an optional `matchByOccurrence` field (also present in the JSON report). Expression-level rules keep line-text-sensitive matching, and a genuinely new extra occurrence still surfaces.
diff --git a/.changeset/react-detected-signal.md b/.changeset/react-detected-signal.md
deleted file mode 100644
index a8b7a3bb65..0000000000
--- a/.changeset/react-detected-signal.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-"react-doctor": patch
----
-
-Surface when a scan target had no discoverable React project, so a gated-off run can't pass for a clean one.
-
-- The JSON report now carries `reactDetected: false` (additive optional field on schemaVersion 1 and 2) when no scanned project resolved a React or Preact runtime — the case where every React-runtime rule family gates off and the report would otherwise be byte-indistinguishable from a genuinely clean scan. It's `true` when any project resolved a runtime, and absent when nothing was scanned or the run errored. Consumers gating on the report (CI, verifiers, pre-commit hooks) should treat `reactDetected === false` as "wrong scan target", not "all clear"; per-project detail is already available via `projects[].project.reactVersion` / `preactVersion`.
-- The CLI prints a stderr warning in the same case: "No React project detected at <path> — React rules were gated off; this is not the same as a clean scan."
-- The programmatic API mirrors the signal: `diagnose()` results carry `reactDetected` (`DiagnoseResult.reactDetected`, per-project on `ProjectResultOk`, aggregate on `DiagnoseProjectsResult` — absent when no project scanned successfully), and the `hasReactRuntime(project)` predicate is exported from `react-doctor/api` and `@react-doctor/api`.
diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md
index 345b727cd8..353bd93913 100644
--- a/packages/api/CHANGELOG.md
+++ b/packages/api/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/api
 
+## 0.7.1
+
+### Patch Changes
+
+- Updated dependencies [[`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85)]:
+  - @react-doctor/core@0.7.1
+
 ## 0.7.0
 
 ### Patch Changes
diff --git a/packages/api/package.json b/packages/api/package.json
index 05e7a16e61..9a7c785940 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/api",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "private": true,
   "description": "Programmatic API for React Doctor.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index 496a6200b1..7cddc6d721 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -1,5 +1,15 @@
 # @react-doctor/core
 
+## 0.7.1
+
+### Patch Changes
+
+- [#1061](https://github.com/millionco/react-doctor/pull/1061) [`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - Fix a CI-gate false positive in the baseline delta: pre-existing element-level findings (Accessibility-category rules, plus rules flagged `matchByOccurrence` like `iframe-missing-sandbox`) are now matched by `(file, rule)` occurrence count instead of the flagged line's text, so reformatting the flagged line (reindentation, prettier reflow, collapsing a multi-line JSX element) no longer reports the finding as newly introduced. The flag is resolved at diagnostic creation and carried on the diagnostic as an optional `matchByOccurrence` field (also present in the JSON report). Expression-level rules keep line-text-sensitive matching, and a genuinely new extra occurrence still surfaces.
+
+- Updated dependencies [[`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85)]:
+  - oxlint-plugin-react-doctor@0.7.1
+  - deslop-js@0.7.1
+
 ## 0.7.0
 
 ### Patch Changes
diff --git a/packages/core/package.json b/packages/core/package.json
index c62b31dbad..b5374a2752 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/core",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "private": true,
   "description": "Diagnostic engine for React Doctor.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/deslop-cli/CHANGELOG.md b/packages/deslop-cli/CHANGELOG.md
index b586d5358f..baf03f8711 100644
--- a/packages/deslop-cli/CHANGELOG.md
+++ b/packages/deslop-cli/CHANGELOG.md
@@ -1,5 +1,12 @@
 # deslop-cli
 
+## 0.7.1
+
+### Patch Changes
+
+- Updated dependencies []:
+  - deslop-js@0.7.1
+
 ## 0.7.0
 
 ### Patch Changes
diff --git a/packages/deslop-cli/package.json b/packages/deslop-cli/package.json
index 5a10df0077..34508ddc80 100644
--- a/packages/deslop-cli/package.json
+++ b/packages/deslop-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deslop-cli",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "CLI to remove AI slop from JavaScript codebases.",
   "keywords": [
     "cli",
diff --git a/packages/deslop-js/CHANGELOG.md b/packages/deslop-js/CHANGELOG.md
index 236d6a0415..ac7c23446b 100644
--- a/packages/deslop-js/CHANGELOG.md
+++ b/packages/deslop-js/CHANGELOG.md
@@ -1,5 +1,7 @@
 # deslop-js
 
+## 0.7.1
+
 ## 0.7.0
 
 ### Minor Changes
diff --git a/packages/deslop-js/package.json b/packages/deslop-js/package.json
index 74cf86ef72..1075e97d9e 100644
--- a/packages/deslop-js/package.json
+++ b/packages/deslop-js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deslop-js",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Remove AI slop from JavaScript code.",
   "keywords": [
     "dead-code",
diff --git a/packages/eslint-plugin-react-doctor/CHANGELOG.md b/packages/eslint-plugin-react-doctor/CHANGELOG.md
index 1edf0402b0..3f4684ddab 100644
--- a/packages/eslint-plugin-react-doctor/CHANGELOG.md
+++ b/packages/eslint-plugin-react-doctor/CHANGELOG.md
@@ -1,5 +1,12 @@
 # eslint-plugin-react-doctor
 
+## 0.7.1
+
+### Patch Changes
+
+- Updated dependencies [[`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85)]:
+  - oxlint-plugin-react-doctor@0.7.1
+
 ## 0.7.0
 
 ### Patch Changes
diff --git a/packages/eslint-plugin-react-doctor/package.json b/packages/eslint-plugin-react-doctor/package.json
index d49a290493..292f82e989 100644
--- a/packages/eslint-plugin-react-doctor/package.json
+++ b/packages/eslint-plugin-react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-doctor",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "React Doctor rules for ESLint.",
   "keywords": [
     "accessibility",
diff --git a/packages/fuzz/CHANGELOG.md b/packages/fuzz/CHANGELOG.md
index b345826db3..76859b0928 100644
--- a/packages/fuzz/CHANGELOG.md
+++ b/packages/fuzz/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/fuzz
 
+## 0.0.5
+
+### Patch Changes
+
+- Updated dependencies [[`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85)]:
+  - oxlint-plugin-react-doctor@0.7.1
+
 ## 0.0.4
 
 ### Patch Changes
diff --git a/packages/fuzz/package.json b/packages/fuzz/package.json
index 9219acfef6..86686acfac 100644
--- a/packages/fuzz/package.json
+++ b/packages/fuzz/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/fuzz",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "private": true,
   "description": "Adversarial fuzzing harness for React Doctor rules.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/language-server/CHANGELOG.md b/packages/language-server/CHANGELOG.md
index 1722a4f6ad..fb25bc00d2 100644
--- a/packages/language-server/CHANGELOG.md
+++ b/packages/language-server/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @react-doctor/language-server
 
+## 0.7.1
+
+### Patch Changes
+
+- Updated dependencies [[`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85)]:
+  - @react-doctor/core@0.7.1
+
 ## 0.7.0
 
 ### Patch Changes
diff --git a/packages/language-server/package.json b/packages/language-server/package.json
index 0701b6ac95..b0c8d1c160 100644
--- a/packages/language-server/package.json
+++ b/packages/language-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-doctor/language-server",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "private": true,
   "description": "Language server for React Doctor editor integrations.",
   "license": "SEE LICENSE IN LICENSE",
diff --git a/packages/oxlint-plugin-react-doctor/CHANGELOG.md b/packages/oxlint-plugin-react-doctor/CHANGELOG.md
index a1dbbd2b4f..8dbf399916 100644
--- a/packages/oxlint-plugin-react-doctor/CHANGELOG.md
+++ b/packages/oxlint-plugin-react-doctor/CHANGELOG.md
@@ -1,5 +1,11 @@
 # oxlint-plugin-react-doctor
 
+## 0.7.1
+
+### Patch Changes
+
+- [#1061](https://github.com/millionco/react-doctor/pull/1061) [`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - Fix a CI-gate false positive in the baseline delta: pre-existing element-level findings (Accessibility-category rules, plus rules flagged `matchByOccurrence` like `iframe-missing-sandbox`) are now matched by `(file, rule)` occurrence count instead of the flagged line's text, so reformatting the flagged line (reindentation, prettier reflow, collapsing a multi-line JSX element) no longer reports the finding as newly introduced. The flag is resolved at diagnostic creation and carried on the diagnostic as an optional `matchByOccurrence` field (also present in the JSON report). Expression-level rules keep line-text-sensitive matching, and a genuinely new extra occurrence still surfaces.
+
 ## 0.7.0
 
 ## 0.6.3
diff --git a/packages/oxlint-plugin-react-doctor/package.json b/packages/oxlint-plugin-react-doctor/package.json
index 65c3dba29d..05e3a7847d 100644
--- a/packages/oxlint-plugin-react-doctor/package.json
+++ b/packages/oxlint-plugin-react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",
diff --git a/packages/react-doctor/CHANGELOG.md b/packages/react-doctor/CHANGELOG.md
index bdec97c83d..41bc95936a 100644
--- a/packages/react-doctor/CHANGELOG.md
+++ b/packages/react-doctor/CHANGELOG.md
@@ -1,5 +1,19 @@
 # react-doctor
 
+## 0.7.1
+
+### Patch Changes
+
+- [#1062](https://github.com/millionco/react-doctor/pull/1062) [`6b21b70`](https://github.com/millionco/react-doctor/commit/6b21b70d1acf50c23df170f3751479b2cb295909) Thanks [@devin-ai-integration](https://github.com/apps/devin-ai-integration)! - Surface when a scan target had no discoverable React project, so a gated-off run can't pass for a clean one.
+
+  - The JSON report now carries `reactDetected: false` (additive optional field on schemaVersion 1 and 2) when no scanned project resolved a React or Preact runtime — the case where every React-runtime rule family gates off and the report would otherwise be byte-indistinguishable from a genuinely clean scan. It's `true` when any project resolved a runtime, and absent when nothing was scanned or the run errored. Consumers gating on the report (CI, verifiers, pre-commit hooks) should treat `reactDetected === false` as "wrong scan target", not "all clear"; per-project detail is already available via `projects[].project.reactVersion` / `preactVersion`.
+  - The CLI prints a stderr warning in the same case: "No React project detected at <path> — React rules were gated off; this is not the same as a clean scan."
+  - The programmatic API mirrors the signal: `diagnose()` results carry `reactDetected` (`DiagnoseResult.reactDetected`, per-project on `ProjectResultOk`, aggregate on `DiagnoseProjectsResult` — absent when no project scanned successfully), and the `hasReactRuntime(project)` predicate is exported from `react-doctor/api` and `@react-doctor/api`.
+
+- Updated dependencies [[`c0c3fc1`](https://github.com/millionco/react-doctor/commit/c0c3fc170972876c8bbc2419b32e66b9c864df85)]:
+  - oxlint-plugin-react-doctor@0.7.1
+  - deslop-js@0.7.1
+
 ## 0.7.0
 
 ### Patch Changes
diff --git a/packages/react-doctor/package.json b/packages/react-doctor/package.json
index c5b48ebc9c..483d53116d 100644
--- a/packages/react-doctor/package.json
+++ b/packages/react-doctor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-doctor",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Your agent writes bad React. This catches it",
   "keywords": [
     "accessibility",

From ce9dabf1103f4f989bb8f9c1783a24674ba163e7 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 13:17:39 -0500
Subject: [PATCH 28/33] fix(core): --staged now works in monorepo
 subdirectories (git show :./<path>) (#1067)

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/staged-monorepo-subdir-pathspec.md |  5 ++
 packages/core/src/services/git.ts             |  9 ++-
 .../issue-1064-staged-subdir-path.test.ts     | 74 +++++++++++++++++++
 3 files changed, 87 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/staged-monorepo-subdir-pathspec.md
 create mode 100644 packages/core/tests/regressions/issue-1064-staged-subdir-path.test.ts

diff --git a/.changeset/staged-monorepo-subdir-pathspec.md b/.changeset/staged-monorepo-subdir-pathspec.md
new file mode 100644
index 0000000000..c098f5d489
--- /dev/null
+++ b/.changeset/staged-monorepo-subdir-pathspec.md
@@ -0,0 +1,5 @@
+---
+"@react-doctor/core": patch
+---
+
+Fix `--staged` silently scanning nothing when the project is a subdirectory of the git repo (the standard monorepo layout, e.g. `apps/webui`). Staged paths are collected project-relative (`git diff --cached --relative`), but the staged-content read used a bare `git show :<path>` index pathspec, which git resolves against the repo root — so in a subproject every read missed, the file was silently skipped, and the scan "passed" with `scannedFileCount: 0` (particularly dangerous in a pre-commit hook). The index read now uses the cwd-relative `git show :./<path>` form, matching how baseline `<ref>:<path>` reads were already resolved.
diff --git a/packages/core/src/services/git.ts b/packages/core/src/services/git.ts
index 2bda2fda18..68cb933cd0 100644
--- a/packages/core/src/services/git.ts
+++ b/packages/core/src/services/git.ts
@@ -769,7 +769,14 @@ export class Git extends Context.Service<
         showStagedContent: (directory, relativePath, options) =>
           runCommand({
             command: "git",
-            args: ["show", `:${relativePath}`],
+            // The `./` prefix is required for the same reason as `showRefContent`
+            // below: git reads a bare `:<path>` index pathspec relative to the
+            // REPO ROOT, but `relativePath` is relative to `directory` (the
+            // scanned project, which may be a monorepo subproject). `:./` makes
+            // git resolve it against the cwd, so a subproject's staged content is
+            // read correctly instead of silently missing (the whole file set
+            // would otherwise be skipped and `--staged` scans nothing).
+            args: ["show", `:./${relativePath}`],
             directory,
             maxStdoutBytes: options?.maxBufferBytes,
           }).pipe(Effect.map((result) => (result.status === 0 ? result.stdout : null))),
diff --git a/packages/core/tests/regressions/issue-1064-staged-subdir-path.test.ts b/packages/core/tests/regressions/issue-1064-staged-subdir-path.test.ts
new file mode 100644
index 0000000000..a95b56da62
--- /dev/null
+++ b/packages/core/tests/regressions/issue-1064-staged-subdir-path.test.ts
@@ -0,0 +1,74 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as Effect from "effect/Effect";
+import { afterAll, describe, expect, it } from "vite-plus/test";
+import { Git } from "@react-doctor/core";
+
+/**
+ * Regression for #1064: `--staged` silently scanned nothing when the project
+ * is a subdirectory of the git repo (the standard monorepo layout). Staged
+ * paths are collected with `git diff --cached --relative` (project-relative,
+ * e.g. `src/Bad.tsx`), but the content read used a bare `git show :<path>`
+ * index pathspec — which git resolves against the REPO ROOT, not the cwd. In a
+ * subproject that misses (`fatal: path 'apps/webui/src/Bad.tsx' is in the
+ * index, but not 'src/Bad.tsx'`), the non-zero exit folds to `null`, and
+ * `materializeSourceTree` skips the file with no warning, so every staged file
+ * is dropped and the gate "passes" with `scannedFileCount: 0`.
+ *
+ * The fix prefixes the pathspec with `./` (`git show :./<path>`) so git
+ * resolves it relative to the scanned project — the same treatment
+ * `showRefContent` already applies to the `<ref>:<path>` baseline reads.
+ *
+ * Uses `Git.layerNode` (production layer) against a real repo whose project
+ * lives in `apps/webui/`; staging (`git add`) populates the index, so the read
+ * needs no commit (and thus no `commit.gpgsign` TTY prompt).
+ */
+const runNode = <Value>(program: Effect.Effect<Value, unknown, Git>): Promise<Value> =>
+  Effect.runPromise(program.pipe(Effect.provide(Git.layerNode)));
+
+const subdirectoryRepository = (() => {
+  const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rd-1064-"));
+  const projectDirectory = path.join(repoRoot, "apps", "webui");
+  fs.mkdirSync(path.join(projectDirectory, "src"), { recursive: true });
+  fs.writeFileSync(
+    path.join(projectDirectory, "src", "Bad.tsx"),
+    "export const Bad = () => <div>bad</div>;\n",
+  );
+  const runGit = (args: ReadonlyArray<string>): void => {
+    execFileSync("git", [...args], { cwd: repoRoot, stdio: "ignore" });
+  };
+  runGit(["init"]);
+  runGit(["add", "apps/webui/src/Bad.tsx"]);
+  return { repoRoot, projectDirectory };
+})();
+
+afterAll(() => fs.rmSync(subdirectoryRepository.repoRoot, { recursive: true, force: true }));
+
+describe("issue #1064: staged content reads from a project subdirectory", () => {
+  it("reads a staged file whose path is relative to the scanned subproject", async () => {
+    const content = await runNode(
+      Effect.gen(function* () {
+        const git = yield* Git;
+        return yield* git.showStagedContent(subdirectoryRepository.projectDirectory, "src/Bad.tsx");
+      }),
+    );
+    // Before the fix this was `null` (bare `:src/Bad.tsx` missed against the
+    // repo root), silently dropping every staged file in a monorepo subproject.
+    expect(content).toBe("export const Bad = () => <div>bad</div>;\n");
+  });
+
+  it("still returns null for a path genuinely absent from the index", async () => {
+    const content = await runNode(
+      Effect.gen(function* () {
+        const git = yield* Git;
+        return yield* git.showStagedContent(
+          subdirectoryRepository.projectDirectory,
+          "src/Missing.tsx",
+        );
+      }),
+    );
+    expect(content).toBeNull();
+  });
+});

From 64452aacab9770ac8a01ebab221addeedb594b77 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 20:35:50 -0500
Subject: [PATCH 29/33] fix(cli): scan cache no longer replays across projects
 at a reused path (#1070)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/scan-cache-cross-project-replay.md |  5 ++
 .../react-doctor/src/cli/utils/constants.ts   |  4 +-
 .../src/cli/utils/scan-result-cache.ts        | 52 +++++++++++---
 .../tests/scan-result-cache.test.ts           | 68 +++++++++++++++++++
 4 files changed, 119 insertions(+), 10 deletions(-)
 create mode 100644 .changeset/scan-cache-cross-project-replay.md

diff --git a/.changeset/scan-cache-cross-project-replay.md b/.changeset/scan-cache-cross-project-replay.md
new file mode 100644
index 0000000000..082a8cf035
--- /dev/null
+++ b/.changeset/scan-cache-cross-project-replay.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": patch
+---
+
+Fix whole-repo scan cache replaying another project's diagnostics when a .git-less checkout sits inside an unrelated repository (e.g. a gitignored benchmark/mining clone directory reused across projects). The cache key's git identity (HEAD sha, worktree fingerprint) resolved from the enclosing repository, which cannot see the checkout's files, so two different projects materialized at the same path keyed identically. The key now requires the fingerprinted repository to actually track files under the project directory (cache off otherwise), and every cache hit re-verifies the stored payload's directory and `package.json` content hash so any future keying bug of this class degrades to a miss instead of a cross-project replay.
diff --git a/packages/react-doctor/src/cli/utils/constants.ts b/packages/react-doctor/src/cli/utils/constants.ts
index b7f8578b62..af4551b88b 100644
--- a/packages/react-doctor/src/cli/utils/constants.ts
+++ b/packages/react-doctor/src/cli/utils/constants.ts
@@ -27,7 +27,9 @@ export const BASELINE_FILES_TEMP_DIR_PREFIX = "react-doctor-baseline-";
 // Bumped to 2: `CachedScanPayload` gained the required `supplyChainOverlapTimedOut`
 // (supply-chain overlap) and `deadCodeOverlapped` (dead-code overlap) fields.
 // Bumped to 3: gained the required `suppressedRuleCounts` field (suppression telemetry).
-export const SCAN_RESULT_CACHE_SCHEMA_VERSION = 3;
+// Bumped to 4: gained the `manifestContentHash` replay guard, which every
+// `lookup` verifies — pre-bump entries without it would never hit again.
+export const SCAN_RESULT_CACHE_SCHEMA_VERSION = 4;
 export const SCAN_RESULT_CACHE_MAX_ENTRY_COUNT = 20;
 export const SCAN_RESULT_CACHE_FILENAME = "scan-cache.json";
 // The dirty-worktree cache-key fingerprint content-hashes every path `git
diff --git a/packages/react-doctor/src/cli/utils/scan-result-cache.ts b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
index fc75b1d0f1..ddafca0270 100644
--- a/packages/react-doctor/src/cli/utils/scan-result-cache.ts
+++ b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
@@ -23,7 +23,7 @@ import {
   SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES,
   SCAN_RESULT_CACHE_SCHEMA_VERSION,
 } from "./constants.js";
-import { isRecord, runGit } from "./git-hook-shared.js";
+import { getPackageJsonPath, isRecord, runGit } from "./git-hook-shared.js";
 import type { ResolvedInspectOptions } from "../../inspect.js";
 
 export interface CachedScanPayload {
@@ -63,6 +63,14 @@ export interface CachedScanPayload {
    * suppression telemetry the fresh scan emitted.
    */
   readonly suppressedRuleCounts: ReadonlyArray<SuppressedRuleCount>;
+  /**
+   * Content hash of the project's `package.json` when the payload was stored
+   * (`null` when the project has none). Stamped by `store` and re-checked by
+   * `lookup` independently of the cache key, so any keying bug of the
+   * same-path-different-project class surfaces as a miss instead of silently
+   * replaying another project's diagnostics.
+   */
+  readonly manifestContentHash?: string | null;
 }
 
 interface PersistedScanResultCacheEntry {
@@ -282,10 +290,20 @@ const resolveDotenvFingerprint = (projectDirectory: string): ReadonlyArray<strin
   }
 };
 
-const hasHiddenTrackedFileState = (projectDirectory: string): boolean => {
+// Whether the repository git resolves for the project directory can be
+// trusted as cache-key identity. `git ls-files -v` (restricted to the project
+// directory by cwd) refutes that two ways: zero entries means the repository
+// tracks nothing here — the project directory is a gitignored or untracked
+// checkout (e.g. a .git-less clone nested inside an unrelated repository), so
+// HEAD and `git status` describe a repository that cannot see the project's
+// files and different project contents would key identically; a non-"H"
+// entry means assume-unchanged / skip-worktree bits hide tracked-file changes
+// from every fingerprint built on `git status`.
+const isGitIdentityTrustworthy = (projectDirectory: string): boolean => {
   const output = runGit(projectDirectory, ["ls-files", "-v"]);
-  if (output === null) return true;
-  return output.split("\n").some((line) => line.length > 0 && line[0] !== "H");
+  if (output === null) return false;
+  const entryLines = output.split("\n").filter((line) => line.length > 0);
+  return entryLines.length > 0 && entryLines.every((line) => line[0] === "H");
 };
 
 // Sits beside the per-file lint / sidecar / dead-code caches under the shared
@@ -354,6 +372,9 @@ const resolveProjectIdentity = (projectDirectory: string): string => {
   }
 };
 
+const resolveManifestContentHash = (projectDirectory: string): string | null =>
+  hashFileContents(getPackageJsonPath(projectDirectory));
+
 const fileFingerprint = (filePath: string): string | null => {
   try {
     const stat = fs.statSync(filePath);
@@ -391,9 +412,7 @@ const resolveToolchainFingerprint = (nodeBinaryPath: string | null): ReadonlyArr
 
 export const buildScanResultCacheKey = (input: ScanResultCacheKeyInput): string | null => {
   if (isCacheGloballyDisabled()) return null;
-  // Assume-unchanged / skip-worktree hide tracked-file state from `git
-  // status`, so no fingerprint built from it can see those changes.
-  if (hasHiddenTrackedFileState(input.projectDirectory)) return null;
+  if (!isGitIdentityTrustworthy(input.projectDirectory)) return null;
   const worktreeFingerprint = buildWorktreeFingerprint(input.projectDirectory);
   if (worktreeFingerprint === null) return null;
   const headSha = readHeadSha(input.projectDirectory);
@@ -466,9 +485,24 @@ export const createScanResultCache = (projectDirectory: string): ScanResultCache
   };
 
   return {
-    lookup: (key) => entries.get(key)?.payload ?? null,
+    lookup: (key) => {
+      const payload = entries.get(key)?.payload;
+      if (payload === undefined) return null;
+      // Replay guard, independent of the key: a served payload must describe
+      // THIS project — same directory identity and same manifest content as
+      // when it was stored — so a keying bug degrades to a miss, never to
+      // another project's diagnostics.
+      const describesThisProject =
+        resolveProjectIdentity(payload.directory) === resolveProjectIdentity(projectDirectory) &&
+        (payload.manifestContentHash ?? null) === resolveManifestContentHash(projectDirectory);
+      return describesThisProject ? payload : null;
+    },
     store: (key, payload) => {
-      entries.set(key, { key, createdAtMs: Date.now(), payload });
+      entries.set(key, {
+        key,
+        createdAtMs: Date.now(),
+        payload: { ...payload, manifestContentHash: resolveManifestContentHash(projectDirectory) },
+      });
       persist();
     },
   };
diff --git a/packages/react-doctor/tests/scan-result-cache.test.ts b/packages/react-doctor/tests/scan-result-cache.test.ts
index 8c8f47d365..fbb88f6892 100644
--- a/packages/react-doctor/tests/scan-result-cache.test.ts
+++ b/packages/react-doctor/tests/scan-result-cache.test.ts
@@ -306,6 +306,74 @@ describe("scan result cache", () => {
     expect(cacheKey(projectDirectory, baseOptions())).toBeNull();
   });
 
+  it("does not cache a .git-less checkout git resolves to an enclosing repository", () => {
+    // The mining/benchmark layout: an enclosing "runner" repo gitignores a
+    // clones/ directory into which different projects are materialized at the
+    // same path with .git stripped. Every git probe from the clone resolves
+    // the runner repo — whose HEAD and worktree state cannot see the clone's
+    // contents — so without the tracking-state gate two different projects at
+    // this path key identically and replay each other's diagnostics.
+    const runnerDirectory = path.join(tempDirectory, "runner");
+    fs.mkdirSync(runnerDirectory, { recursive: true });
+    fs.writeFileSync(path.join(runnerDirectory, ".gitignore"), "clones/\n");
+    initGitRepo(runnerDirectory, { commit: true });
+    const projectDirectory = setupReactProject(runnerDirectory, "clones/app", {
+      files: { "src/App.tsx": "export const App = () => <div />;\n" },
+    });
+
+    expect(cacheKey(projectDirectory, baseOptions())).toBeNull();
+  });
+
+  it("still caches a tracked workspace-member subdirectory", () => {
+    const repositoryDirectory = path.join(tempDirectory, "workspace");
+    fs.mkdirSync(repositoryDirectory, { recursive: true });
+    const projectDirectory = setupReactProject(repositoryDirectory, "packages/app", {
+      files: { "src/App.tsx": "export const App = () => <div />;\n" },
+    });
+    initGitRepo(repositoryDirectory, { commit: true });
+
+    expect(cacheKey(projectDirectory, baseOptions())).not.toBeNull();
+  });
+
+  describe("replay verification", () => {
+    it("misses when the manifest content changed since the payload was stored", () => {
+      const projectDirectory = setupReactProject(tempDirectory, "manifest-drift", {
+        files: { "src/App.tsx": "export const App = () => <div />;\n" },
+      });
+      initGitRepo(projectDirectory, { commit: true });
+      const key = cacheKey(projectDirectory, baseOptions());
+      expect(key).not.toBeNull();
+      if (key === null) return;
+      createScanResultCache(projectDirectory).store(key, basePayload(projectDirectory));
+      expect(createScanResultCache(projectDirectory).lookup(key)).not.toBeNull();
+
+      // A different project materialized at the same path (same cache key by
+      // hypothesis of a keying bug) must read as a miss, not a replay.
+      fs.writeFileSync(
+        path.join(projectDirectory, "package.json"),
+        JSON.stringify({ name: "different-project", dependencies: { react: "^19.0.0" } }),
+      );
+      expect(createScanResultCache(projectDirectory).lookup(key)).toBeNull();
+    });
+
+    it("misses when the stored payload describes another directory", () => {
+      const projectDirectory = setupReactProject(tempDirectory, "directory-drift", {
+        files: { "src/App.tsx": "export const App = () => <div />;\n" },
+      });
+      initGitRepo(projectDirectory, { commit: true });
+      const key = cacheKey(projectDirectory, baseOptions());
+      expect(key).not.toBeNull();
+      if (key === null) return;
+      const cache = createScanResultCache(projectDirectory);
+      cache.store(
+        key,
+        basePayload(projectDirectory, { directory: path.join(tempDirectory, "elsewhere") }),
+      );
+
+      expect(cache.lookup(key)).toBeNull();
+    });
+  });
+
   it("handles git output larger than Node's default maxBuffer", () => {
     // `git ls-files -v` exceeds execFileSync's 1 MiB default on repos with
     // ~15-25k tracked files (getsentry/sentry: 1.25 MB); the resulting ENOBUFS

From 5809083017d77962e22d257578458dc02cdebe14 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 20:35:59 -0500
Subject: [PATCH 30/33] feat(cli): add --supply-chain / --no-supply-chain to
 toggle the dependency scan (#1069)

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/no-supply-chain-flag.md            |  5 +++++
 packages/core/src/types/inspect.ts            |  7 +++++++
 .../react-doctor/src/cli/commands/inspect.ts  |  8 ++++----
 packages/react-doctor/src/cli/index.ts        |  5 +++++
 .../src/cli/utils/build-run-event.ts          |  4 ++++
 .../src/cli/utils/build-runtime-layers.ts     | 19 +++++++++++++------
 .../src/cli/utils/inspect-flags.ts            |  2 ++
 .../cli/utils/resolve-cli-inspect-options.ts  |  5 +++--
 .../src/cli/utils/scan-result-cache.ts        |  5 +++++
 .../src/cli/utils/strip-unknown-cli-flags.ts  |  2 ++
 packages/react-doctor/src/inspect.ts          |  5 +++++
 .../tests/build-run-event.test.ts             | 15 +++++++++++++++
 .../tests/resolve-cli-inspect-options.test.ts | 18 ++++++++++++++++++
 .../tests/scan-result-cache.test.ts           |  4 ++++
 .../tests/strip-unknown-cli-flags.test.ts     | 10 ++++++++++
 15 files changed, 102 insertions(+), 12 deletions(-)
 create mode 100644 .changeset/no-supply-chain-flag.md

diff --git a/.changeset/no-supply-chain-flag.md b/.changeset/no-supply-chain-flag.md
new file mode 100644
index 0000000000..22e8d9e385
--- /dev/null
+++ b/.changeset/no-supply-chain-flag.md
@@ -0,0 +1,5 @@
+---
+"react-doctor": minor
+---
+
+Add `--supply-chain` / `--no-supply-chain` CLI flags to toggle the dependency supply-chain scan, mirroring `--lint`/`--no-lint` and `--dead-code`/`--no-dead-code`. Supply-chain enablement now resolves as a scan option (`InspectOptions.supplyChain`) against `supplyChain.enabled` — the flag wins — so it takes precedence over per-project config on every scan (a workspace module's config can't undo `--no-supply-chain`), and config isn't mutated so `scan.hasCustomConfig` telemetry stays accurate. The enabled state also rides the per-scan wide event as `scan.supplyChain`.
diff --git a/packages/core/src/types/inspect.ts b/packages/core/src/types/inspect.ts
index 35c2e3130c..842e47afa0 100644
--- a/packages/core/src/types/inspect.ts
+++ b/packages/core/src/types/inspect.ts
@@ -112,6 +112,13 @@ export interface InspectOptions {
   lint?: boolean;
   /** See `ReactDoctorConfig.deadCode`. Ignored in diff / staged mode. */
   deadCode?: boolean;
+  /**
+   * Whether to run the Socket.dev supply-chain scan. Resolves against
+   * `ReactDoctorConfig.supplyChain.enabled` (this wins when set), defaulting
+   * to `true`. Kept as an option — not folded into the config — so it takes
+   * precedence over per-project config on every scan, like `lint`/`deadCode`.
+   */
+  supplyChain?: boolean;
   includePaths?: string[];
   configOverride?: ReactDoctorConfig | null;
   /**
diff --git a/packages/react-doctor/src/cli/commands/inspect.ts b/packages/react-doctor/src/cli/commands/inspect.ts
index 645b42964b..7f596486e7 100644
--- a/packages/react-doctor/src/cli/commands/inspect.ts
+++ b/packages/react-doctor/src/cli/commands/inspect.ts
@@ -549,10 +549,10 @@ export const inspectAction = async (directory: string, flags: InspectFlags): Pro
         projectScanTarget.userConfig?.plugins === undefined
           ? scanTarget.configSourceDirectory
           : projectScanTarget.configSourceDirectory;
-      // The Socket supply-chain check runs by default; opted out per project
-      // config. Off ⇒ a manifest-only diff change shouldn't pull a project into
-      // the scan (there'd be nothing to report).
-      const supplyChainEnabled = projectConfig?.supplyChain?.enabled !== false;
+      // The Socket supply-chain check runs by default; opted out by
+      // `--no-supply-chain` (wins) or per-project config. Off ⇒ a manifest-only
+      // diff change shouldn't pull a project into the scan (nothing to report).
+      const supplyChainEnabled = flags.supplyChain ?? projectConfig?.supplyChain?.enabled !== false;
 
       let includePaths: string[] | undefined;
       let supplyChainManifestChanged = false;
diff --git a/packages/react-doctor/src/cli/index.ts b/packages/react-doctor/src/cli/index.ts
index b683abb425..e6a0b0f0b7 100644
--- a/packages/react-doctor/src/cli/index.ts
+++ b/packages/react-doctor/src/cli/index.ts
@@ -145,6 +145,11 @@ const program = new Command()
     "--no-dead-code",
     "skip dead-code analysis (unused files / exports / dependencies, circular imports)",
   )
+  .option("--supply-chain", "enable the dependency supply-chain scan (default)")
+  .option(
+    "--no-supply-chain",
+    "skip the dependency supply-chain scan (Socket.dev dependency health checks)",
+  )
   .option("--verbose", "show every rule and per-file details (default shows top 3 rules)")
   .option(
     "--debug",
diff --git a/packages/react-doctor/src/cli/utils/build-run-event.ts b/packages/react-doctor/src/cli/utils/build-run-event.ts
index 26a55d2de7..79d2f39506 100644
--- a/packages/react-doctor/src/cli/utils/build-run-event.ts
+++ b/packages/react-doctor/src/cli/utils/build-run-event.ts
@@ -44,6 +44,9 @@ export interface RunEventInput {
   readonly maxDurationMs: number | null;
   readonly lint: boolean;
   readonly deadCode: boolean;
+  // Whether the supply-chain scan is enabled by config/flag (the config analog
+  // of `lint`/`deadCode`) — not whether it ran; diff/staged mode skips it anyway.
+  readonly supplyChain: boolean;
   readonly scoreOnly: boolean;
   readonly noScore: boolean;
   readonly respectInlineDisables: boolean;
@@ -443,6 +446,7 @@ const buildScanAttributes = (input: RunEventInput): RunEventAttributes => {
     maxDurationMs: input.maxDurationMs,
     lint: input.lint,
     deadCode: input.deadCode,
+    supplyChain: input.supplyChain,
     scoreOnly: input.scoreOnly,
     noScore: input.noScore,
     respectInlineDisables: input.respectInlineDisables,
diff --git a/packages/react-doctor/src/cli/utils/build-runtime-layers.ts b/packages/react-doctor/src/cli/utils/build-runtime-layers.ts
index 50471586c2..b853b94d0c 100644
--- a/packages/react-doctor/src/cli/utils/build-runtime-layers.ts
+++ b/packages/react-doctor/src/cli/utils/build-runtime-layers.ts
@@ -36,6 +36,14 @@ export interface BuildRuntimeLayersInput {
    */
   readonly shouldSkipLint: boolean;
   readonly shouldRunDeadCode: boolean;
+  /**
+   * Whether the Socket.dev supply-chain scan should run. Resolved by
+   * `inspect()` from the `--supply-chain` / `--no-supply-chain` flag over
+   * `supplyChain.enabled` (the flag wins), so a per-project config can't
+   * undo the CLI choice. `false` swaps `SupplyChain.layerNode` for the
+   * no-op `layerOf([])`.
+   */
+  readonly shouldRunSupplyChain: boolean;
   /**
    * Whether the run should request a score from the hosted API.
    * `false` swaps `Score.layerHttp` for `Score.layerOf(null)` so the
@@ -105,12 +113,11 @@ export const buildRuntimeLayers = (input: BuildRuntimeLayersInput) => {
   const deadCodeLayer = input.shouldRunDeadCode ? DeadCode.layerNode : DeadCode.layerOf([]);
   const scoreLayer = input.shouldComputeScore ? Score.layerHttp : Score.layerOf(null);
   // Socket.dev supply-chain score gate runs by default (the keyless HTTP
-  // layer); a no-op empty layer only when the user explicitly opts out via
-  // `supplyChain.enabled: false`.
-  const supplyChainLayer =
-    input.userConfig?.supplyChain?.enabled === false
-      ? SupplyChain.layerOf([])
-      : SupplyChain.layerNode;
+  // layer); a no-op empty layer when the user opts out via
+  // `--no-supply-chain` or `supplyChain.enabled: false`.
+  const supplyChainLayer = input.shouldRunSupplyChain
+    ? SupplyChain.layerNode
+    : SupplyChain.layerOf([]);
   const projectLayer =
     input.projectInfoOverride === undefined
       ? Project.layerNode
diff --git a/packages/react-doctor/src/cli/utils/inspect-flags.ts b/packages/react-doctor/src/cli/utils/inspect-flags.ts
index c50a0709da..d3b226af50 100644
--- a/packages/react-doctor/src/cli/utils/inspect-flags.ts
+++ b/packages/react-doctor/src/cli/utils/inspect-flags.ts
@@ -5,6 +5,8 @@
 export interface InspectFlags {
   lint?: boolean;
   deadCode?: boolean;
+  // Resolved against `supplyChain.enabled` (this flag wins), like lint/deadCode.
+  supplyChain?: boolean;
   verbose?: boolean;
   // Forces a Sentry trace and prints its id at the end. Conflicts with
   // --no-score / --no-telemetry, which disable the telemetry it needs.
diff --git a/packages/react-doctor/src/cli/utils/resolve-cli-inspect-options.ts b/packages/react-doctor/src/cli/utils/resolve-cli-inspect-options.ts
index 40cba5068c..30f12a660f 100644
--- a/packages/react-doctor/src/cli/utils/resolve-cli-inspect-options.ts
+++ b/packages/react-doctor/src/cli/utils/resolve-cli-inspect-options.ts
@@ -15,8 +15,8 @@ export interface CliInspectOptions extends InspectOptions {
  * accepts. Flag-derived fields only (`scoreOnly`, `noScore`, `silent`,
  * `isCi`): every `userConfig` fallback — including `noScore` — lives in
  * `inspect()`'s merge layer, which sees each project's module-merged
- * config. The plain boolean knobs (`lint`, `deadCode`, `verbose`) pass
- * through unchanged for the same reason. This resolver reads
+ * config. The plain boolean knobs (`lint`, `deadCode`, `supplyChain`,
+ * `verbose`) pass through unchanged for the same reason. This resolver reads
  * `userConfig` only to decide the `--blocking warning` gate.
  */
 export const resolveCliInspectOptions = (
@@ -33,6 +33,7 @@ export const resolveCliInspectOptions = (
   return {
     lint: flags.lint,
     deadCode: flags.deadCode,
+    supplyChain: flags.supplyChain,
     verbose: flags.verbose,
     outputDirectory: flags.outputDir,
     // `--no-respect-inline-disables` is negatable-only, so commander defaults
diff --git a/packages/react-doctor/src/cli/utils/scan-result-cache.ts b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
index ddafca0270..46477bc242 100644
--- a/packages/react-doctor/src/cli/utils/scan-result-cache.ts
+++ b/packages/react-doctor/src/cli/utils/scan-result-cache.ts
@@ -435,6 +435,11 @@ export const buildScanResultCacheKey = (input: ScanResultCacheKeyInput): string
     engineOptions: {
       lint: input.options.lint,
       deadCode: input.options.deadCode,
+      // Resolved supply-chain enablement (the `--supply-chain` flag over
+      // config). Keyed here — not just via `userConfig` — because the flag can
+      // flip it without touching the config blob, so a `--no-supply-chain`
+      // lookup must not serve a supply-chain-on payload at the same commit.
+      supplyChain: input.options.supplyChain,
       includePaths: [...input.options.includePaths].sort(),
       customRulesOnly: input.options.customRulesOnly,
       respectInlineDisables: input.options.respectInlineDisables,
diff --git a/packages/react-doctor/src/cli/utils/strip-unknown-cli-flags.ts b/packages/react-doctor/src/cli/utils/strip-unknown-cli-flags.ts
index 0d08524aad..d665cb4ec2 100644
--- a/packages/react-doctor/src/cli/utils/strip-unknown-cli-flags.ts
+++ b/packages/react-doctor/src/cli/utils/strip-unknown-cli-flags.ts
@@ -23,10 +23,12 @@ const ROOT_FLAG_SPEC: CliFlagSpec = {
     "--no-parallel",
     "--no-respect-inline-disables",
     "--no-score",
+    "--no-supply-chain",
     "--no-telemetry",
     "--no-warnings",
     "--score",
     "--staged",
+    "--supply-chain",
     "--verbose",
     "--version",
     "--warnings",
diff --git a/packages/react-doctor/src/inspect.ts b/packages/react-doctor/src/inspect.ts
index 5bb468452e..ef571f024c 100644
--- a/packages/react-doctor/src/inspect.ts
+++ b/packages/react-doctor/src/inspect.ts
@@ -153,6 +153,7 @@ export interface ReactDoctorInspectOptions extends InspectOptions {
 export interface ResolvedInspectOptions {
   lint: boolean;
   deadCode: boolean;
+  supplyChain: boolean;
   verbose: boolean;
   /** See `InspectOptions.outputDirectory`. `null` keeps the temp-dir default. */
   outputDirectory: string | null;
@@ -204,6 +205,7 @@ const mergeInspectOptions = (
 ): ResolvedInspectOptions => ({
   lint: inputOptions.lint ?? userConfig?.lint ?? true,
   deadCode: inputOptions.deadCode ?? userConfig?.deadCode ?? true,
+  supplyChain: inputOptions.supplyChain ?? userConfig?.supplyChain?.enabled ?? true,
   verbose: inputOptions.verbose ?? userConfig?.verbose ?? false,
   outputDirectory: inputOptions.outputDirectory || null,
   scoreOnly: inputOptions.scoreOnly ?? false,
@@ -267,6 +269,7 @@ const buildRunEventConfig = (
     maxDurationMs: options.maxDurationMs,
     lint: options.lint,
     deadCode: options.deadCode,
+    supplyChain: options.supplyChain,
     scoreOnly: options.scoreOnly,
     noScore: options.noScore,
     respectInlineDisables: options.respectInlineDisables,
@@ -451,6 +454,7 @@ const runBaselineComparison = async (
       projectInfoOverride: params.headProjectInfo,
       shouldSkipLint: !params.options.lint || !params.resolvedNodeBinaryPath,
       shouldRunDeadCode: false,
+      shouldRunSupplyChain: params.options.supplyChain,
       shouldComputeScore: false,
       shouldShowProgressSpinners: false,
       oxlintConcurrency: params.options.concurrency,
@@ -605,6 +609,7 @@ const runInspectWithRuntime = async (
     configSourceDirectory,
     shouldSkipLint: !options.lint || lintBindingMissing,
     shouldRunDeadCode: options.deadCode,
+    shouldRunSupplyChain: options.supplyChain,
     shouldComputeScore: !options.noScore,
     shouldShowProgressSpinners,
     oxlintConcurrency: options.concurrency,
diff --git a/packages/react-doctor/tests/build-run-event.test.ts b/packages/react-doctor/tests/build-run-event.test.ts
index 60331038d4..14840a10f5 100644
--- a/packages/react-doctor/tests/build-run-event.test.ts
+++ b/packages/react-doctor/tests/build-run-event.test.ts
@@ -73,6 +73,7 @@ const baseInput = (overrides: Partial<RunEventInput> = {}): RunEventInput => ({
   maxDurationMs: null,
   lint: true,
   deadCode: true,
+  supplyChain: true,
   scoreOnly: false,
   noScore: false,
   respectInlineDisables: true,
@@ -536,4 +537,18 @@ describe("buildRunEventAttributes", () => {
     expect(attributes["scan.fileCount"]).toBeUndefined();
     expect(attributes["timing.scanMs"]).toBeUndefined();
   });
+
+  it("records each scan phase's enabled state, including supply-chain", () => {
+    const enabled = buildRunEventAttributes(baseInput());
+    expect(enabled["scan.lint"]).toBe(true);
+    expect(enabled["scan.deadCode"]).toBe(true);
+    expect(enabled["scan.supplyChain"]).toBe(true);
+
+    const disabled = buildRunEventAttributes(
+      baseInput({ lint: false, deadCode: false, supplyChain: false }),
+    );
+    expect(disabled["scan.lint"]).toBe(false);
+    expect(disabled["scan.deadCode"]).toBe(false);
+    expect(disabled["scan.supplyChain"]).toBe(false);
+  });
 });
diff --git a/packages/react-doctor/tests/resolve-cli-inspect-options.test.ts b/packages/react-doctor/tests/resolve-cli-inspect-options.test.ts
index 745a82dbd0..cb5910a401 100644
--- a/packages/react-doctor/tests/resolve-cli-inspect-options.test.ts
+++ b/packages/react-doctor/tests/resolve-cli-inspect-options.test.ts
@@ -135,3 +135,21 @@ describe("resolveCliInspectOptions: category filtering", () => {
     );
   });
 });
+
+describe("resolveCliInspectOptions: scan-phase flags", () => {
+  // Passed through as scan options (not folded into config) so the flag wins
+  // over per-project config in `inspect()`'s merge, matching lint/deadCode.
+  it("passes lint / deadCode / supplyChain through unchanged", () => {
+    const off = resolveCliInspectOptions(
+      { lint: false, deadCode: false, supplyChain: false },
+      null,
+    );
+    expect(off.lint).toBe(false);
+    expect(off.deadCode).toBe(false);
+    expect(off.supplyChain).toBe(false);
+
+    const unset = resolveCliInspectOptions({}, null);
+    expect(unset.supplyChain).toBeUndefined();
+    expect(resolveCliInspectOptions({ supplyChain: true }, null).supplyChain).toBe(true);
+  });
+});
diff --git a/packages/react-doctor/tests/scan-result-cache.test.ts b/packages/react-doctor/tests/scan-result-cache.test.ts
index fbb88f6892..2e13345f74 100644
--- a/packages/react-doctor/tests/scan-result-cache.test.ts
+++ b/packages/react-doctor/tests/scan-result-cache.test.ts
@@ -21,6 +21,7 @@ let tempDirectory: string;
 const baseOptions = (overrides: Partial<ResolvedInspectOptions> = {}): ResolvedInspectOptions => ({
   lint: false,
   deadCode: false,
+  supplyChain: true,
   verbose: false,
   scoreOnly: false,
   noScore: true,
@@ -222,6 +223,9 @@ describe("scan result cache", () => {
     expect(cacheKey(projectDirectory, baseOptions({ includePaths: ["src/App.tsx"] }))).not.toBe(
       originalKey,
     );
+    // `--no-supply-chain` must not share a key with a supply-chain-on run at the
+    // same commit — the flag no longer rides the keyed `userConfig` blob.
+    expect(cacheKey(projectDirectory, baseOptions({ supplyChain: false }))).not.toBe(originalKey);
     const alternateNodeBinaryPath = path.join(tempDirectory, "fake-node");
     fs.writeFileSync(alternateNodeBinaryPath, "node-a");
     expect(cacheKey(projectDirectory, options, VERSION, alternateNodeBinaryPath)).not.toBe(
diff --git a/packages/react-doctor/tests/strip-unknown-cli-flags.test.ts b/packages/react-doctor/tests/strip-unknown-cli-flags.test.ts
index f1bae05b1b..297d604ef6 100644
--- a/packages/react-doctor/tests/strip-unknown-cli-flags.test.ts
+++ b/packages/react-doctor/tests/strip-unknown-cli-flags.test.ts
@@ -102,6 +102,16 @@ describe("stripUnknownCliFlags", () => {
     expect(stripUserArguments([".", "--no-telemetry"])).toEqual([".", "--no-telemetry"]);
   });
 
+  it("keeps the phase opt-out flags so Commander can toggle each scan phase", () => {
+    expect(stripUserArguments([".", "--no-lint", "--no-dead-code", "--no-supply-chain"])).toEqual([
+      ".",
+      "--no-lint",
+      "--no-dead-code",
+      "--no-supply-chain",
+    ]);
+    expect(stripUserArguments([".", "--supply-chain"])).toEqual([".", "--supply-chain"]);
+  });
+
   it("keeps color flags on the version subcommand and drops unknown ones", () => {
     expect(stripUserArguments(["version", "--no-color"])).toEqual(["version", "--no-color"]);
     expect(stripUserArguments(["version", "--color"])).toEqual(["version", "--color"]);

From d353dadf988c52e3037dff52eec9cf8923145364 Mon Sep 17 00:00:00 2001
From: Ray Arayilakath <me@rayhanadev.com>
Date: Sat, 4 Jul 2026 21:13:31 -0500
Subject: [PATCH 31/33] feat(core): detect React when scanning a monorepo
 package subdirectory (#1071)

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/monorepo-subdir-react-detection.md |   8 +
 .../core/src/project-info/discover-project.ts |  37 ++--
 .../src/project-info/find-monorepo-root.ts    |   8 +-
 .../find-nearest-ancestor-package-json.ts     |  33 ++++
 .../resolve-installed-react-version.ts        |  63 +++++++
 .../core/src/utils/ancestor-directories.ts    |  23 +++
 packages/core/tests/discover-project.test.ts  | 175 ++++++++++++++++++
 7 files changed, 329 insertions(+), 18 deletions(-)
 create mode 100644 .changeset/monorepo-subdir-react-detection.md
 create mode 100644 packages/core/src/project-info/find-nearest-ancestor-package-json.ts
 create mode 100644 packages/core/src/project-info/resolve-installed-react-version.ts
 create mode 100644 packages/core/src/utils/ancestor-directories.ts

diff --git a/.changeset/monorepo-subdir-react-detection.md b/.changeset/monorepo-subdir-react-detection.md
new file mode 100644
index 0000000000..93089cd6aa
--- /dev/null
+++ b/.changeset/monorepo-subdir-react-detection.md
@@ -0,0 +1,8 @@
+---
+"@react-doctor/core": patch
+---
+
+Detect React when scanning a package subdirectory of a monorepo, so React rules no longer gate off silently. Two additions at the `discoverProject` seam:
+
+- **Nearest-ancestor discovery.** A scan target with no `package.json` of its own now adopts the nearest enclosing package (a leaf workspace, a plain app root, or a monorepo root — whichever is closest, bounded by the git root) instead of only workspace-configured monorepo roots. Scanning `app/src/components` in a plain React app now inherits the app's React detection rather than synthesizing an empty, React-blind project.
+- **Node-resolution React version fallback.** When declarations yield no usable React version (a version-less spec like `workspace:*` / `*` / a dist-tag, or React living only in a hoisted `node_modules` the declaration walks never reach), the version is resolved the way Node itself would — `require.resolve("react/package.json")` — making "React is installed and importable" ⇒ "React is detected" an invariant. Guarded to installations physically inside the enclosing repo so a globally installed React can't leak in, and it never overrides a parseable peer range (`^18 || ^19` still floors to the lowest supported major).
diff --git a/packages/core/src/project-info/discover-project.ts b/packages/core/src/project-info/discover-project.ts
index 4d5aa2b02f..c7947d30eb 100644
--- a/packages/core/src/project-info/discover-project.ts
+++ b/packages/core/src/project-info/discover-project.ts
@@ -8,6 +8,8 @@ import { detectReactCompiler } from "./detect-react-compiler.js";
 import { extractDependencyInfo } from "./extract-dependency-info.js";
 import { findDependencyInfoFromMonorepoRoot } from "./find-dependency-info-from-monorepo-root.js";
 import { findMonorepoRoot, isMonorepoRoot } from "./find-monorepo-root.js";
+import { findNearestAncestorPackageJson } from "./find-nearest-ancestor-package-json.js";
+import { resolveInstalledReactVersion } from "./resolve-installed-react-version.js";
 import { findReactInWorkspaces } from "./find-react-in-workspaces.js";
 import { getDependencyDeclaration } from "./utils/get-dependency-declaration.js";
 import { hasReactNativeWorkspaceAnywhere } from "./has-react-native-workspace-anywhere.js";
@@ -45,27 +47,26 @@ export const clearProjectCache = (): void => {
 
 /**
  * Build a `ProjectInfo` for a directory that has no `package.json` of
- * its own — a monorepo subfolder like `repo/packages`, or any loose tree
- * of TypeScript/JavaScript files. Dependency + framework detection is
- * inherited from the enclosing workspace root when there is one, so
- * scanning a subdirectory of a React monorepo still gets the React
- * capabilities; a standalone non-React directory simply scans with the
- * framework-agnostic rules. Throws only when the directory has nothing
- * to scan (no enclosing project and no source files of its own).
+ * its own — a package subfolder like `repo/packages` or `app/src/features`,
+ * or any loose tree of TypeScript/JavaScript files. Dependency + framework
+ * detection is inherited from the nearest enclosing package (a leaf
+ * workspace, a plain app root, or a monorepo root — whichever is closest,
+ * bounded by the git root), so scanning a subdirectory of a React project
+ * still gets the React capabilities; a standalone non-React directory simply
+ * scans with the framework-agnostic rules. Throws only when the directory has
+ * nothing to scan (no enclosing project and no source files of its own).
  */
 const discoverProjectWithoutPackageJson = (directory: string): ProjectInfo => {
   const sourceFileCount = countSourceFiles(directory);
   const hasOwnTsConfig = fs.existsSync(path.join(directory, "tsconfig.json"));
 
-  const monorepoRoot = findMonorepoRoot(directory);
+  const enclosingProjectRoot = findNearestAncestorPackageJson(directory);
   const enclosingProject =
-    monorepoRoot !== null && isFile(path.join(monorepoRoot, "package.json"))
-      ? discoverProject(monorepoRoot)
-      : null;
+    enclosingProjectRoot !== null ? discoverProject(enclosingProjectRoot) : null;
 
-  // A workspace subfolder (e.g. `repo/packages`): keep the enclosing root's
+  // A package subfolder (e.g. `repo/packages`): keep the enclosing package's
   // dependency + framework detection, but scope the directory-specific fields
-  // to this folder so React capabilities survive when a React monorepo
+  // to this folder so React capabilities survive when a React project
   // subdirectory is scanned.
   if (enclosingProject !== null) {
     return {
@@ -249,6 +250,16 @@ export const discoverProject = (directory: string): ProjectInfo => {
     zodVersion = zodDeclaration.version;
   }
 
+  // Last resort: React is physically installed and importable from here even
+  // though no declaration named a usable version — resolve it the way Node
+  // would. Fires when React is undeclared (hoisted into the repo's
+  // node_modules) or declared only as a version-less spec (`workspace:*`, `*`,
+  // a dist-tag) whose major can't be parsed; a concrete peer range like
+  // `^18 || ^19` already parsed above and is left untouched.
+  if (!reactVersion || parseReactMajor(reactVersion) === null) {
+    reactVersion = resolveInstalledReactVersion(directory) ?? reactVersion;
+  }
+
   const projectName = packageJson.name ?? path.basename(directory);
   const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
   const sourceFileCount = countSourceFiles(directory);
diff --git a/packages/core/src/project-info/find-monorepo-root.ts b/packages/core/src/project-info/find-monorepo-root.ts
index dcedd717dc..3203f57a80 100644
--- a/packages/core/src/project-info/find-monorepo-root.ts
+++ b/packages/core/src/project-info/find-monorepo-root.ts
@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { ancestorDirectories } from "../utils/ancestor-directories.js";
 import { isFile } from "./utils/is-file.js";
 import { readPackageJson } from "./read-package-json.js";
 
@@ -12,11 +13,8 @@ export const isMonorepoRoot = (directory: string): boolean => {
 };
 
 export const findMonorepoRoot = (startDirectory: string): string | null => {
-  let currentDirectory = path.dirname(startDirectory);
-
-  while (currentDirectory !== path.dirname(currentDirectory)) {
-    if (isMonorepoRoot(currentDirectory)) return currentDirectory;
-    currentDirectory = path.dirname(currentDirectory);
+  for (const directory of ancestorDirectories(startDirectory, { includeStart: false })) {
+    if (isMonorepoRoot(directory)) return directory;
   }
 
   return null;
diff --git a/packages/core/src/project-info/find-nearest-ancestor-package-json.ts b/packages/core/src/project-info/find-nearest-ancestor-package-json.ts
new file mode 100644
index 0000000000..abd6032d3d
--- /dev/null
+++ b/packages/core/src/project-info/find-nearest-ancestor-package-json.ts
@@ -0,0 +1,33 @@
+import * as path from "node:path";
+import { ancestorDirectories } from "../utils/ancestor-directories.js";
+import { isProjectBoundary } from "../utils/is-project-boundary.js";
+import { isFile } from "./utils/is-file.js";
+
+/**
+ * Walk up from `startDirectory` to the nearest ancestor that owns a
+ * `package.json`, stopping at (and including) the enclosing project boundary
+ * — the working tree's git root or a monorepo root. Lets a scan of a package
+ * subfolder that has no `package.json` of its own adopt the nearest enclosing
+ * package as its project root, so it inherits that package's dependency +
+ * framework detection instead of synthesizing an empty (React-blind) project.
+ *
+ * Generalizes the older monorepo-root-only lookup: the nearest ancestor is the
+ * most specific owning package (a leaf workspace, not just the repo root), so
+ * a subfolder of one workspace no longer borrows a sibling's capabilities.
+ *
+ * Returns `null` when no ancestor `package.json` exists inside the project
+ * boundary (a loose tree of files, or a subfolder of a package-less repo).
+ */
+export const findNearestAncestorPackageJson = (startDirectory: string): string | null => {
+  // The scan directory itself has no `package.json` (the caller checked). If it
+  // is already the project boundary — the git root or a monorepo root — don't
+  // walk above it and adopt an unrelated `package.json` from outside the repo.
+  if (isProjectBoundary(startDirectory)) return null;
+
+  for (const directory of ancestorDirectories(startDirectory, { includeStart: false })) {
+    if (isFile(path.join(directory, "package.json"))) return directory;
+    if (isProjectBoundary(directory)) return null;
+  }
+
+  return null;
+};
diff --git a/packages/core/src/project-info/resolve-installed-react-version.ts b/packages/core/src/project-info/resolve-installed-react-version.ts
new file mode 100644
index 0000000000..c43da4a646
--- /dev/null
+++ b/packages/core/src/project-info/resolve-installed-react-version.ts
@@ -0,0 +1,63 @@
+import * as path from "node:path";
+import { ancestorDirectories } from "../utils/ancestor-directories.js";
+import { isProjectBoundary } from "../utils/is-project-boundary.js";
+import { isFile } from "./utils/is-file.js";
+import { readPackageJson } from "./read-package-json.js";
+
+/**
+ * Last-resort React detection: locate React the way Node's `node_modules`
+ * resolution would from `directory` — check each `node_modules/react` up the
+ * tree — but bounded to the enclosing repo so a globally installed React can't
+ * masquerade as the project's version. Stops at (and including) the nearest
+ * project boundary — the git root or a monorepo root — and returns the first
+ * installed `version`.
+ *
+ * Makes "React is installed and importable" ⇒ "React is detected" an invariant
+ * for packages whose only React declaration is a version-less spec
+ * (`workspace:*`, `*`, a dist-tag) or where React lives solely in a hoisted
+ * `node_modules` the declaration walks never reach — the profile of a component
+ * package inside a monorepo. Matching the `node_modules/react` entry rather than
+ * its realpath means a project whose `node_modules` is symlinked elsewhere (a
+ * Docker volume, a shared store) still counts, while a global install outside
+ * the repo does not.
+ *
+ * Returns `null` when React isn't installed within the repo or its package.json
+ * carries no version string. A tree with no boundary marker at all bounds the
+ * search to `directory`, so a dependency hoisted above the scanned package there
+ * is conservatively not adopted.
+ */
+/**
+ * The nearest enclosing project boundary (git root or monorepo root), or
+ * `directory` itself when the scan target sits outside any repo. Bounds the
+ * node_modules walk so a React hoisted anywhere inside the repo counts, but a
+ * React in an ancestor above the repo — a home-directory or global
+ * `node_modules` — can't leak in.
+ */
+const findContainmentRoot = (directory: string): string => {
+  for (const ancestorDirectory of ancestorDirectories(directory, { includeStart: true })) {
+    if (isProjectBoundary(ancestorDirectory)) return ancestorDirectory;
+  }
+  return directory;
+};
+
+export const resolveInstalledReactVersion = (directory: string): string | null => {
+  const containmentRoot = findContainmentRoot(directory);
+
+  for (const ancestorDirectory of ancestorDirectories(directory, { includeStart: true })) {
+    const reactPackageJsonPath = path.join(
+      ancestorDirectory,
+      "node_modules",
+      "react",
+      "package.json",
+    );
+    if (isFile(reactPackageJsonPath)) {
+      const installedVersion = readPackageJson(reactPackageJsonPath).version;
+      return typeof installedVersion === "string" ? installedVersion : null;
+    }
+    // Stop after the containment root — its own node_modules (the hoist target)
+    // was just checked, so anything higher is outside the repo.
+    if (ancestorDirectory === containmentRoot) return null;
+  }
+
+  return null;
+};
diff --git a/packages/core/src/utils/ancestor-directories.ts b/packages/core/src/utils/ancestor-directories.ts
new file mode 100644
index 0000000000..124f113121
--- /dev/null
+++ b/packages/core/src/utils/ancestor-directories.ts
@@ -0,0 +1,23 @@
+import * as path from "node:path";
+
+/**
+ * The chain of ancestor directories of `startDirectory`, nearest first, up to
+ * and including the filesystem root. With `includeStart`, the chain begins at
+ * `startDirectory` itself; otherwise at its parent. The one place the "walk up
+ * the tree" traversal is expressed, so each caller adds only its own match /
+ * stop policy instead of re-deriving the `path.dirname` loop.
+ */
+export const ancestorDirectories = (
+  startDirectory: string,
+  { includeStart }: { includeStart: boolean },
+): string[] => {
+  const directories: string[] = [];
+  let currentDirectory = includeStart ? startDirectory : path.dirname(startDirectory);
+
+  while (true) {
+    directories.push(currentDirectory);
+    const parentDirectory = path.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) return directories;
+    currentDirectory = parentDirectory;
+  }
+};
diff --git a/packages/core/tests/discover-project.test.ts b/packages/core/tests/discover-project.test.ts
index 025374d7ed..2f5b014521 100644
--- a/packages/core/tests/discover-project.test.ts
+++ b/packages/core/tests/discover-project.test.ts
@@ -899,6 +899,147 @@ describe("listWorkspacePackages", () => {
   });
 });
 
+describe("discoverProject — node-resolution React fallback", () => {
+  const writeInstalledReact = (rootDirectory: string, version: string): void => {
+    const reactDirectory = path.join(rootDirectory, "node_modules", "react");
+    fs.mkdirSync(reactDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(reactDirectory, "package.json"),
+      JSON.stringify({ name: "react", version, main: "index.js" }),
+    );
+    fs.writeFileSync(path.join(reactDirectory, "index.js"), "module.exports = {};\n");
+  };
+
+  it("resolves the installed React version when the declaration is version-less", () => {
+    const projectDirectory = path.join(tempDirectory, "react-workspace-protocol-installed");
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDirectory, "package.json"),
+      JSON.stringify({ name: "widget", dependencies: { react: "workspace:*" } }),
+    );
+    writeInstalledReact(projectDirectory, "19.1.0");
+
+    const projectInfo = discoverProject(projectDirectory);
+    expect(projectInfo.reactVersion).toBe("19.1.0");
+    expect(projectInfo.reactMajorVersion).toBe(19);
+  });
+
+  it("detects React hoisted into an enclosing node_modules with no declaration", () => {
+    const repositoryRoot = path.join(tempDirectory, "hoisted-react-repo");
+    const packageDirectory = path.join(repositoryRoot, "packages", "widget");
+    fs.mkdirSync(path.join(repositoryRoot, ".git"), { recursive: true });
+    fs.mkdirSync(packageDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(packageDirectory, "package.json"),
+      JSON.stringify({ name: "widget" }),
+    );
+    writeInstalledReact(repositoryRoot, "18.3.1");
+
+    const projectInfo = discoverProject(packageDirectory);
+    expect(projectInfo.reactVersion).toBe("18.3.1");
+    expect(projectInfo.reactMajorVersion).toBe(18);
+  });
+
+  it("does not adopt a React installed outside the enclosing repo boundary", () => {
+    const outsideDirectory = path.join(tempDirectory, "containment-outside");
+    const repositoryRoot = path.join(outsideDirectory, "repo");
+    fs.mkdirSync(path.join(repositoryRoot, ".git"), { recursive: true });
+    fs.writeFileSync(path.join(repositoryRoot, "package.json"), JSON.stringify({ name: "repo" }));
+    // React lives one level ABOVE the git root, so the guard rejects it.
+    writeInstalledReact(outsideDirectory, "18.0.0");
+
+    const projectInfo = discoverProject(repositoryRoot);
+    expect(projectInfo.reactVersion).toBeNull();
+    expect(projectInfo.reactMajorVersion).toBeNull();
+  });
+
+  it("leaves a parseable peer range untouched even when a different React is installed", () => {
+    const projectDirectory = path.join(tempDirectory, "peer-range-installed");
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDirectory, "package.json"),
+      JSON.stringify({
+        name: "component-lib",
+        peerDependencies: { react: "^18.0.0 || ^19.0.0" },
+      }),
+    );
+    writeInstalledReact(projectDirectory, "19.5.0");
+
+    const projectInfo = discoverProject(projectDirectory);
+    expect(projectInfo.reactVersion).toBe("^18.0.0 || ^19.0.0");
+    expect(projectInfo.reactMajorVersion).toBe(18);
+  });
+
+  it("does not override a concrete declared version with a different install", () => {
+    const projectDirectory = path.join(tempDirectory, "concrete-not-overridden");
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDirectory, "package.json"),
+      JSON.stringify({ name: "app", dependencies: { react: "18.2.0" } }),
+    );
+    writeInstalledReact(projectDirectory, "19.9.9");
+
+    // The declared concrete version parses to a major, so the fallback stays out.
+    expect(discoverProject(projectDirectory).reactVersion).toBe("18.2.0");
+  });
+
+  it("detects React when the project's node_modules is symlinked outside the repo", () => {
+    // Docker-volume / shared-store shape: node_modules is a symlink to a
+    // directory outside the working tree, but it is still the project's install.
+    const storeDirectory = path.join(tempDirectory, "symlink-store");
+    const reactInStore = path.join(storeDirectory, "react");
+    fs.mkdirSync(reactInStore, { recursive: true });
+    fs.writeFileSync(
+      path.join(reactInStore, "package.json"),
+      JSON.stringify({ name: "react", version: "19.0.0" }),
+    );
+    const repositoryRoot = path.join(tempDirectory, "symlink-repo");
+    fs.mkdirSync(path.join(repositoryRoot, ".git"), { recursive: true });
+    fs.writeFileSync(
+      path.join(repositoryRoot, "package.json"),
+      JSON.stringify({ name: "repo", dependencies: { react: "*" } }),
+    );
+    fs.symlinkSync(storeDirectory, path.join(repositoryRoot, "node_modules"));
+
+    expect(discoverProject(repositoryRoot).reactVersion).toBe("19.0.0");
+  });
+
+  it("does not walk to a global node_modules when the scan tree has no boundary", () => {
+    // No git root and no workspace marker: the search floors at the scanned
+    // package, so a React hoisted above it isn't adopted.
+    const parentDirectory = path.join(tempDirectory, "no-boundary-parent");
+    fs.mkdirSync(parentDirectory, { recursive: true });
+    writeInstalledReact(parentDirectory, "18.0.0");
+    const packageDirectory = path.join(parentDirectory, "pkg");
+    fs.mkdirSync(packageDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(packageDirectory, "package.json"),
+      JSON.stringify({ name: "pkg", dependencies: { react: "*" } }),
+    );
+
+    // The fallback fires (`*` has no major) but floors at the package, so the
+    // hoisted `18.0.0` is not adopted — the declared `*` is left in place.
+    const projectInfo = discoverProject(packageDirectory);
+    expect(projectInfo.reactVersion).toBe("*");
+    expect(projectInfo.reactMajorVersion).toBeNull();
+  });
+
+  it("ignores an installed React whose package.json has no usable version", () => {
+    const projectDirectory = path.join(tempDirectory, "installed-no-version");
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDirectory, "package.json"),
+      JSON.stringify({ name: "app", dependencies: { react: "*" } }),
+    );
+    const reactDirectory = path.join(projectDirectory, "node_modules", "react");
+    fs.mkdirSync(reactDirectory, { recursive: true });
+    fs.writeFileSync(path.join(reactDirectory, "package.json"), JSON.stringify({ name: "react" }));
+
+    // `react: "*"` parses to no major and the install has no version → stays as-is.
+    expect(discoverProject(projectDirectory).reactVersion).toBe("*");
+  });
+});
+
 const tempDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "react-doctor-discover-test-"));
 
 afterAll(() => {
@@ -952,6 +1093,40 @@ describe("discoverProject without a package.json", () => {
     expect(projectInfo.rootDirectory).toBe(subdirectory);
   });
 
+  it("inherits React detection from a plain (non-monorepo) enclosing app root", () => {
+    const appRoot = path.join(tempDirectory, "plain-react-app");
+    const subdirectory = path.join(appRoot, "src", "components");
+    fs.mkdirSync(subdirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(appRoot, "package.json"),
+      JSON.stringify({ name: "plain-react-app", dependencies: { react: "^19.0.0" } }),
+    );
+    fs.writeFileSync(path.join(subdirectory, "button.tsx"), "export const ok = true;\n");
+
+    // `src/components` has no package.json and the app is not a workspace root,
+    // so the nearest-ancestor walk adopts the app root to keep React on.
+    const projectInfo = discoverProject(subdirectory);
+    expect(projectInfo.reactVersion).toBe("^19.0.0");
+    expect(projectInfo.rootDirectory).toBe(subdirectory);
+  });
+
+  it("does not escape a boundary scan directory to an ancestor package.json", () => {
+    const outsideDirectory = path.join(tempDirectory, "boundary-escape-outside");
+    const repositoryRoot = path.join(outsideDirectory, "repo");
+    fs.mkdirSync(path.join(repositoryRoot, ".git"), { recursive: true });
+    // An unrelated React package.json ABOVE the repo boundary.
+    fs.writeFileSync(
+      path.join(outsideDirectory, "package.json"),
+      JSON.stringify({ name: "outside", dependencies: { react: "^19.0.0" } }),
+    );
+    // The repo root is a git boundary with no package.json of its own, just source.
+    fs.writeFileSync(path.join(repositoryRoot, "index.ts"), "export const ok = true;\n");
+
+    const projectInfo = discoverProject(repositoryRoot);
+    expect(projectInfo.reactVersion).toBeNull();
+    expect(projectInfo.rootDirectory).toBe(repositoryRoot);
+  });
+
   it("throws PackageJsonNotFoundError for an empty directory with nothing to scan", () => {
     const emptyDirectory = path.join(tempDirectory, "truly-empty");
     fs.mkdirSync(emptyDirectory, { recursive: true });

From 1880b152e4d6aedd5c06cf2ca51783e53cfb4004 Mon Sep 17 00:00:00 2001
From: "devin-ai-integration[bot]"
 <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 4 Jul 2026 21:20:28 -0700
Subject: [PATCH 32/33] fix(oxlint-plugin): scope useEffectEvent effect-event
 rules to React imports (#1072)

---
 .changeset/non-react-use-effect-event.md      |  5 ++
 .../src/plugin/constants/react.ts             | 13 +++++
 .../rules-of-hooks.regressions.test.ts        | 46 ++++++++++++++++++
 .../rules/react-builtins/rules-of-hooks.ts    | 27 ++++++++++-
 ...o-effect-event-in-deps.regressions.test.ts | 47 +++++++++++++++++++
 .../no-effect-event-in-deps.ts                |  7 +++
 .../is-imported-from-non-react-module.ts      | 20 ++++++++
 7 files changed, 164 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/non-react-use-effect-event.md
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.regressions.test.ts
 create mode 100644 packages/oxlint-plugin-react-doctor/src/plugin/utils/is-imported-from-non-react-module.ts

diff --git a/.changeset/non-react-use-effect-event.md b/.changeset/non-react-use-effect-event.md
new file mode 100644
index 0000000000..17620ce896
--- /dev/null
+++ b/.changeset/non-react-use-effect-event.md
@@ -0,0 +1,5 @@
+---
+"oxlint-plugin-react-doctor": patch
+---
+
+Stop `rules-of-hooks` and `no-effect-event-in-deps` from firing on a `useEffectEvent` imported from a non-React package. Both rules match the hook by NAME to stay in parity with eslint-plugin-react-hooks (whose fixtures call a bare global), so a same-named custom hook — e.g. `@rocket.chat/fuselage-hooks`'s `useEffectEvent`, a stable-callback helper designed to be stored and passed as props — was flagged as if it were React's experimental effect event ("only works when called from Effects", "re-runs your effect every render"). Detection is now disambiguated by import source: a `useEffectEvent` explicitly imported from a module outside `REACT_RUNTIME_MODULE_SOURCES` (`react`, `react-dom`, `preact/compat`, `preact/hooks`) is left alone, while React's own and bare/unimported names keep their existing behavior.
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/constants/react.ts b/packages/oxlint-plugin-react-doctor/src/plugin/constants/react.ts
index e10dae97a2..f1beec5569 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/constants/react.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/constants/react.ts
@@ -3,6 +3,19 @@ import { TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES } from "./dom.js";
 
 export const INDEX_PARAMETER_NAMES = new Set(["index", "idx", "i"]);
 
+// Module specifiers whose exports are React's own runtime symbols. Effect-event
+// rules match `useEffectEvent` by NAME (to stay in parity with
+// eslint-plugin-react-hooks, whose fixtures call a bare global), so a same-named
+// hook imported from another package — e.g. `@rocket.chat/fuselage-hooks`, whose
+// `useEffectEvent` is a stable-callback helper meant to be stored and passed as
+// props — is disambiguated by import source before React's semantics apply.
+export const REACT_RUNTIME_MODULE_SOURCES = new Set([
+  "react",
+  "react-dom",
+  "preact/compat",
+  "preact/hooks",
+]);
+
 export const LOADING_STATE_PATTERN = /^(?:isLoading|isPending)$/;
 
 export const STABLE_HOOK_WRAPPERS = new Set(["useState", "useMemo", "useRef"]);
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts
index d3aa0faf2a..ed69214620 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.regressions.test.ts
@@ -341,3 +341,49 @@ describe("react-builtins/rules-of-hooks — regressions: local non-hook use* cal
     expect(result.diagnostics).toHaveLength(1);
   });
 });
+
+describe("react-builtins/rules-of-hooks — regressions: same-named non-React useEffectEvent", () => {
+  it("does not flag a useEffectEvent imported from a non-React package passed as a prop", () => {
+    const result = runTsx(`
+      import { useEffectEvent } from "@rocket.chat/fuselage-hooks";
+      const MyComponent = ({ onDone }) => {
+        const handleChange = useEffectEvent(() => onDone());
+        return <Child onChange={handleChange} />;
+      };
+    `);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("does not flag a non-React useEffectEvent stored in a variable and referenced later", () => {
+    const result = runTsx(`
+      import { useEffectEvent } from "@rocket.chat/fuselage-hooks";
+      const MyComponent = ({ value }) => {
+        const handler = useEffectEvent(() => value);
+        const wrapped = handler;
+        return <button onClick={wrapped}>go</button>;
+      };
+    `);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags React's useEffectEvent when passed around", () => {
+    const result = runTsx(`
+      import { useEffectEvent } from "react";
+      const MyComponent = ({ onDone }) => {
+        const handleChange = useEffectEvent(() => onDone());
+        return <Child onChange={handleChange} />;
+      };
+    `);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
+  it("still flags a bare/unimported useEffectEvent when passed around (parity)", () => {
+    const result = runTsx(`
+      const MyComponent = ({ onDone }) => {
+        const handleChange = useEffectEvent(() => onDone());
+        return <Child onChange={handleChange} />;
+      };
+    `);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts
index 2eaf31f886..331fc8e43f 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts
@@ -7,6 +7,7 @@ import { isReactComponentOrHookName } from "../../utils/is-react-component-or-ho
 import { isReactHookName } from "../../utils/is-react-hook-name.js";
 import { REACT_HOC_NAMES } from "../../constants/react.js";
 import { isFunctionLike } from "../../utils/is-function-like.js";
+import { isImportedFromNonReactModule } from "../../utils/is-imported-from-non-react-module.js";
 import { isReactHocCallbackArgument } from "../../utils/is-react-hoc-callback-argument.js";
 import { walkAst } from "../../utils/walk-ast.js";
 
@@ -626,6 +627,25 @@ const isUseEffectEventSymbol = (symbol: SymbolDescriptor): boolean => {
   return getHookNameFromCallee(initializer.callee) === "useEffectEvent";
 };
 
+// React's effect-event semantics (call-only, never stored or passed around)
+// apply to React's own `useEffectEvent`. A same-named hook EXPLICITLY imported
+// from another package — e.g. `@rocket.chat/fuselage-hooks`, whose
+// `useEffectEvent` is a stable-callback helper designed to be passed as props —
+// carries different semantics, so applying these reports would be a false
+// positive. A bare/unimported `useEffectEvent` is still treated as React's to
+// preserve parity with eslint-plugin-react-hooks.
+const isNonReactEffectEventCallee = (callee: EsTreeNode, contextNode: EsTreeNode): boolean =>
+  isNodeOfType(callee, "Identifier") && isImportedFromNonReactModule(contextNode, callee.name);
+
+const isNonReactEffectEventSymbol = (
+  symbol: SymbolDescriptor,
+  contextNode: EsTreeNode,
+): boolean => {
+  const initializer = symbol.initializer;
+  if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+  return isNonReactEffectEventCallee(initializer.callee, contextNode);
+};
+
 const findEnclosingComponentOrHookFunction = (node: EsTreeNode): EsTreeNode | null => {
   let current: EsTreeNode | null | undefined = node.parent;
   while (current) {
@@ -720,7 +740,11 @@ export const rulesOfHooks = defineRule({
         if (!hookContext) return;
         const { hookName } = hookContext;
 
-        if (hookName === "useEffectEvent" && !isUseEffectEventInitializer(node)) {
+        if (
+          hookName === "useEffectEvent" &&
+          !isUseEffectEventInitializer(node) &&
+          !isNonReactEffectEventCallee(node.callee, node)
+        ) {
           context.report({ node: node.callee, message: buildEffectEventPassedDownMessage() });
           return;
         }
@@ -848,6 +872,7 @@ export const rulesOfHooks = defineRule({
         const reference = context.scopes.referenceFor(node);
         const symbol = reference?.resolvedSymbol;
         if (!symbol || !isUseEffectEventSymbol(symbol)) return;
+        if (isNonReactEffectEventSymbol(symbol, node)) return;
         if (!isSameComponentOrHookScope(symbol, node)) return;
         if (isInsideAllowedEffectEventCallback(node, additionalEffectHooksRegex)) return;
 
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.regressions.test.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.regressions.test.ts
new file mode 100644
index 0000000000..9567d4006f
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.regressions.test.ts
@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vite-plus/test";
+import { runRule } from "../../../test-utils/run-rule.js";
+import { noEffectEventInDeps } from "./no-effect-event-in-deps.js";
+
+const runTsx = (code: string) => runRule(noEffectEventInDeps, code, { filename: "fixture.tsx" });
+
+describe("no-effect-event-in-deps — regressions: same-named non-React useEffectEvent", () => {
+  it("does not flag a useEffectEvent imported from a non-React package listed in deps", () => {
+    const result = runTsx(`
+      import { useEffect } from "react";
+      import { useEffectEvent } from "@rocket.chat/fuselage-hooks";
+      const MyComponent = ({ value }) => {
+        const onTick = useEffectEvent(() => value);
+        useEffect(() => { onTick(); }, [onTick]);
+        return null;
+      };
+    `);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("still flags React's useEffectEvent listed in deps", () => {
+    const result = runTsx(`
+      import { useEffect, useEffectEvent } from "react";
+      const MyComponent = ({ value }) => {
+        const onTick = useEffectEvent(() => value);
+        useEffect(() => { onTick(); }, [onTick]);
+        return null;
+      };
+    `);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0]?.message).toBe(
+      'Listing "onTick" in the deps re-runs your effect every render & defeats useEffectEvent.',
+    );
+  });
+
+  it("still flags a bare/unimported useEffectEvent listed in deps (parity)", () => {
+    const result = runTsx(`
+      import { useEffect } from "react";
+      const MyComponent = ({ value }) => {
+        const onTick = useEffectEvent(() => value);
+        useEffect(() => { onTick(); }, [onTick]);
+        return null;
+      };
+    `);
+    expect(result.diagnostics).toHaveLength(1);
+  });
+});
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts
index a02922e241..5b2bac418c 100644
--- a/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts
@@ -5,6 +5,7 @@ import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { isComponentAssignment } from "../../utils/is-component-assignment.js";
 import { isHookCall } from "../../utils/is-hook-call.js";
+import { isImportedFromNonReactModule } from "../../utils/is-imported-from-non-react-module.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { isUppercaseName } from "../../utils/is-uppercase-name.js";
 import type { RuleContext } from "../../utils/rule-context.js";
@@ -103,6 +104,12 @@ export const noEffectEventInDeps = defineRule({
         const initializer = declaratorNode.init;
         if (!initializer || !isNodeOfType(initializer, "CallExpression")) return;
         if (!isHookCall(initializer, "useEffectEvent")) return;
+        if (
+          isNodeOfType(initializer.callee, "Identifier") &&
+          isImportedFromNonReactModule(declaratorNode, initializer.callee.name)
+        ) {
+          return;
+        }
         componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
       },
     });
diff --git a/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-imported-from-non-react-module.ts b/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-imported-from-non-react-module.ts
new file mode 100644
index 0000000000..4e3dcf97d7
--- /dev/null
+++ b/packages/oxlint-plugin-react-doctor/src/plugin/utils/is-imported-from-non-react-module.ts
@@ -0,0 +1,20 @@
+import { REACT_RUNTIME_MODULE_SOURCES } from "../constants/react.js";
+import type { EsTreeNode } from "./es-tree-node.js";
+import { getImportSourceForName } from "./find-import-source-for-name.js";
+
+// True when `localIdentifierName` is EXPLICITLY imported into the enclosing
+// module from a package that is not a React runtime — e.g. a homegrown
+// `useEffectEvent` from "@rocket.chat/fuselage-hooks", which is a stable-callback
+// helper meant to be stored and passed as props rather than React's experimental
+// effect event. Effect-event rules key off the hook NAME (to stay in parity with
+// eslint-plugin-react-hooks, whose fixtures call a bare global), so a same-named
+// custom hook would otherwise be a false positive. Returns false for an
+// unimported bare/global name so that parity behaviour is preserved.
+export const isImportedFromNonReactModule = (
+  contextNode: EsTreeNode,
+  localIdentifierName: string,
+): boolean => {
+  const importSource = getImportSourceForName(contextNode, localIdentifierName);
+  if (importSource === null) return false;
+  return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
+};

From bcc2e6a30258052fe6e2653bfcd56e28d1f9f7e2 Mon Sep 17 00:00:00 2001
From: wan9chi <dk4rest@gmail.com>
Date: Tue, 7 Jul 2026 17:14:16 +0800
Subject: [PATCH 33/33] test: vite-plus prerelease 0.2.3 smoke test

Upgrade to 0.0.0-commit.fd1ae7eab160c92f3907a20e80e92d2e87403c20 via vp migrate; deps resolve through the registry
bridge (.npmrc). Draft, do not merge.
---
 .npmrc                                        |    2 +
 package.json                                  |   17 +-
 packages/core/package.json                    |    4 +-
 .../issue-920-object-prototype-keys.test.ts   |    2 +-
 packages/core/tests/rule-key-aliases.test.ts  |    2 +-
 .../fixtures/config-entry-seed/vite.config.ts |    2 +-
 .../config-exclusion/vitest.config.ts         |    2 +-
 .../src/settings-panel.test.tsx               |    2 +-
 .../__tests__/example.test.ts                 |    2 +-
 .../fixtures/tsdown-entry/tsdown.config.ts    |    2 +-
 .../vite-resolve-alias/vite.config.ts         |    2 +-
 .../vitest-automock/__tests__/server.test.ts  |    2 +-
 .../vitest-automock/__tests__/utils.test.ts   |    2 +-
 .../fixtures/vitest-coverage/vitest.config.ts |    2 +-
 .../fixtures/vitest-custom/vitest.config.ts   |    2 +-
 .../vitest-override-target/vitest.config.ts   |    2 +-
 .../fixtures/vitest-setup/vitest.config.ts    |    2 +-
 .../oxlint-plugin-react-doctor/package.json   |    3 +-
 packages/react-doctor/package.json            |    4 +-
 pnpm-lock.yaml                                | 7190 -----------------
 pnpm-workspace.yaml                           |   31 +-
 21 files changed, 54 insertions(+), 7225 deletions(-)
 delete mode 100644 pnpm-lock.yaml

diff --git a/.npmrc b/.npmrc
index bf2e7648b0..a2db84ed3d 100644
--- a/.npmrc
+++ b/.npmrc
@@ -1 +1,3 @@
 shamefully-hoist=true
+# vite-plus preview build registry bridge (auto-added by vp)
+registry=https://registry-bridge.viteplus.dev/
diff --git a/package.json b/package.json
index 45134b79b4..81082f02dc 100644
--- a/package.json
+++ b/package.json
@@ -44,23 +44,12 @@
     "ts-json-schema-generator": "^2.9.0",
     "turbo": "^2.9.7",
     "typescript": "^6.0.3",
-    "vite-plus": "^0.1.15"
+    "vite": "catalog:",
+    "vite-plus": "catalog:"
   },
   "engines": {
     "node": "^20.19.0 || >=22.13.0",
     "pnpm": ">=8"
   },
-  "packageManager": "pnpm@10.29.1",
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "@parcel/watcher",
-      "@sentry/cli",
-      "esbuild",
-      "unrs-resolver"
-    ],
-    "overrides": {
-      "oxlint": ">=1.66.0 <1.67.0",
-      "oxlint-tsgolint": "^0.23.0"
-    }
-  }
+  "packageManager": "pnpm@10.29.1"
 }
diff --git a/packages/core/package.json b/packages/core/package.json
index b5374a2752..a11e7e7ad6 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -28,7 +28,6 @@
     "effect": "4.0.0-beta.70",
     "eslint-plugin-react-hooks": "^7.1.1",
     "jiti": "^2.7.0",
-    "oxlint": ">=1.66.0 <1.67.0",
     "oxlint-plugin-react-doctor": "workspace:*",
     "picomatch": "^4.0.4",
     "semver": "^7.7.4",
@@ -38,7 +37,8 @@
     "@effect/vitest": "4.0.0-beta.70",
     "@types/node": "^25.6.0",
     "@types/picomatch": "^4.0.3",
-    "@types/semver": "^7.7.1"
+    "@types/semver": "^7.7.1",
+    "vitest": "catalog:"
   },
   "engines": {
     "node": "^20.19.0 || >=22.13.0"
diff --git a/packages/core/tests/regressions/issue-920-object-prototype-keys.test.ts b/packages/core/tests/regressions/issue-920-object-prototype-keys.test.ts
index 7d1bfb66bd..a563a8449f 100644
--- a/packages/core/tests/regressions/issue-920-object-prototype-keys.test.ts
+++ b/packages/core/tests/regressions/issue-920-object-prototype-keys.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 import { detectForeignDisableNearMiss } from "../../src/detect-foreign-disable-near-miss.js";
 
 describe("regression: issue #920 - Object.prototype key collision in disable comments", () => {
diff --git a/packages/core/tests/rule-key-aliases.test.ts b/packages/core/tests/rule-key-aliases.test.ts
index 851e7eeca0..5d1689bb18 100644
--- a/packages/core/tests/rule-key-aliases.test.ts
+++ b/packages/core/tests/rule-key-aliases.test.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "vite-plus/test";
 import {
   isSameRuleKey,
   getEquivalentRuleKeys,
diff --git a/packages/deslop-js/tests/fixtures/config-entry-seed/vite.config.ts b/packages/deslop-js/tests/fixtures/config-entry-seed/vite.config.ts
index cdefdb334f..9f4c7065a6 100644
--- a/packages/deslop-js/tests/fixtures/config-entry-seed/vite.config.ts
+++ b/packages/deslop-js/tests/fixtures/config-entry-seed/vite.config.ts
@@ -1,4 +1,4 @@
-import { defineConfig } from "vite";
+import { defineConfig } from "vite-plus";
 import { myPlugin } from "./src/vite-plugin";
 
 export default defineConfig({
diff --git a/packages/deslop-js/tests/fixtures/config-exclusion/vitest.config.ts b/packages/deslop-js/tests/fixtures/config-exclusion/vitest.config.ts
index 720aeb7176..7510ccc324 100644
--- a/packages/deslop-js/tests/fixtures/config-exclusion/vitest.config.ts
+++ b/packages/deslop-js/tests/fixtures/config-exclusion/vitest.config.ts
@@ -1,2 +1,2 @@
-import { defineConfig } from "vitest/config";
+import { defineConfig } from "vite-plus";
 export default defineConfig({});
diff --git a/packages/deslop-js/tests/fixtures/default-import-named-export/src/settings-panel.test.tsx b/packages/deslop-js/tests/fixtures/default-import-named-export/src/settings-panel.test.tsx
index f0606479cf..1f429a3ff2 100644
--- a/packages/deslop-js/tests/fixtures/default-import-named-export/src/settings-panel.test.tsx
+++ b/packages/deslop-js/tests/fixtures/default-import-named-export/src/settings-panel.test.tsx
@@ -1,5 +1,5 @@
 import SettingsPanel from "./settings-panel";
-import { describe, it } from "vitest";
+import { describe, it } from "vite-plus/test";
 
 describe("SettingsPanel", () => {
   it("loads", () => {
diff --git a/packages/deslop-js/tests/fixtures/test-mock-import/__tests__/example.test.ts b/packages/deslop-js/tests/fixtures/test-mock-import/__tests__/example.test.ts
index 27b700ae54..0082821492 100644
--- a/packages/deslop-js/tests/fixtures/test-mock-import/__tests__/example.test.ts
+++ b/packages/deslop-js/tests/fixtures/test-mock-import/__tests__/example.test.ts
@@ -1,4 +1,4 @@
-import { vi, describe, it, expect } from "vitest";
+import { vi, describe, it, expect } from "vite-plus/test";
 vi.mock("../src/mocked-util");
 import { helper } from "../src/index";
 
diff --git a/packages/deslop-js/tests/fixtures/tsdown-entry/tsdown.config.ts b/packages/deslop-js/tests/fixtures/tsdown-entry/tsdown.config.ts
index f6ee00eaf5..bfcdeca89a 100644
--- a/packages/deslop-js/tests/fixtures/tsdown-entry/tsdown.config.ts
+++ b/packages/deslop-js/tests/fixtures/tsdown-entry/tsdown.config.ts
@@ -1,4 +1,4 @@
-import { defineConfig } from "tsdown";
+import { defineConfig } from "vite-plus/pack";
 
 export default defineConfig([
   {
diff --git a/packages/deslop-js/tests/fixtures/vite-resolve-alias/vite.config.ts b/packages/deslop-js/tests/fixtures/vite-resolve-alias/vite.config.ts
index 4ab4ea719a..3deecf7893 100644
--- a/packages/deslop-js/tests/fixtures/vite-resolve-alias/vite.config.ts
+++ b/packages/deslop-js/tests/fixtures/vite-resolve-alias/vite.config.ts
@@ -1,6 +1,6 @@
 import { fileURLToPath, URL } from "node:url";
 import path from "node:path";
-import { defineConfig } from "vite";
+import { defineConfig } from "vite-plus";
 
 export default defineConfig({
   resolve: {
diff --git a/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/server.test.ts b/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/server.test.ts
index d0097b0c7b..f656c1c539 100644
--- a/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/server.test.ts
+++ b/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/server.test.ts
@@ -1,4 +1,4 @@
-import { vi, describe, it, expect } from "vitest";
+import { vi, describe, it, expect } from "vite-plus/test";
 import { fetchData } from "../src/server/api";
 
 vi.mock("../src/server/api");
diff --git a/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/utils.test.ts b/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/utils.test.ts
index 4bd1646009..2b125263dc 100644
--- a/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/utils.test.ts
+++ b/packages/deslop-js/tests/fixtures/vitest-automock/__tests__/utils.test.ts
@@ -1,4 +1,4 @@
-import { vi, describe, it, expect } from "vitest";
+import { vi, describe, it, expect } from "vite-plus/test";
 import { formatDate } from "../src/utils/helper";
 
 vi.mock("../src/utils/helper", () => ({
diff --git a/packages/deslop-js/tests/fixtures/vitest-coverage/vitest.config.ts b/packages/deslop-js/tests/fixtures/vitest-coverage/vitest.config.ts
index e98a6161db..75375d4182 100644
--- a/packages/deslop-js/tests/fixtures/vitest-coverage/vitest.config.ts
+++ b/packages/deslop-js/tests/fixtures/vitest-coverage/vitest.config.ts
@@ -1,4 +1,4 @@
-import { defineConfig } from "vite";
+import { defineConfig } from "vite-plus";
 
 export default defineConfig({
   test: {
diff --git a/packages/deslop-js/tests/fixtures/vitest-custom/vitest.config.ts b/packages/deslop-js/tests/fixtures/vitest-custom/vitest.config.ts
index 8846ac707f..6542ef3cfa 100644
--- a/packages/deslop-js/tests/fixtures/vitest-custom/vitest.config.ts
+++ b/packages/deslop-js/tests/fixtures/vitest-custom/vitest.config.ts
@@ -1,4 +1,4 @@
-import { defineConfig } from "vitest/config";
+import { defineConfig } from "vite-plus";
 
 export default defineConfig({
   test: {
diff --git a/packages/deslop-js/tests/fixtures/vitest-override-target/vitest.config.ts b/packages/deslop-js/tests/fixtures/vitest-override-target/vitest.config.ts
index 8fb6f2dcff..8ffe822bcd 100644
--- a/packages/deslop-js/tests/fixtures/vitest-override-target/vitest.config.ts
+++ b/packages/deslop-js/tests/fixtures/vitest-override-target/vitest.config.ts
@@ -1,3 +1,3 @@
-import { defineConfig } from "vitest/config";
+import { defineConfig } from "vite-plus";
 
 export default defineConfig({});
diff --git a/packages/deslop-js/tests/fixtures/vitest-setup/vitest.config.ts b/packages/deslop-js/tests/fixtures/vitest-setup/vitest.config.ts
index 51e8ce4c1b..a7de99c165 100644
--- a/packages/deslop-js/tests/fixtures/vitest-setup/vitest.config.ts
+++ b/packages/deslop-js/tests/fixtures/vitest-setup/vitest.config.ts
@@ -1,4 +1,4 @@
-import { defineConfig } from "vitest/config";
+import { defineConfig } from "vite-plus";
 
 export default defineConfig({
   test: {
diff --git a/packages/oxlint-plugin-react-doctor/package.json b/packages/oxlint-plugin-react-doctor/package.json
index 05e3a7847d..37802e85d9 100644
--- a/packages/oxlint-plugin-react-doctor/package.json
+++ b/packages/oxlint-plugin-react-doctor/package.json
@@ -59,7 +59,8 @@
     "oxc-parser": "^0.135.0"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0"
+    "@types/node": "^25.6.0",
+    "vitest": "catalog:"
   },
   "engines": {
     "node": "^20.19.0 || >=22.13.0"
diff --git a/packages/react-doctor/package.json b/packages/react-doctor/package.json
index 483d53116d..166cc2b62b 100644
--- a/packages/react-doctor/package.json
+++ b/packages/react-doctor/package.json
@@ -65,7 +65,6 @@
     "eslint-plugin-react-hooks": "^7.1.1",
     "jiti": "^2.7.0",
     "magicast": "^0.5.3",
-    "oxlint": ">=1.66.0 <1.67.0",
     "oxlint-plugin-react-doctor": "workspace:*",
     "prompts": "^2.4.2",
     "typescript": ">=5.0.4 <6",
@@ -82,7 +81,8 @@
     "@types/prompts": "^2.4.9",
     "@xterm/headless": "^6.0.0",
     "commander": "^14.0.3",
-    "ora": "^9.4.0"
+    "ora": "^9.4.0",
+    "vitest": "catalog:"
   },
   "engines": {
     "node": "^20.19.0 || >=22.13.0"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
deleted file mode 100644
index d455981fd5..0000000000
--- a/pnpm-lock.yaml
+++ /dev/null
@@ -1,7190 +0,0 @@
-lockfileVersion: '9.0'
-
-settings:
-  autoInstallPeers: true
-  excludeLinksFromLockfile: false
-
-overrides:
-  oxlint: '>=1.66.0 <1.67.0'
-  oxlint-tsgolint: ^0.23.0
-
-importers:
-
-  .:
-    devDependencies:
-      '@changesets/changelog-github':
-        specifier: ^0.7.0
-        version: 0.7.0
-      '@changesets/cli':
-        specifier: ^2.31.0
-        version: 2.31.0(@types/node@25.6.0)
-      '@rayhanadev/truffler':
-        specifier: ^0.4.2
-        version: 0.4.2
-      '@sentry/cli':
-        specifier: ^3.4.3
-        version: 3.4.3
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-      '@voidzero-dev/vite-plus-core':
-        specifier: ^0.1.15
-        version: 0.1.20(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)
-      cross-env:
-        specifier: ^10.1.0
-        version: 10.1.0
-      ts-json-schema-generator:
-        specifier: ^2.9.0
-        version: 2.9.0
-      turbo:
-        specifier: ^2.9.7
-        version: 2.9.7
-      typescript:
-        specifier: ^6.0.3
-        version: 6.0.3
-      vite-plus:
-        specifier: ^0.1.15
-        version: 0.1.20(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))(yaml@2.9.0)
-
-  packages/api:
-    dependencies:
-      '@react-doctor/core':
-        specifier: workspace:*
-        version: link:../core
-      effect:
-        specifier: 4.0.0-beta.70
-        version: 4.0.0-beta.70
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-
-  packages/core:
-    dependencies:
-      '@effect/platform-node-shared':
-        specifier: 4.0.0-beta.70
-        version: 4.0.0-beta.70(effect@4.0.0-beta.70)
-      confbox:
-        specifier: ^0.2.4
-        version: 0.2.4
-      deslop-js:
-        specifier: workspace:*
-        version: link:../deslop-js
-      effect:
-        specifier: 4.0.0-beta.70
-        version: 4.0.0-beta.70
-      eslint-plugin-react-hooks:
-        specifier: ^7.1.1
-        version: 7.1.1(eslint@9.39.2(jiti@2.7.0))
-      jiti:
-        specifier: ^2.7.0
-        version: 2.7.0
-      oxlint:
-        specifier: '>=1.66.0 <1.67.0'
-        version: 1.66.0(oxlint-tsgolint@0.23.0)
-      oxlint-plugin-react-doctor:
-        specifier: workspace:*
-        version: link:../oxlint-plugin-react-doctor
-      picomatch:
-        specifier: ^4.0.4
-        version: 4.0.4
-      semver:
-        specifier: ^7.7.4
-        version: 7.7.4
-      typescript:
-        specifier: '>=5.0.4 <7'
-        version: 6.0.3
-    devDependencies:
-      '@effect/vitest':
-        specifier: 4.0.0-beta.70
-        version: 4.0.0-beta.70(effect@4.0.0-beta.70)(vitest@4.1.7(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0)))
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-      '@types/picomatch':
-        specifier: ^4.0.3
-        version: 4.0.3
-      '@types/semver':
-        specifier: ^7.7.1
-        version: 7.7.1
-
-  packages/deslop-cli:
-    dependencies:
-      commander:
-        specifier: ^14.0.3
-        version: 14.0.3
-      deslop-js:
-        specifier: workspace:*
-        version: link:../deslop-js
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-
-  packages/deslop-js:
-    dependencies:
-      '@oxc-project/types':
-        specifier: ^0.132.0
-        version: 0.132.0
-      fast-glob:
-        specifier: ^3.3.3
-        version: 3.3.3
-      minimatch:
-        specifier: ^10.2.5
-        version: 10.2.5
-      oxc-parser:
-        specifier: ^0.132.0
-        version: 0.132.0
-      oxc-resolver:
-        specifier: ^11.19.1
-        version: 11.19.1(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
-      typescript:
-        specifier: '>=5.0.4 <6'
-        version: 5.9.3
-    devDependencies:
-      '@types/minimatch':
-        specifier: ^5.1.2
-        version: 5.1.2
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-      tsx:
-        specifier: ^4.21.0
-        version: 4.22.4
-
-  packages/eslint-plugin-react-doctor:
-    dependencies:
-      oxlint-plugin-react-doctor:
-        specifier: workspace:*
-        version: link:../oxlint-plugin-react-doctor
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-
-  packages/fuzz:
-    dependencies:
-      oxlint-plugin-react-doctor:
-        specifier: workspace:*
-        version: link:../oxlint-plugin-react-doctor
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-      cross-env:
-        specifier: ^10.1.0
-        version: 10.1.0
-
-  packages/language-server:
-    dependencies:
-      '@react-doctor/core':
-        specifier: workspace:*
-        version: link:../core
-      vscode-languageserver:
-        specifier: ^9.0.1
-        version: 9.0.1
-      vscode-languageserver-textdocument:
-        specifier: ^1.0.12
-        version: 1.0.12
-      vscode-uri:
-        specifier: ^3.1.0
-        version: 3.1.0
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-
-  packages/oxlint-plugin-react-doctor:
-    dependencies:
-      '@typescript-eslint/types':
-        specifier: ^8.59.3
-        version: 8.59.3
-      eslint-scope:
-        specifier: ^9.1.2
-        version: 9.1.2
-      eslint-visitor-keys:
-        specifier: ^5.0.1
-        version: 5.0.1
-      oxc-parser:
-        specifier: ^0.135.0
-        version: 0.135.0
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-
-  packages/react-doctor:
-    dependencies:
-      '@babel/code-frame':
-        specifier: ^7.29.0
-        version: 7.29.0
-      '@sentry/node':
-        specifier: ^10.54.0
-        version: 10.54.0
-      agent-install:
-        specifier: 0.0.5
-        version: 0.0.5
-      conf:
-        specifier: ^15.1.0
-        version: 15.1.0
-      confbox:
-        specifier: ^0.2.4
-        version: 0.2.4
-      deslop-js:
-        specifier: workspace:*
-        version: link:../deslop-js
-      eslint-plugin-react-hooks:
-        specifier: ^7.1.1
-        version: 7.1.1(eslint@9.39.2(jiti@2.7.0))
-      jiti:
-        specifier: ^2.7.0
-        version: 2.7.0
-      magicast:
-        specifier: ^0.5.3
-        version: 0.5.3
-      oxlint:
-        specifier: '>=1.66.0 <1.67.0'
-        version: 1.66.0(oxlint-tsgolint@0.23.0)
-      oxlint-plugin-react-doctor:
-        specifier: workspace:*
-        version: link:../oxlint-plugin-react-doctor
-      prompts:
-        specifier: ^2.4.2
-        version: 2.4.2
-      typescript:
-        specifier: '>=5.0.4 <6'
-        version: 5.9.3
-      vscode-languageserver:
-        specifier: ^9.0.1
-        version: 9.0.1
-      vscode-languageserver-textdocument:
-        specifier: ^1.0.12
-        version: 1.0.12
-      vscode-uri:
-        specifier: ^3.1.0
-        version: 3.1.0
-      yaml:
-        specifier: ^2.9.0
-        version: 2.9.0
-    devDependencies:
-      '@react-doctor/api':
-        specifier: workspace:*
-        version: link:../api
-      '@react-doctor/core':
-        specifier: workspace:*
-        version: link:../core
-      '@react-doctor/language-server':
-        specifier: workspace:*
-        version: link:../language-server
-      '@types/babel__code-frame':
-        specifier: ^7.27.0
-        version: 7.27.0
-      '@types/prompts':
-        specifier: ^2.4.9
-        version: 2.4.9
-      '@xterm/headless':
-        specifier: ^6.0.0
-        version: 6.0.0
-      commander:
-        specifier: ^14.0.3
-        version: 14.0.3
-      ora:
-        specifier: ^9.4.0
-        version: 9.4.0
-
-  packages/vscode-react-doctor:
-    dependencies:
-      vscode-languageclient:
-        specifier: ^9.0.1
-        version: 9.0.1
-    devDependencies:
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-      '@types/vscode':
-        specifier: ^1.85.0
-        version: 1.120.0
-      esbuild:
-        specifier: ^0.25.0
-        version: 0.25.12
-      typescript:
-        specifier: ^6.0.3
-        version: 6.0.3
-
-  packages/website:
-    dependencies:
-      '@vercel/analytics':
-        specifier: ^2.0.1
-        version: 2.0.1(next@16.2.4(@opentelemetry/api@1.9.1)(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react@19.2.5)
-      lucide-react:
-        specifier: ^1.14.0
-        version: 1.14.0(react@19.2.5)
-      next:
-        specifier: 16.2.4
-        version: 16.2.4(@opentelemetry/api@1.9.1)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
-      react:
-        specifier: 19.2.5
-        version: 19.2.5
-      react-dom:
-        specifier: 19.2.5
-        version: 19.2.5(react@19.2.5)
-    devDependencies:
-      '@tailwindcss/postcss':
-        specifier: ^4
-        version: 4.1.18
-      '@types/node':
-        specifier: ^25.6.0
-        version: 25.6.0
-      '@types/react':
-        specifier: ^19
-        version: 19.2.14
-      '@types/react-dom':
-        specifier: ^19
-        version: 19.2.3(@types/react@19.2.14)
-      tailwindcss:
-        specifier: ^4
-        version: 4.1.18
-      typescript:
-        specifier: ^6.0.3
-        version: 6.0.3
-
-packages:
-
-  '@alloc/quick-lru@5.2.0':
-    resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
-    engines: {node: '>=10'}
-
-  '@ark/schema@0.56.0':
-    resolution: {integrity: sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA==}
-
-  '@ark/util@0.56.0':
-    resolution: {integrity: sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA==}
-
-  '@babel/code-frame@7.29.0':
-    resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/compat-data@7.29.0':
-    resolution: {integrity: sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/core@7.29.0':
-    resolution: {integrity: sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/generator@7.29.1':
-    resolution: {integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-compilation-targets@7.28.6':
-    resolution: {integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-globals@7.28.0':
-    resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-module-imports@7.28.6':
-    resolution: {integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-module-transforms@7.28.6':
-    resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==}
-    engines: {node: '>=6.9.0'}
-    peerDependencies:
-      '@babel/core': ^7.0.0
-
-  '@babel/helper-string-parser@7.27.1':
-    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-string-parser@7.29.7':
-    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-validator-identifier@7.28.5':
-    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-validator-identifier@7.29.7':
-    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helper-validator-option@7.27.1':
-    resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/helpers@7.28.6':
-    resolution: {integrity: sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/parser@7.29.0':
-    resolution: {integrity: sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-
-  '@babel/parser@7.29.7':
-    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-
-  '@babel/runtime@7.29.2':
-    resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/template@7.28.6':
-    resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/traverse@7.29.0':
-    resolution: {integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/types@7.29.0':
-    resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
-    engines: {node: '>=6.9.0'}
-
-  '@babel/types@7.29.7':
-    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
-    engines: {node: '>=6.9.0'}
-
-  '@changesets/apply-release-plan@7.1.1':
-    resolution: {integrity: sha512-9qPCm/rLx/xoOFXIHGB229+4GOL76S4MC+7tyOuTsR6+1jYlfFDQORdvwR5hDA6y4FL2BPt3qpbcQIS+dW85LA==}
-
-  '@changesets/assemble-release-plan@6.0.10':
-    resolution: {integrity: sha512-rSDcqdJ9KbVyjpBIuCidhvZNIiVt1XaIYp73ycVQRIA5n/j6wQaEk0ChRLMUQ1vkxZe51PTQ9OIhbg6HQMW45A==}
-
-  '@changesets/changelog-git@0.2.1':
-    resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
-
-  '@changesets/changelog-github@0.7.0':
-    resolution: {integrity: sha512-rBsbRvc4TVn+FvFnOVM3LxlFJfTXXCp8gfVJ+0BubxWNSVnLuAzowi5j+IEraLLP52w8AAs9QfKbPS3MMiXQJA==}
-
-  '@changesets/cli@2.31.0':
-    resolution: {integrity: sha512-AhI4enNTgHu2IZr6K4WZyf0EPch4XVMn1yOMFmCD9gsfBGqMYaHXls5HyDv6/CL5axVQABz68eG30eCtbr2wFg==}
-    hasBin: true
-
-  '@changesets/config@3.1.4':
-    resolution: {integrity: sha512-pf0bvD/v6WI2cRlZ6hzpjtZdSlXDXMAJ+Iz7xfFzV4ZxJ8OGGAON+1qYc99ZPrijnt4xp3VGG7eNvAOGS24V1Q==}
-
-  '@changesets/errors@0.2.0':
-    resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==}
-
-  '@changesets/get-dependents-graph@2.1.4':
-    resolution: {integrity: sha512-ZsS00x6WvmHq3sQv8oCMwL0f/z3wbXCVuSVTJwCnnmbC/iBdNJGFx1EcbMG4PC6sXRyH69liM4A2WKXzn/kRPg==}
-
-  '@changesets/get-github-info@0.8.0':
-    resolution: {integrity: sha512-cRnC+xdF0JIik7coko3iUP9qbnfi1iJQ3sAa6dE+Tx3+ET8bjFEm63PA4WEohgjYcmsOikPHWzPsMWWiZmntOQ==}
-
-  '@changesets/get-release-plan@4.0.16':
-    resolution: {integrity: sha512-2K5Om6CrMPm45rtvckfzWo7e9jOVCKLCnXia5eUPaURH7/LWzri7pK1TycdzAuAtehLkW7VPbWLCSExTHmiI6g==}
-
-  '@changesets/get-version-range-type@0.4.0':
-    resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==}
-
-  '@changesets/git@3.0.4':
-    resolution: {integrity: sha512-BXANzRFkX+XcC1q/d27NKvlJ1yf7PSAgi8JG6dt8EfbHFHi4neau7mufcSca5zRhwOL8j9s6EqsxmT+s+/E6Sw==}
-
-  '@changesets/logger@0.1.1':
-    resolution: {integrity: sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==}
-
-  '@changesets/parse@0.4.3':
-    resolution: {integrity: sha512-ZDmNc53+dXdWEv7fqIUSgRQOLYoUom5Z40gmLgmATmYR9NbL6FJJHwakcCpzaeCy+1D0m0n7mT4jj2B/MQPl7A==}
-
-  '@changesets/pre@2.0.2':
-    resolution: {integrity: sha512-HaL/gEyFVvkf9KFg6484wR9s0qjAXlZ8qWPDkTyKF6+zqjBe/I2mygg3MbpZ++hdi0ToqNUF8cjj7fBy0dg8Ug==}
-
-  '@changesets/read@0.6.7':
-    resolution: {integrity: sha512-D1G4AUYGrBEk8vj8MGwf75k9GpN6XL3wg8i42P2jZZwFLXnlr2Pn7r9yuQNbaMCarP7ZQWNJbV6XLeysAIMhTA==}
-
-  '@changesets/should-skip-package@0.1.2':
-    resolution: {integrity: sha512-qAK/WrqWLNCP22UDdBTMPH5f41elVDlsNyat180A33dWxuUDyNpg6fPi/FyTZwRriVjg0L8gnjJn2F9XAoF0qw==}
-
-  '@changesets/types@4.1.0':
-    resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==}
-
-  '@changesets/types@6.1.0':
-    resolution: {integrity: sha512-rKQcJ+o1nKNgeoYRHKOS07tAMNd3YSN0uHaJOZYjBAgxfV7TUE7JE+z4BzZdQwb5hKaYbayKN5KrYV7ODb2rAA==}
-
-  '@changesets/write@0.4.0':
-    resolution: {integrity: sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q==}
-
-  '@effect/platform-node-shared@4.0.0-beta.70':
-    resolution: {integrity: sha512-3VXuL63IDmq13We+ApRKn2JW3Rb9g5gj1YEmfb8u2b73norur1VsIJ/pRE4qjShevg19dQYi2JsLawSZ6gApug==}
-    engines: {node: '>=18.0.0'}
-    peerDependencies:
-      effect: ^4.0.0-beta.70
-
-  '@effect/vitest@4.0.0-beta.70':
-    resolution: {integrity: sha512-XDteNN0xfOgoMauAVoN5iylxVgEjp7kFsGFq18tZ5XYjek0eOZa0nOoes5s7Bs71VvwjnCeCbFMD7IhxswEt8A==}
-    peerDependencies:
-      effect: ^4.0.0-beta.70
-      vitest: ^3.0.0 || ^4.0.0
-
-  '@emnapi/core@1.10.0':
-    resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
-
-  '@emnapi/runtime@1.10.0':
-    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
-
-  '@emnapi/wasi-threads@1.2.1':
-    resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
-
-  '@epic-web/invariant@1.0.0':
-    resolution: {integrity: sha512-lrTPqgvfFQtR/eY/qkIzp98OGdNJu0m5ji3q/nJI8v3SXkRKEnWiOxMmbvcSoAIzv/cGiuvRy57k4suKQSAdwA==}
-
-  '@esbuild/aix-ppc64@0.25.12':
-    resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [aix]
-
-  '@esbuild/aix-ppc64@0.27.3':
-    resolution: {integrity: sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [aix]
-
-  '@esbuild/aix-ppc64@0.28.1':
-    resolution: {integrity: sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [aix]
-
-  '@esbuild/android-arm64@0.25.12':
-    resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [android]
-
-  '@esbuild/android-arm64@0.27.3':
-    resolution: {integrity: sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [android]
-
-  '@esbuild/android-arm64@0.28.1':
-    resolution: {integrity: sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [android]
-
-  '@esbuild/android-arm@0.25.12':
-    resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [android]
-
-  '@esbuild/android-arm@0.27.3':
-    resolution: {integrity: sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [android]
-
-  '@esbuild/android-arm@0.28.1':
-    resolution: {integrity: sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [android]
-
-  '@esbuild/android-x64@0.25.12':
-    resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [android]
-
-  '@esbuild/android-x64@0.27.3':
-    resolution: {integrity: sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [android]
-
-  '@esbuild/android-x64@0.28.1':
-    resolution: {integrity: sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [android]
-
-  '@esbuild/darwin-arm64@0.25.12':
-    resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@esbuild/darwin-arm64@0.27.3':
-    resolution: {integrity: sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@esbuild/darwin-arm64@0.28.1':
-    resolution: {integrity: sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@esbuild/darwin-x64@0.25.12':
-    resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@esbuild/darwin-x64@0.27.3':
-    resolution: {integrity: sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@esbuild/darwin-x64@0.28.1':
-    resolution: {integrity: sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@esbuild/freebsd-arm64@0.25.12':
-    resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-arm64@0.27.3':
-    resolution: {integrity: sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-arm64@0.28.1':
-    resolution: {integrity: sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-x64@0.25.12':
-    resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-x64@0.27.3':
-    resolution: {integrity: sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-x64@0.28.1':
-    resolution: {integrity: sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@esbuild/linux-arm64@0.25.12':
-    resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux]
-
-  '@esbuild/linux-arm64@0.27.3':
-    resolution: {integrity: sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux]
-
-  '@esbuild/linux-arm64@0.28.1':
-    resolution: {integrity: sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux]
-
-  '@esbuild/linux-arm@0.25.12':
-    resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux]
-
-  '@esbuild/linux-arm@0.27.3':
-    resolution: {integrity: sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux]
-
-  '@esbuild/linux-arm@0.28.1':
-    resolution: {integrity: sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux]
-
-  '@esbuild/linux-ia32@0.25.12':
-    resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [linux]
-
-  '@esbuild/linux-ia32@0.27.3':
-    resolution: {integrity: sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [linux]
-
-  '@esbuild/linux-ia32@0.28.1':
-    resolution: {integrity: sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [linux]
-
-  '@esbuild/linux-loong64@0.25.12':
-    resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==}
-    engines: {node: '>=18'}
-    cpu: [loong64]
-    os: [linux]
-
-  '@esbuild/linux-loong64@0.27.3':
-    resolution: {integrity: sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==}
-    engines: {node: '>=18'}
-    cpu: [loong64]
-    os: [linux]
-
-  '@esbuild/linux-loong64@0.28.1':
-    resolution: {integrity: sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==}
-    engines: {node: '>=18'}
-    cpu: [loong64]
-    os: [linux]
-
-  '@esbuild/linux-mips64el@0.25.12':
-    resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==}
-    engines: {node: '>=18'}
-    cpu: [mips64el]
-    os: [linux]
-
-  '@esbuild/linux-mips64el@0.27.3':
-    resolution: {integrity: sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==}
-    engines: {node: '>=18'}
-    cpu: [mips64el]
-    os: [linux]
-
-  '@esbuild/linux-mips64el@0.28.1':
-    resolution: {integrity: sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==}
-    engines: {node: '>=18'}
-    cpu: [mips64el]
-    os: [linux]
-
-  '@esbuild/linux-ppc64@0.25.12':
-    resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [linux]
-
-  '@esbuild/linux-ppc64@0.27.3':
-    resolution: {integrity: sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [linux]
-
-  '@esbuild/linux-ppc64@0.28.1':
-    resolution: {integrity: sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [linux]
-
-  '@esbuild/linux-riscv64@0.25.12':
-    resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==}
-    engines: {node: '>=18'}
-    cpu: [riscv64]
-    os: [linux]
-
-  '@esbuild/linux-riscv64@0.27.3':
-    resolution: {integrity: sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==}
-    engines: {node: '>=18'}
-    cpu: [riscv64]
-    os: [linux]
-
-  '@esbuild/linux-riscv64@0.28.1':
-    resolution: {integrity: sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==}
-    engines: {node: '>=18'}
-    cpu: [riscv64]
-    os: [linux]
-
-  '@esbuild/linux-s390x@0.25.12':
-    resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==}
-    engines: {node: '>=18'}
-    cpu: [s390x]
-    os: [linux]
-
-  '@esbuild/linux-s390x@0.27.3':
-    resolution: {integrity: sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==}
-    engines: {node: '>=18'}
-    cpu: [s390x]
-    os: [linux]
-
-  '@esbuild/linux-s390x@0.28.1':
-    resolution: {integrity: sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==}
-    engines: {node: '>=18'}
-    cpu: [s390x]
-    os: [linux]
-
-  '@esbuild/linux-x64@0.25.12':
-    resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux]
-
-  '@esbuild/linux-x64@0.27.3':
-    resolution: {integrity: sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux]
-
-  '@esbuild/linux-x64@0.28.1':
-    resolution: {integrity: sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux]
-
-  '@esbuild/netbsd-arm64@0.25.12':
-    resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-arm64@0.27.3':
-    resolution: {integrity: sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-arm64@0.28.1':
-    resolution: {integrity: sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-x64@0.25.12':
-    resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-x64@0.27.3':
-    resolution: {integrity: sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-x64@0.28.1':
-    resolution: {integrity: sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [netbsd]
-
-  '@esbuild/openbsd-arm64@0.25.12':
-    resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-arm64@0.27.3':
-    resolution: {integrity: sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-arm64@0.28.1':
-    resolution: {integrity: sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-x64@0.25.12':
-    resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-x64@0.27.3':
-    resolution: {integrity: sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-x64@0.28.1':
-    resolution: {integrity: sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@esbuild/openharmony-arm64@0.25.12':
-    resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@esbuild/openharmony-arm64@0.27.3':
-    resolution: {integrity: sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@esbuild/openharmony-arm64@0.28.1':
-    resolution: {integrity: sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@esbuild/sunos-x64@0.25.12':
-    resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [sunos]
-
-  '@esbuild/sunos-x64@0.27.3':
-    resolution: {integrity: sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [sunos]
-
-  '@esbuild/sunos-x64@0.28.1':
-    resolution: {integrity: sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [sunos]
-
-  '@esbuild/win32-arm64@0.25.12':
-    resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@esbuild/win32-arm64@0.27.3':
-    resolution: {integrity: sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@esbuild/win32-arm64@0.28.1':
-    resolution: {integrity: sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@esbuild/win32-ia32@0.25.12':
-    resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [win32]
-
-  '@esbuild/win32-ia32@0.27.3':
-    resolution: {integrity: sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [win32]
-
-  '@esbuild/win32-ia32@0.28.1':
-    resolution: {integrity: sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [win32]
-
-  '@esbuild/win32-x64@0.25.12':
-    resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
-  '@esbuild/win32-x64@0.27.3':
-    resolution: {integrity: sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
-  '@esbuild/win32-x64@0.28.1':
-    resolution: {integrity: sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
-  '@eslint-community/eslint-utils@4.9.1':
-    resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
-
-  '@eslint-community/regexpp@4.12.2':
-    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
-    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
-
-  '@eslint/config-array@0.21.2':
-    resolution: {integrity: sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@eslint/config-helpers@0.4.2':
-    resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@eslint/core@0.17.0':
-    resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@eslint/eslintrc@3.3.5':
-    resolution: {integrity: sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@eslint/js@9.39.2':
-    resolution: {integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@eslint/object-schema@2.1.7':
-    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@eslint/plugin-kit@0.4.1':
-    resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@humanfs/core@0.19.1':
-    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
-    engines: {node: '>=18.18.0'}
-
-  '@humanfs/node@0.16.7':
-    resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==}
-    engines: {node: '>=18.18.0'}
-
-  '@humanwhocodes/module-importer@1.0.1':
-    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
-    engines: {node: '>=12.22'}
-
-  '@humanwhocodes/retry@0.4.3':
-    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
-    engines: {node: '>=18.18'}
-
-  '@iarna/toml@2.2.5':
-    resolution: {integrity: sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg==}
-
-  '@img/colour@1.0.0':
-    resolution: {integrity: sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==}
-    engines: {node: '>=18'}
-
-  '@img/sharp-darwin-arm64@0.34.5':
-    resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@img/sharp-darwin-x64@0.34.5':
-    resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [x64]
-    os: [darwin]
-
-  '@img/sharp-libvips-darwin-arm64@1.2.4':
-    resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@img/sharp-libvips-darwin-x64@1.2.4':
-    resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==}
-    cpu: [x64]
-    os: [darwin]
-
-  '@img/sharp-libvips-linux-arm64@1.2.4':
-    resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-libvips-linux-arm@1.2.4':
-    resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
-    cpu: [arm]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-libvips-linux-ppc64@1.2.4':
-    resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-libvips-linux-riscv64@1.2.4':
-    resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-libvips-linux-s390x@1.2.4':
-    resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-libvips-linux-x64@1.2.4':
-    resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
-    resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
-    resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@img/sharp-linux-arm64@0.34.5':
-    resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-linux-arm@0.34.5':
-    resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [arm]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-linux-ppc64@0.34.5':
-    resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-linux-riscv64@0.34.5':
-    resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-linux-s390x@0.34.5':
-    resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-linux-x64@0.34.5':
-    resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@img/sharp-linuxmusl-arm64@0.34.5':
-    resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@img/sharp-linuxmusl-x64@0.34.5':
-    resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@img/sharp-wasm32@0.34.5':
-    resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [wasm32]
-
-  '@img/sharp-win32-arm64@0.34.5':
-    resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [arm64]
-    os: [win32]
-
-  '@img/sharp-win32-ia32@0.34.5':
-    resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [ia32]
-    os: [win32]
-
-  '@img/sharp-win32-x64@0.34.5':
-    resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-    cpu: [x64]
-    os: [win32]
-
-  '@inquirer/external-editor@1.0.3':
-    resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      '@types/node': '>=18'
-    peerDependenciesMeta:
-      '@types/node':
-        optional: true
-
-  '@jridgewell/gen-mapping@0.3.13':
-    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
-
-  '@jridgewell/remapping@2.3.5':
-    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
-
-  '@jridgewell/resolve-uri@3.1.2':
-    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
-    engines: {node: '>=6.0.0'}
-
-  '@jridgewell/source-map@0.3.11':
-    resolution: {integrity: sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==}
-
-  '@jridgewell/sourcemap-codec@1.5.5':
-    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
-
-  '@jridgewell/trace-mapping@0.3.31':
-    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
-
-  '@manypkg/find-root@1.1.0':
-    resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==}
-
-  '@manypkg/get-packages@1.1.3':
-    resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==}
-
-  '@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.3':
-    resolution: {integrity: sha512-QZHtlVgbAdy2zAqNA9Gu1UpIuI8Xvsd1v8ic6B2pZmeFnFcMWiPLfWXh7TVw4eGEZ/C9TH281KwhVoeQUKbyjw==}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.3':
-    resolution: {integrity: sha512-mdzd3AVzYKuUmiWOQ8GNhl64/IoFGol569zNRdkLReh6LRLHOXxU4U8eq0JwaD8iFHdVGqSy4IjFL4reoWCDFw==}
-    cpu: [x64]
-    os: [darwin]
-
-  '@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.3':
-    resolution: {integrity: sha512-YxQL+ax0XqBJDZiKimS2XQaf+2wDGVa1enVRGzEvLLVFeqa5kx2bWbtcSXgsxjQB7nRqqIGFIcLteF/sHeVtQg==}
-    cpu: [arm64]
-    os: [linux]
-
-  '@msgpackr-extract/msgpackr-extract-linux-arm@3.0.3':
-    resolution: {integrity: sha512-fg0uy/dG/nZEXfYilKoRe7yALaNmHoYeIoJuJ7KJ+YyU2bvY8vPv27f7UKhGRpY6euFYqEVhxCFZgAUNQBM3nw==}
-    cpu: [arm]
-    os: [linux]
-
-  '@msgpackr-extract/msgpackr-extract-linux-x64@3.0.3':
-    resolution: {integrity: sha512-cvwNfbP07pKUfq1uH+S6KJ7dT9K8WOE4ZiAcsrSes+UY55E/0jLYc+vq+DO7jlmqRb5zAggExKm0H7O/CBaesg==}
-    cpu: [x64]
-    os: [linux]
-
-  '@msgpackr-extract/msgpackr-extract-win32-x64@3.0.3':
-    resolution: {integrity: sha512-x0fWaQtYp4E6sktbsdAqnehxDgEc/VwM7uLsRCYWaiGu0ykYdZPiS8zCWdnjHwyiumousxfBm4SO31eXqwEZhQ==}
-    cpu: [x64]
-    os: [win32]
-
-  '@napi-rs/wasm-runtime@1.1.4':
-    resolution: {integrity: sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==}
-    peerDependencies:
-      '@emnapi/core': ^1.7.1
-      '@emnapi/runtime': ^1.7.1
-
-  '@next/env@16.2.4':
-    resolution: {integrity: sha512-dKkkOzOSwFYe5RX6y26fZgkSpVAlIOJKQHIiydQcrWH6y/97+RceSOAdjZ14Qa3zLduVUy0TXcn+EiM6t4rPgw==}
-
-  '@next/swc-darwin-arm64@16.2.4':
-    resolution: {integrity: sha512-OXTFFox5EKN1Ym08vfrz+OXxmCcEjT4SFMbNRsWZE99dMqt2Kcusl5MqPXcW232RYkMLQTy0hqgAMEsfEd/l2A==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@next/swc-darwin-x64@16.2.4':
-    resolution: {integrity: sha512-XhpVnUfmYWvD3YrXu55XdcAkQtOnvaI6wtQa8fuF5fGoKoxIUZ0kWPtcOfqJEWngFF/lOS9l3+O9CcownhiQxQ==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@next/swc-linux-arm64-gnu@16.2.4':
-    resolution: {integrity: sha512-Mx/tjlNA3G8kg14QvuGAJ4xBwPk1tUHq56JxZ8CXnZwz1Etz714soCEzGQQzVMz4bEnGPowzkV6Xrp6wAkEWOQ==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@next/swc-linux-arm64-musl@16.2.4':
-    resolution: {integrity: sha512-iVMMp14514u7Nup2umQS03nT/bN9HurK8ufylC3FZNykrwjtx7V1A7+4kvhbDSCeonTVqV3Txnv0Lu+m2oDXNg==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@next/swc-linux-x64-gnu@16.2.4':
-    resolution: {integrity: sha512-EZOvm1aQWgnI/N/xcWOlnS3RQBk0VtVav5Zo7n4p0A7UKyTDx047k8opDbXgBpHl4CulRqRfbw3QrX2w5UOXMQ==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@next/swc-linux-x64-musl@16.2.4':
-    resolution: {integrity: sha512-h9FxsngCm9cTBf71AR4fGznDEDx1hS7+kSEiIRjq5kO1oXWm07DxVGZjCvk0SGx7TSjlUqhI8oOyz7NfwAdPoA==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@next/swc-win32-arm64-msvc@16.2.4':
-    resolution: {integrity: sha512-3NdJV5OXMSOeJYijX+bjaLge3mJBlh4ybydbT4GFoB/2hAojWHtMhl3CYlYoMrjPuodp0nzFVi4Tj2+WaMg+Ow==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@next/swc-win32-x64-msvc@16.2.4':
-    resolution: {integrity: sha512-kMVGgsqhO5YTYODD9IPGGhA6iprWidQckK3LmPeW08PIFENRmgfb4MjXHO+p//d+ts2rpjvK5gXWzXSMrPl9cw==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [win32]
-
-  '@nodelib/fs.scandir@2.1.5':
-    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
-    engines: {node: '>= 8'}
-
-  '@nodelib/fs.stat@2.0.5':
-    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
-    engines: {node: '>= 8'}
-
-  '@nodelib/fs.walk@1.2.8':
-    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
-    engines: {node: '>= 8'}
-
-  '@opentelemetry/api-logs@0.214.0':
-    resolution: {integrity: sha512-40lSJeqYO8Uz2Yj7u94/SJWE/wONa7rmMKjI1ZcIjgf3MHNHv1OZUCrCETGuaRF62d5pQD1wKIW+L4lmSMTzZA==}
-    engines: {node: '>=8.0.0'}
-
-  '@opentelemetry/api@1.9.1':
-    resolution: {integrity: sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==}
-    engines: {node: '>=8.0.0'}
-
-  '@opentelemetry/core@2.7.1':
-    resolution: {integrity: sha512-QAqIj32AtK6+pEVNG7EOVxHdE06RP+FM5qpiEJ4RtDcFIqKUZHYhl7/7UY5efhwmwNAg7j8QbJVBLxMerc0+gw==}
-    engines: {node: ^18.19.0 || >=20.6.0}
-    peerDependencies:
-      '@opentelemetry/api': '>=1.0.0 <1.10.0'
-
-  '@opentelemetry/instrumentation@0.214.0':
-    resolution: {integrity: sha512-MHqEX5Dk59cqVah5LiARMACku7jXSVk9iVDWOea4x3cr7VfdByeDCURK6o1lntT1JS/Tsovw01UJrBhN3/uC5w==}
-    engines: {node: ^18.19.0 || >=20.6.0}
-    peerDependencies:
-      '@opentelemetry/api': ^1.3.0
-
-  '@opentelemetry/resources@2.7.1':
-    resolution: {integrity: sha512-DeT6KKolmC4e/dRQvMQ/RwlnzhaqeiFOXY5ngoOPJ07GgVVKxZOg9EcrNZb5aTzUn+iCrJldAgOfQm1O/QfPAQ==}
-    engines: {node: ^18.19.0 || >=20.6.0}
-    peerDependencies:
-      '@opentelemetry/api': '>=1.3.0 <1.10.0'
-
-  '@opentelemetry/sdk-trace-base@2.7.1':
-    resolution: {integrity: sha512-NAYIlsF8MPUsKqJMiDQJTMPOmlbawC1Iz/omMLygZ1C9am8fTKYjTaI+OZM+WTY3t3Glo0wnOg/6/pac6RGPPw==}
-    engines: {node: ^18.19.0 || >=20.6.0}
-    peerDependencies:
-      '@opentelemetry/api': '>=1.3.0 <1.10.0'
-
-  '@opentelemetry/semantic-conventions@1.41.1':
-    resolution: {integrity: sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA==}
-    engines: {node: '>=14'}
-
-  '@oxc-parser/binding-android-arm-eabi@0.132.0':
-    resolution: {integrity: sha512-KrLaPWa5c9Y7LkW+rKkaUE3y7DBDrQtaf7rlsSDfv6KAHUjgzAIRA761Lrrp6//Yd/Rlie/yEOt9YENCoJnOcw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [android]
-
-  '@oxc-parser/binding-android-arm-eabi@0.135.0':
-    resolution: {integrity: sha512-sHeZItACNcA5WRAWqF6ixriR4GkZDyY10gVgnZU7pXku1DjHFATSqnwZM809jl0gXPHxb6fKzYQCK7bNK5cACQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [android]
-
-  '@oxc-parser/binding-android-arm64@0.132.0':
-    resolution: {integrity: sha512-SThDrSeamB/kG2+NxcJ5/wSLcV6dUqDknrPLqFYQ0ST/55mtBP4M7Q/f3QbubH6aAd11wpzZn/nwbVRSdobOpg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [android]
-
-  '@oxc-parser/binding-android-arm64@0.135.0':
-    resolution: {integrity: sha512-wPte+SzgzWWFgMSF8YZDNM+tBXtJg0AXBi7+tU3yS2z1f2Af9kRLZLKuJojADmuD/cZexmnMHHC3SDItTW77Iw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [android]
-
-  '@oxc-parser/binding-darwin-arm64@0.132.0':
-    resolution: {integrity: sha512-Lc0f/TYoKBghE5/2Gsv7bLXk+TJZunx2Tf61X8hG4ARXdc8UYI26dCGccFSd1AyFbK3jfaNXtMnupggDbjPXdQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@oxc-parser/binding-darwin-arm64@0.135.0':
-    resolution: {integrity: sha512-BmKz3lHIsqVos+9aPcdYCT9MG3APoUyM43KlEFhJMWNVDOGG8FKyiFz81Bc+mGz2o0hpuQ3PfXLfVWJrKXjo2g==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@oxc-parser/binding-darwin-x64@0.132.0':
-    resolution: {integrity: sha512-RG2eJIpf7C21z9HSSXFw1bTArdpKe7Y4fwcJTwRq1yCSe1vSavaN9GA1sm9KqzemTLAGVktQ+7qBTGp0vQeUZg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [darwin]
-
-  '@oxc-parser/binding-darwin-x64@0.135.0':
-    resolution: {integrity: sha512-dM8BS+8+Br1fNvmh2QZbGiHaYttwLebRa6J4Uz9vuFzMNmvsdRYwf7993ptOaV0JTrR63AaoVLjX7nhWbijxjQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [darwin]
-
-  '@oxc-parser/binding-freebsd-x64@0.132.0':
-    resolution: {integrity: sha512-wQIPntPLtJ8NcBpvKPbEv3NqzV6k8eP8tP/jE9Rg8HTg/j7urZGFSsTCPCW5k77Qfw2DM4vRvc9p3I4yq/Shvw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@oxc-parser/binding-freebsd-x64@0.135.0':
-    resolution: {integrity: sha512-xlZnvvJdR9bGu2pOhvR5hMuKPHCE6Sa9owK5A484mzjHdm75VRV5nCs5w/jkmGODMMTFc+KN7EnZqEieM813kw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@oxc-parser/binding-linux-arm-gnueabihf@0.132.0':
-    resolution: {integrity: sha512-PixKEpeSe3yxQWqNyOCBALRYc72+Tj7ILDofUl3iXo25cVOzLA6jHUhmOINRtWIPh7dbUie3QNeabwaQpZTw6w==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxc-parser/binding-linux-arm-gnueabihf@0.135.0':
-    resolution: {integrity: sha512-PSR8LmBK/H/PQRiN8g7RebQgZX/ntVCrdT/JBfNxE5ezdHG1s2i4rbazsRJYD83TTI1MmgTpC0MGL42PLtskQQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxc-parser/binding-linux-arm-musleabihf@0.132.0':
-    resolution: {integrity: sha512-sCR+DzGHlyHKnbA2z9zWjTUhIo8Sy0enJl4RDsBwPmkxYynPatpwOAWe8W5127SlW0boqUWHGtr1NWn5UwIhXQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxc-parser/binding-linux-arm-musleabihf@0.135.0':
-    resolution: {integrity: sha512-I85GJXzfUsigkkk7Ngdz95C217M4FdUi1Z2HrX5UyPmURobwQZ7m2bbUvwFkz4VGZd+lymFGKHvDZ3RQC9qOzA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxc-parser/binding-linux-arm64-gnu@0.132.0':
-    resolution: {integrity: sha512-sQBix5P2cW+IpzTcCwYxnh9yALrKSIkKJThspBvMGcygSMnbzkSvhN7SfuX1hvBk8y1XEChsdkU3ET0V5DmzUw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-arm64-gnu@0.135.0':
-    resolution: {integrity: sha512-zqEY0npz0g0aGZj/8a5BclunjVDytsBQHYtIC10Gd26HcrLwbVF6YDbqRQjunMGYdSo97u6xOBl05aTDI2diDQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-arm64-musl@0.132.0':
-    resolution: {integrity: sha512-WozHg3Kc//8Sk756HXXgMbEAvqtG+Lzb9JOojwQzIGDtN78Az2dLttkb71akWYUF/8IgYfDSlfKh4Uot8is5Vw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-parser/binding-linux-arm64-musl@0.135.0':
-    resolution: {integrity: sha512-mWAfprP819gQ2qYst1RxgTI8b/z0b29OpoKfRflIXLHde2dZLihQD4g47Onuvtpo5GPIkMYPRlX9QoeZfs/GnQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-parser/binding-linux-ppc64-gnu@0.132.0':
-    resolution: {integrity: sha512-CmX/ulNBOEwWTyVRmcpYKAcAizW6+OjtLJgo7fXoL9OqQvjF4VER8tPomv44vwzfSCy1BHbsB0ZlZYzYJNj4cA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-ppc64-gnu@0.135.0':
-    resolution: {integrity: sha512-gri8c2AOmJKJwOux2KTHFBfUaXoJURuVMKhmKEi/2hTF55cQteTDV2XNfTiE5oCC+Tnem1Y4/MWzcyDadtsSag==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-riscv64-gnu@0.132.0':
-    resolution: {integrity: sha512-j9oQS+hM90SdhviNGWbPgT4+Rlq+ac++q/zjgwPD1mVHgxHzATvoRGtDx0sXGmFOQ9J9YkwAhYGb5MAHL6TAsA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-riscv64-gnu@0.135.0':
-    resolution: {integrity: sha512-Y2tkupCG5wo0SxH2rMLG4d4Kmv6DaM3sBp+GuM5lox0S8Za6VxKgQrY2Mut088QQxKkEE89n/4CCCgmw2o0e3Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-riscv64-musl@0.132.0':
-    resolution: {integrity: sha512-bLz+Xi+Agnfmd7kWPEsSVwCn2k4EyIalZkNBcQ0OGIv9rqn8VgCPLNd03tM9mKX/5TdlvDXalz0q71BIrOPNqg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-parser/binding-linux-riscv64-musl@0.135.0':
-    resolution: {integrity: sha512-xDRJq6i6WTynjeP+ISbDpyH4p9BaJ0wuQcL0lCSDkt9qOXC9dmwpOu1VG/TlwmPI3KpYntmO9nJCuc3TMTsNBA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-parser/binding-linux-s390x-gnu@0.132.0':
-    resolution: {integrity: sha512-U6t2qbJU0ypTfyj9QV3W1Y6mITDTL8ai/OR6NUn85vyHthOvobKWgXzU4tu0EskSzlpuVFz1g0jFGulDIUKHxQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-s390x-gnu@0.135.0':
-    resolution: {integrity: sha512-V4MoUuiCRNvihxhIufRxvK+ka013V4joTSK0FAGA1KEjLuNprfH6N/Qw2uxQEVIFuNYMhD/hV6xJ/ptbzlKdHg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-x64-gnu@0.132.0':
-    resolution: {integrity: sha512-WcEaSNHFk8yz5YFlQQAlhq6jOFmZBB/RKE7uzhyCIf+pF1Lmv9gUH4221mle2Gd9iHyWT3ySNph8yZgb1xYdWg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-x64-gnu@0.135.0':
-    resolution: {integrity: sha512-JCFZ7zM7KXOKoPAbK/ZB4wY0M1jxRECiem2UQuiXLjzGqS9+hno7mtX+qyK2F7HWK2xPhyJb+frpcOtk5DKOtg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-parser/binding-linux-x64-musl@0.132.0':
-    resolution: {integrity: sha512-iQrV4iJzQgRwK3BWRmQl1C3C6g3wYpXN2WLdQdyR+efoUnncdShZAVp9OgcojtlD3MDRbuOMGG3SjxF4fL4nlQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-parser/binding-linux-x64-musl@0.135.0':
-    resolution: {integrity: sha512-9jSVS1b3hOV7sdKH4aA2DFfnTz0RgQd0v2BefR+LYbH8yIlmSM22JJZbAAjVeVXmFgUAk3zJQ1tpE/Nd+Vi2YQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-parser/binding-openharmony-arm64@0.132.0':
-    resolution: {integrity: sha512-FWzmUGrZ6GUby4U7WIwcCtab6tdmlTO3xTRRKyb5kjIJVEiaUAT8animUG/nK8ZCA8gkRkPOTId4rl6uTqUmJQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@oxc-parser/binding-openharmony-arm64@0.135.0':
-    resolution: {integrity: sha512-M857ZLBSdn1Uy/SJJz5zh0qGu67B4P9omCgXGBU2LLqTzraX6ZjVNaKq5yW1PDw/LgJXDXR/dbZfgmB310f11Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@oxc-parser/binding-wasm32-wasi@0.132.0':
-    resolution: {integrity: sha512-TlbMppxJI5CjWDes0QaP6G3aneVg1yikBu5QYI+DUShF9WDL66ccgKFNNGmi/Wybtszw6hxwAvv76T4DaPKnHw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [wasm32]
-
-  '@oxc-parser/binding-wasm32-wasi@0.135.0':
-    resolution: {integrity: sha512-2w6DVcntQZX9U5RhXtgiWb3FLWFB5EcwI1U8yr3htOCJUJjagN4BFUHz/Y/d9ZsumndZ6ByxxWEtbUZNE1bfFw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [wasm32]
-
-  '@oxc-parser/binding-win32-arm64-msvc@0.132.0':
-    resolution: {integrity: sha512-RH/NbFjGKqdUAUi7Oh3LQPxUk2hsWFEEQ38HSnbRQT8QjBZFKqL1fMbmsB3N4jy/KPh9iX94+9dmkEMBBbambw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [win32]
-
-  '@oxc-parser/binding-win32-arm64-msvc@0.135.0':
-    resolution: {integrity: sha512-rX1U8+IH2Z37EJjDXKa1iifvUQAdba+vZ4Ewj1iaG5eA/QaSybzclCOwtWa0/5BuUQnnK/T2JHUEFrwhL6Ck2Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [win32]
-
-  '@oxc-parser/binding-win32-ia32-msvc@0.132.0':
-    resolution: {integrity: sha512-JUr4jQY9jxoIB/YTLXr6XofSi5xikj6p5/Ns1h0VOBDT0j1jKU+kMsv2xxv51RwnETcXpA1Yw/9oUAfcqfaqEA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ia32]
-    os: [win32]
-
-  '@oxc-parser/binding-win32-ia32-msvc@0.135.0':
-    resolution: {integrity: sha512-9FAisBbH1QICGAjlJobiuKGd/jOuVmyqniWdQMwTa5SkCl6hhuotBCJf1n46B0flYbSOR5TzfV9HZCWSyb3c/Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ia32]
-    os: [win32]
-
-  '@oxc-parser/binding-win32-x64-msvc@0.132.0':
-    resolution: {integrity: sha512-2dapgHpA5X8DSXF4AU36hJWYf6zP0tKjMXFRAZFBD62pkevW/uhFDXoFH9Y/3Fd2EtDrw5ByNnR1wVE9X9y0SQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [win32]
-
-  '@oxc-parser/binding-win32-x64-msvc@0.135.0':
-    resolution: {integrity: sha512-wYF+A2AzJ2n7ul6q+Z2G/ia0S2+8cUp0AgWZzoFvF4WmUcl1P7p+o6se1Gdr5wGnWuF0iAMIkGddrjCarNr2yA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [win32]
-
-  '@oxc-project/runtime@0.127.0':
-    resolution: {integrity: sha512-UQYLxAhDDPHm++szfa4z0RTdcPq5vaywrAoEA2n1YaAKeanXQdjHsoT6x1gP3U97RN8LZ7yHsSOrKPCcA6mCqw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  '@oxc-project/types@0.127.0':
-    resolution: {integrity: sha512-aIYXQBo4lCbO4z0R3FHeucQHpF46l2LbMdxRvqvuRuW2OxdnSkcng5B8+K12spgLDj93rtN3+J2Vac/TIO+ciQ==}
-
-  '@oxc-project/types@0.132.0':
-    resolution: {integrity: sha512-FESMOxil5Se014ui/Eq8fT5uHJo6nIRwH0PfJrZJXs6Gek3ZVFOrpUv3YIZT20m+extU98Hg1Ym72U58rlsxUQ==}
-
-  '@oxc-project/types@0.135.0':
-    resolution: {integrity: sha512-wR+xRdFkUBMvcAjBJ2q2kcZM6d+DKu2NgoOyxZgYwZdLhmiv6+rnO8PZ/P68kMiZtIKm+pW7zyEJ4kSOs0vo+Q==}
-
-  '@oxc-resolver/binding-android-arm-eabi@11.19.1':
-    resolution: {integrity: sha512-aUs47y+xyXHUKlbhqHUjBABjvycq6YSD7bpxSW7vplUmdzAlJ93yXY6ZR0c1o1x5A/QKbENCvs3+NlY8IpIVzg==}
-    cpu: [arm]
-    os: [android]
-
-  '@oxc-resolver/binding-android-arm64@11.19.1':
-    resolution: {integrity: sha512-oolbkRX+m7Pq2LNjr/kKgYeC7bRDMVTWPgxBGMjSpZi/+UskVo4jsMU3MLheZV55jL6c3rNelPl4oD60ggYmqA==}
-    cpu: [arm64]
-    os: [android]
-
-  '@oxc-resolver/binding-darwin-arm64@11.19.1':
-    resolution: {integrity: sha512-nUC6d2i3R5B12sUW4O646qD5cnMXf2oBGPLIIeaRfU9doJRORAbE2SGv4eW6rMqhD+G7nf2Y8TTJTLiiO3Q/dQ==}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@oxc-resolver/binding-darwin-x64@11.19.1':
-    resolution: {integrity: sha512-cV50vE5+uAgNcFa3QY1JOeKDSkM/9ReIcc/9wn4TavhW/itkDGrXhw9jaKnkQnGbjJ198Yh5nbX/Gr2mr4Z5jQ==}
-    cpu: [x64]
-    os: [darwin]
-
-  '@oxc-resolver/binding-freebsd-x64@11.19.1':
-    resolution: {integrity: sha512-xZOQiYGFxtk48PBKff+Zwoym7ScPAIVp4c14lfLxizO2LTTTJe5sx9vQNGrBymrf/vatSPNMD4FgsaaRigPkqw==}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@oxc-resolver/binding-linux-arm-gnueabihf@11.19.1':
-    resolution: {integrity: sha512-lXZYWAC6kaGe/ky2su94e9jN9t6M0/6c+GrSlCqL//XO1cxi5lpAhnJYdyrKfm0ZEr/c7RNyAx3P7FSBcBd5+A==}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxc-resolver/binding-linux-arm-musleabihf@11.19.1':
-    resolution: {integrity: sha512-veG1kKsuK5+t2IsO9q0DErYVSw2azvCVvWHnfTOS73WE0STdLLB7Q1bB9WR+yHPQM76ASkFyRbogWo1GR1+WbQ==}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxc-resolver/binding-linux-arm64-gnu@11.19.1':
-    resolution: {integrity: sha512-heV2+jmXyYnUrpUXSPugqWDRpnsQcDm2AX4wzTuvgdlZfoNYO0O3W2AVpJYaDn9AG4JdM6Kxom8+foE7/BcSig==}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-resolver/binding-linux-arm64-musl@11.19.1':
-    resolution: {integrity: sha512-jvo2Pjs1c9KPxMuMPIeQsgu0mOJF9rEb3y3TdpsrqwxRM+AN6/nDDwv45n5ZrUnQMsdBy5gIabioMKnQfWo9ew==}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-resolver/binding-linux-ppc64-gnu@11.19.1':
-    resolution: {integrity: sha512-vLmdNxWCdN7Uo5suays6A/+ywBby2PWBBPXctWPg5V0+eVuzsJxgAn6MMB4mPlshskYbppjpN2Zg83ArHze9gQ==}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-resolver/binding-linux-riscv64-gnu@11.19.1':
-    resolution: {integrity: sha512-/b+WgR+VTSBxzgOhDO7TlMXC1ufPIMR6Vj1zN+/x+MnyXGW7prTLzU9eW85Aj7Th7CCEG9ArCbTeqxCzFWdg2w==}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-resolver/binding-linux-riscv64-musl@11.19.1':
-    resolution: {integrity: sha512-YlRdeWb9j42p29ROh+h4eg/OQ3dTJlpHSa+84pUM9+p6i3djtPz1q55yLJhgW9XfDch7FN1pQ/Vd6YP+xfRIuw==}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-resolver/binding-linux-s390x-gnu@11.19.1':
-    resolution: {integrity: sha512-EDpafVOQWF8/MJynsjOGFThcqhRHy417sRyLfQmeiamJ8qVhSKAn2Dn2VVKUGCjVB9C46VGjhNo7nOPUi1x6uA==}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-resolver/binding-linux-x64-gnu@11.19.1':
-    resolution: {integrity: sha512-NxjZe+rqWhr+RT8/Ik+5ptA3oz7tUw361Wa5RWQXKnfqwSSHdHyrw6IdcTfYuml9dM856AlKWZIUXDmA9kkiBQ==}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxc-resolver/binding-linux-x64-musl@11.19.1':
-    resolution: {integrity: sha512-cM/hQwsO3ReJg5kR+SpI69DMfvNCp+A/eVR4b4YClE5bVZwz8rh2Nh05InhwI5HR/9cArbEkzMjcKgTHS6UaNw==}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxc-resolver/binding-openharmony-arm64@11.19.1':
-    resolution: {integrity: sha512-QF080IowFB0+9Rh6RcD19bdgh49BpQHUW5TajG1qvWHvmrQznTZZjYlgE2ltLXyKY+qs4F/v5xuX1XS7Is+3qA==}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@oxc-resolver/binding-wasm32-wasi@11.19.1':
-    resolution: {integrity: sha512-w8UCKhX826cP/ZLokXDS6+milN8y4X7zidsAttEdWlVoamTNf6lhBJldaWr3ukTDiye7s4HRcuPEPOXNC432Vg==}
-    engines: {node: '>=14.0.0'}
-    cpu: [wasm32]
-
-  '@oxc-resolver/binding-win32-arm64-msvc@11.19.1':
-    resolution: {integrity: sha512-nJ4AsUVZrVKwnU/QRdzPCCrO0TrabBqgJ8pJhXITdZGYOV28TIYystV1VFLbQ7DtAcaBHpocT5/ZJnF78YJPtQ==}
-    cpu: [arm64]
-    os: [win32]
-
-  '@oxc-resolver/binding-win32-ia32-msvc@11.19.1':
-    resolution: {integrity: sha512-EW+ND5q2Tl+a3pH81l1QbfgbF3HmqgwLfDfVithRFheac8OTcnbXt/JxqD2GbDkb7xYEqy1zNaVFRr3oeG8npA==}
-    cpu: [ia32]
-    os: [win32]
-
-  '@oxc-resolver/binding-win32-x64-msvc@11.19.1':
-    resolution: {integrity: sha512-6hIU3RQu45B+VNTY4Ru8ppFwjVS/S5qwYyGhBotmjxfEKk41I2DlGtRfGJndZ5+6lneE2pwloqunlOyZuX/XAw==}
-    cpu: [x64]
-    os: [win32]
-
-  '@oxfmt/binding-android-arm-eabi@0.46.0':
-    resolution: {integrity: sha512-b1doV4WRcJU+BESSlCvCjV+5CEr/T6h0frArAdV26Nir+gGNFNaylvDiiMPfF1pxeV0txZEs38ojzJaxBYg+ng==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [android]
-
-  '@oxfmt/binding-android-arm64@0.46.0':
-    resolution: {integrity: sha512-v6+HhjsoV3GO0u2u9jLSAZrvWfTraDxKofUIQ7/ktS7tzS+epVsxdHmeM+XxuNcAY/nWxxU1Sg4JcGTNRXraBA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [android]
-
-  '@oxfmt/binding-darwin-arm64@0.46.0':
-    resolution: {integrity: sha512-3eeooJGrqGIlI5MyryDZsAcKXSmKIgAD4yYtfRrRJzXZ0UTFZtiSveIur56YPrGMYZwT4XyVhHsMqrNwr1XeFA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@oxfmt/binding-darwin-x64@0.46.0':
-    resolution: {integrity: sha512-QG8BDM0CXWbu84k2SKmCqfEddPQPFiBicwtYnLqHRWZZl57HbtOLRMac/KTq2NO4AEc4ICCBpFxJIV9zcqYfkQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [darwin]
-
-  '@oxfmt/binding-freebsd-x64@0.46.0':
-    resolution: {integrity: sha512-9DdCqS/n2ncu/Chazvt3cpgAjAmIGQDz7hFKSrNItMApyV/Ja9mz3hD4JakIE3nS8PW9smEbPWnb389QLBY4nw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@oxfmt/binding-linux-arm-gnueabihf@0.46.0':
-    resolution: {integrity: sha512-Dgs7VeE2jT0LHMhw6tPEt0xQYe54kBqHEovmWsv4FVQlegCOvlIJNx0S8n4vj8WUtpT+Z6BD2HhKJPLglLxvZg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxfmt/binding-linux-arm-musleabihf@0.46.0':
-    resolution: {integrity: sha512-Zxn3adhTH13JKnU4xXJj8FeEfF680XjXh3gSShKl57HCMBRde2tUJTgogV/1MSHA80PJEVrDa7r66TLVq3Ia7Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxfmt/binding-linux-arm64-gnu@0.46.0':
-    resolution: {integrity: sha512-+TWipjrgVM8D7aIdDD0tlr3teLTTvQTn7QTE5BpT10H1Fj82gfdn9X6nn2sDgx/MepuSCfSnzFNJq2paLL0OiA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxfmt/binding-linux-arm64-musl@0.46.0':
-    resolution: {integrity: sha512-aAUPBWJ1lGwwnxZUEDLJ94+Iy6MuwJwPxUgO4sCA5mEEyDk7b+cDQ+JpX1VR150Zoyd+D49gsrUzpUK5h587Eg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxfmt/binding-linux-ppc64-gnu@0.46.0':
-    resolution: {integrity: sha512-ufBCJukyFX/UDrokP/r6BGDoTInnsDs7bxyzKAgMiZlt2Qu8GPJSJ6Zm6whIiJzKk0naxA8ilwmbO1LMw6Htxw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxfmt/binding-linux-riscv64-gnu@0.46.0':
-    resolution: {integrity: sha512-eqtlC2YmPqjun76R1gVfGLuKWx7NuEnLEAudZ7n6ipSKbCZTqIKSs1b5Y8K/JHZsRpLkeSmAAjig5HOIg8fQzQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxfmt/binding-linux-riscv64-musl@0.46.0':
-    resolution: {integrity: sha512-yccVOO2nMXkQLGgy0He3EQEwKD7NF0zEk+/OWmroznkqXyJdN6bfK0LtNnr6/14Bh3FjpYq7bP33l/VloCnxpA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxfmt/binding-linux-s390x-gnu@0.46.0':
-    resolution: {integrity: sha512-aAf7fG23OQCey6VRPj9IeCraoYtpgtx0ZyJ1CXkPyT1wjzBE7c3xtuxHe/AdHaJfVVb/SXpSk8Gl1LzyQupSqw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxfmt/binding-linux-x64-gnu@0.46.0':
-    resolution: {integrity: sha512-q0JPsTMyJNjYrBvYFDz4WbVsafNZaPCZv4RnFypRotLqpKROtBZcEaXQW4eb9YmvLU3NckVemLJnzkSZSdmOxw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxfmt/binding-linux-x64-musl@0.46.0':
-    resolution: {integrity: sha512-7LsLY9Cw57GPkhSR+duI3mt9baRczK/DtHYSldQ4BEU92da9igBQNl4z7Vq5U9NNPsh1FmpKvv1q9WDtiUQR1A==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxfmt/binding-openharmony-arm64@0.46.0':
-    resolution: {integrity: sha512-lHiBOz8Duaku7JtRNLlps3j++eOaICPZSd8FCVmTDM4DFOPT71Bjn7g6iar1z7StXlKRweUKxWUs4sA+zWGDXg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@oxfmt/binding-win32-arm64-msvc@0.46.0':
-    resolution: {integrity: sha512-/5ktYUliP89RhgC37DBH1x20U5zPSZMy3cMEcO0j3793rbHP9MWsknBwQB6eozRzWmYrh0IFM/p20EbPvDlYlg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [win32]
-
-  '@oxfmt/binding-win32-ia32-msvc@0.46.0':
-    resolution: {integrity: sha512-3WTnoiuIr8XvV0DIY7SN+1uJSwKf4sPpcbHfobcRT9JutGcLaef/miyBB87jxd3aqH+mS0+G5lsgHuXLUwjjpQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ia32]
-    os: [win32]
-
-  '@oxfmt/binding-win32-x64-msvc@0.46.0':
-    resolution: {integrity: sha512-IXxiQpkYnOwNfP23vzwSfhdpxJzyiPTY7eTn6dn3DsriKddESzM8i6kfq9R7CD/PUJwCvQT22NgtygBeug3KoA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [win32]
-
-  '@oxlint-tsgolint/darwin-arm64@0.23.0':
-    resolution: {integrity: sha512-gOs9PVr2wEg4ox9z0aJo+RKhhImW86YL5N6yav8BK/rgPsIrwN/igSZ+pbRr723NFvUNKde9fgMhRA6JrXAOZw==}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@oxlint-tsgolint/darwin-x64@0.23.0':
-    resolution: {integrity: sha512-kjJ8B+7n4tB9VJdxS5A9GdJt6/bYpzbu4lXp2uO1S3sRmCB5gDEABlGoiePNApRWaW+xqL4b4xgiE727jSLhuA==}
-    cpu: [x64]
-    os: [darwin]
-
-  '@oxlint-tsgolint/linux-arm64@0.23.0':
-    resolution: {integrity: sha512-6dCZuKNu135seMXilkRk9SpCx6i1XgmiipYGalLij5WVRX6ZYS8c4xI7preN/zv9fCXhsQclTIMDu2Y/cytTjw==}
-    cpu: [arm64]
-    os: [linux]
-
-  '@oxlint-tsgolint/linux-x64@0.23.0':
-    resolution: {integrity: sha512-3bdilnyA7kmSTjK27rvjIjSxL5SIg3wt7vwNiRkouWB83ytssyKnuGvxSYJxgMEmFpSutzaBzcCUM2jDtPGcgA==}
-    cpu: [x64]
-    os: [linux]
-
-  '@oxlint-tsgolint/win32-arm64@0.23.0':
-    resolution: {integrity: sha512-j+OEp44SVYiQ+ZD+uttsX7u6L9SvmbbQ77SO1pSFCcJlsVMeCk8qZsjhKfGKuT/jIA+ipOJMVs/+pqUfObBWNw==}
-    cpu: [arm64]
-    os: [win32]
-
-  '@oxlint-tsgolint/win32-x64@0.23.0':
-    resolution: {integrity: sha512-5MyjFuqf+g8OUPJBSGWHJtmoWnzFJYyOg4To9WMQshZYEWig/vtu7JtJ03VWnzHv9LJkAUeApY0gVCOywFR/iQ==}
-    cpu: [x64]
-    os: [win32]
-
-  '@oxlint/binding-android-arm-eabi@1.66.0':
-    resolution: {integrity: sha512-f7kq8N51T4phpzqfBpA2qaVTI/KrkCmNwaj3t/97I/WLTDI+UhlP5GL9eER+zVxBhtlx5rKXWByJU1/zDAvyaw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [android]
-
-  '@oxlint/binding-android-arm64@1.66.0':
-    resolution: {integrity: sha512-xu6QO71tdDS9mjmLZ3AqhtaVHBvdmsOKkYnReNNDgh+XiwnsipeQOIxbiYOOO0iAXycJ+GK0wdMSZP/2j/AmSg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [android]
-
-  '@oxlint/binding-darwin-arm64@1.66.0':
-    resolution: {integrity: sha512-HZ24VimSOC7mxuEA99e0H2FS0C1yO3+iW13jPRAk+e2njsUs3QeAXsafCDyaIrV/MirdOVez+etQNQsJE43zNQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@oxlint/binding-darwin-x64@1.66.0':
-    resolution: {integrity: sha512-awhj8ZvJrrRSnXj7V++rpZvTmnl99L6mi0B7gg7Cp7BN6cKpzuI481bHNLvXGA9GB1/oEgA3ponuyoAc6Md12A==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [darwin]
-
-  '@oxlint/binding-freebsd-x64@1.66.0':
-    resolution: {integrity: sha512-KQF0oVV21/FjIqkRuL8Q1vh8ECsE5+ocdH5tcqTQ4ZnYuDVoYibQUNfqBjQaUsP6UIIda5Y75Wpm5p4RgQWiWw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@oxlint/binding-linux-arm-gnueabihf@1.66.0':
-    resolution: {integrity: sha512-9u1rgwZSEXWb30vbFZzQ78HVXBo0WCKNwJ3a2InRUTNMRng+PUDIoSFmA+m4HdUfBaIqftShq8J8qHc+eE/Vig==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxlint/binding-linux-arm-musleabihf@1.66.0':
-    resolution: {integrity: sha512-Ynot2HR1bHxUaNWoC280MVTDfZuaWuP3XfSMRDhyuZrVjhzoaBCVFlw8h8qeZjWKVUBhPWFIxB7AQTlK8Z2WWg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm]
-    os: [linux]
-
-  '@oxlint/binding-linux-arm64-gnu@1.66.0':
-    resolution: {integrity: sha512-xCbgzciGgo+A4aQZEknsNrNiIwY7sU5SfRuMmRjPIvZAgdF34cIHiKvwOsS5XRLjlTVSFwitmq6YclTtHTfU+g==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxlint/binding-linux-arm64-musl@1.66.0':
-    resolution: {integrity: sha512-hmo+ZB/lHkR1HdDmnziNpzSLmulnUSu10VEqX2Yex7OwvoBAbjJQLvy4gIBRV3AAwWnCvAxKp5Nv1GE6LU1QMg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxlint/binding-linux-ppc64-gnu@1.66.0':
-    resolution: {integrity: sha512-2Invd4Uyy81mVooQC5FBtfxSNrvcX1OxbMlVQ6M2erRrNI2awFYF26YNW2yFxdVFZ4ffNOWKghtMjhnUPsXsVA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxlint/binding-linux-riscv64-gnu@1.66.0':
-    resolution: {integrity: sha512-s0iXPDQVdgayE3RGa/N2DZF7tjgg0TwEtD1sGoDxqPDGrIXgo45H0yHknT0f9A0yteASsweYZtDyTuVlM4aSag==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxlint/binding-linux-riscv64-musl@1.66.0':
-    resolution: {integrity: sha512-OekL4XFiu7RPK0JIZi8VeHgtIXPREf42t8Cy/rKEsC+P3gcqDgNAAGiyuUOpdbG4wwbfue1q4CHcCO7spSve6w==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxlint/binding-linux-s390x-gnu@1.66.0':
-    resolution: {integrity: sha512-Ga1D0kj1SFslm34ThA/BdkUlyAYEnTsXyRC4pF0C5agZSwtGdHYWMTQWemUfBGp4RCG4QWXgdO+HmmmKqOtlBg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxlint/binding-linux-x64-gnu@1.66.0':
-    resolution: {integrity: sha512-p5jfP1wUZe/IC3qpQO84n9DRnf9g3lKRtLBlQq23ykyrDglHcVx7sWmVTlPuU6SBw8mNnPzyOn022G3XZHnlww==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@oxlint/binding-linux-x64-musl@1.66.0':
-    resolution: {integrity: sha512-vUB/sYlYZorDL1ZD+o9mRv7zbsykrrFRtmgS6R8musZqLtrPRQn1gc1eGpuX+sfdccz42STl/AqldY6XRb2upQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@oxlint/binding-openharmony-arm64@1.66.0':
-    resolution: {integrity: sha512-yde+6p/F59xRkGR9H1HfngWRif1QRJjynZK349l+UI0H6w9hL3G8/AVaTHFyTtLVQ56qtNbX2/5Dc77n1ovnOg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@oxlint/binding-win32-arm64-msvc@1.66.0':
-    resolution: {integrity: sha512-O9GLucgoTdmOrbBX+EjzNe7o/Ze5TFOvXcib6bzUOtBOmj6cV+zw18NgB+cGKAkDw1Pdqs8vGkfHbbsLuDtXWg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [win32]
-
-  '@oxlint/binding-win32-ia32-msvc@1.66.0':
-    resolution: {integrity: sha512-m3Pjwc2MfTcom4E4gOv7DyuGyt7OfGNCbmqDHd+N7EzXmP+ppHuudm2NjcA3AjV5TSeGxaguVF4SbTKHe1USYA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [ia32]
-    os: [win32]
-
-  '@oxlint/binding-win32-x64-msvc@1.66.0':
-    resolution: {integrity: sha512-/DbBvw8UFBhja6PqudUjV4UtfsJr0Oa7jUjWVKB0g86lj/VwnPrkngn0sFql3c9RDA0O16dh7ozsXb6GjNAzBQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [win32]
-
-  '@polka/url@1.0.0-next.29':
-    resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
-
-  '@rayhanadev/truffler@0.4.2':
-    resolution: {integrity: sha512-806qcBqAciR4/q0hUqgRLMIDxo/I+AGvzsk9ASQD1HU7OCQhwdM44FvtyxOAJTqS6Rmy1smgkaVB1q+Ehkmgng==}
-    engines: {bun: '>=1.3.0', node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-
-  '@rollup/rollup-android-arm-eabi@4.57.1':
-    resolution: {integrity: sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==}
-    cpu: [arm]
-    os: [android]
-
-  '@rollup/rollup-android-arm64@4.57.1':
-    resolution: {integrity: sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==}
-    cpu: [arm64]
-    os: [android]
-
-  '@rollup/rollup-darwin-arm64@4.57.1':
-    resolution: {integrity: sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@rollup/rollup-darwin-x64@4.57.1':
-    resolution: {integrity: sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==}
-    cpu: [x64]
-    os: [darwin]
-
-  '@rollup/rollup-freebsd-arm64@4.57.1':
-    resolution: {integrity: sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@rollup/rollup-freebsd-x64@4.57.1':
-    resolution: {integrity: sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@rollup/rollup-linux-arm-gnueabihf@4.57.1':
-    resolution: {integrity: sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==}
-    cpu: [arm]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-arm-musleabihf@4.57.1':
-    resolution: {integrity: sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==}
-    cpu: [arm]
-    os: [linux]
-    libc: [musl]
-
-  '@rollup/rollup-linux-arm64-gnu@4.57.1':
-    resolution: {integrity: sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-arm64-musl@4.57.1':
-    resolution: {integrity: sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@rollup/rollup-linux-loong64-gnu@4.57.1':
-    resolution: {integrity: sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==}
-    cpu: [loong64]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-loong64-musl@4.57.1':
-    resolution: {integrity: sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==}
-    cpu: [loong64]
-    os: [linux]
-    libc: [musl]
-
-  '@rollup/rollup-linux-ppc64-gnu@4.57.1':
-    resolution: {integrity: sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-ppc64-musl@4.57.1':
-    resolution: {integrity: sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==}
-    cpu: [ppc64]
-    os: [linux]
-    libc: [musl]
-
-  '@rollup/rollup-linux-riscv64-gnu@4.57.1':
-    resolution: {integrity: sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-riscv64-musl@4.57.1':
-    resolution: {integrity: sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==}
-    cpu: [riscv64]
-    os: [linux]
-    libc: [musl]
-
-  '@rollup/rollup-linux-s390x-gnu@4.57.1':
-    resolution: {integrity: sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==}
-    cpu: [s390x]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-x64-gnu@4.57.1':
-    resolution: {integrity: sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@rollup/rollup-linux-x64-musl@4.57.1':
-    resolution: {integrity: sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@rollup/rollup-openbsd-x64@4.57.1':
-    resolution: {integrity: sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@rollup/rollup-openharmony-arm64@4.57.1':
-    resolution: {integrity: sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@rollup/rollup-win32-arm64-msvc@4.57.1':
-    resolution: {integrity: sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==}
-    cpu: [arm64]
-    os: [win32]
-
-  '@rollup/rollup-win32-ia32-msvc@4.57.1':
-    resolution: {integrity: sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==}
-    cpu: [ia32]
-    os: [win32]
-
-  '@rollup/rollup-win32-x64-gnu@4.57.1':
-    resolution: {integrity: sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==}
-    cpu: [x64]
-    os: [win32]
-
-  '@rollup/rollup-win32-x64-msvc@4.57.1':
-    resolution: {integrity: sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==}
-    cpu: [x64]
-    os: [win32]
-
-  '@sentry/cli-darwin@3.4.3':
-    resolution: {integrity: sha512-KUeP9d0rQ9L/A4SU9U6K8fMeRaWLV24FVH9JE6V6tbi4S9feJwKjfXXCpsqTk87Do5k0sohaz4SFiOkbypePLA==}
-    engines: {node: '>=18'}
-    os: [darwin]
-
-  '@sentry/cli-linux-arm64@3.4.3':
-    resolution: {integrity: sha512-DPu03ywFtmBC/mtQ2+oWZDPHn9hYPLCYNgSxgBkHKrbYcgv4uJLTrl84at3NI/CU8VnpUbx+oeq03chmezZBPA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux, freebsd, android]
-
-  '@sentry/cli-linux-arm@3.4.3':
-    resolution: {integrity: sha512-3dPFWfaB5g31KnwKuQwHboXfh9+m2Gzk/i6eoQsbMamGQWVguQRHn1mZ1PmGykEMvWH3YFopMcfjPt4euNG/ag==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux, freebsd, android]
-
-  '@sentry/cli-linux-i686@3.4.3':
-    resolution: {integrity: sha512-7Jvx+TZLWJJiKCua6YRDXnE+juSuHP4Tw80HzVtEGTgrgGVJTn2VRCwgDQjPKNrRvjeOK7M6/TnFECOqa750xw==}
-    engines: {node: '>=18'}
-    cpu: [x86, ia32]
-    os: [linux, freebsd, android]
-
-  '@sentry/cli-linux-x64@3.4.3':
-    resolution: {integrity: sha512-2opnMFIx/c1lRqW0SiKMy2q3ChuB7tCadfS8WEJKAMdfQLQrSQmyW/9fhBGK9fDSMqGFVoxU6aaSS89GKnkN8g==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux, freebsd, android]
-
-  '@sentry/cli-win32-arm64@3.4.3':
-    resolution: {integrity: sha512-7Nup5qlbogV99zGcgreTqkUy3IRK1C4T3NYTDVO4iu36E31V0pOqyjqh5WSS/6jf9TkDugmkieSv+UjfKwZMFQ==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@sentry/cli-win32-i686@3.4.3':
-    resolution: {integrity: sha512-ENQtxeeH/jc2FRDSbPDs7RSy4+27RFFa8SxYnQUjWVCxCTgh0w3lfE61RzqWcvQ+4D04g/tPbb3TKMtTQIdcRw==}
-    engines: {node: '>=18'}
-    cpu: [x86, ia32]
-    os: [win32]
-
-  '@sentry/cli-win32-x64@3.4.3':
-    resolution: {integrity: sha512-pd69Woj4U1L/T+t0kmxNx+1GM096tcQg1NQH34IqwrE+tRiui0IKW3euu2E3bcu4ckJWlNmNHwXpONgZELK4EQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
-  '@sentry/cli@3.4.3':
-    resolution: {integrity: sha512-sUhfoIWwkVdM2SVtUdIgfY/3p1z369dYYNOZqPjB/7mpiv4owVVS0BD2Aedx8LdBJaTzRcIzSJMhuJ6vcIiSCg==}
-    engines: {node: '>= 18'}
-    hasBin: true
-
-  '@sentry/core@10.54.0':
-    resolution: {integrity: sha512-yC/bc8N5ut6vk9X/ugTnIFAbzaSZ2uGoKiHRGzt7VseDIrjXk5ENDJP0m7Rbchuozr41kBv2QB3mPcHUhfB43w==}
-    engines: {node: '>=18'}
-
-  '@sentry/node-core@10.54.0':
-    resolution: {integrity: sha512-QR5RnIK78g0Np2+VWMZ3TatM7C+oX9zIQ1W36o3KOjw0nNcXkWjZT1lEu4me8cp2s8s3hA4qT7fwcciQqkj1UQ==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      '@opentelemetry/api': ^1.9.0
-      '@opentelemetry/core': ^1.30.1 || ^2.1.0
-      '@opentelemetry/exporter-trace-otlp-http': '>=0.57.0 <1'
-      '@opentelemetry/instrumentation': '>=0.57.1 <1'
-      '@opentelemetry/sdk-trace-base': ^1.30.1 || ^2.1.0
-      '@opentelemetry/semantic-conventions': ^1.39.0
-    peerDependenciesMeta:
-      '@opentelemetry/api':
-        optional: true
-      '@opentelemetry/core':
-        optional: true
-      '@opentelemetry/exporter-trace-otlp-http':
-        optional: true
-      '@opentelemetry/instrumentation':
-        optional: true
-      '@opentelemetry/sdk-trace-base':
-        optional: true
-      '@opentelemetry/semantic-conventions':
-        optional: true
-
-  '@sentry/node@10.54.0':
-    resolution: {integrity: sha512-Jc31dMBs9aBUv6TXmIPNwv2u18YbfvWQG32IkM3dFWAAoJQhCqLZfN0MEDSf9TeNexIf8qBMZtJRHgHIrWYiGg==}
-    engines: {node: '>=18'}
-
-  '@sentry/opentelemetry@10.54.0':
-    resolution: {integrity: sha512-58Jk9yMos5DwhamDsNmnoQMSNx0yD9E+h1pZwkw34ve2qB9tv+cys3Oz6nfazT9ZdIsXIgpQntN8AfMXAvv4/g==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      '@opentelemetry/api': ^1.9.0
-      '@opentelemetry/core': ^1.30.1 || ^2.1.0
-      '@opentelemetry/sdk-trace-base': ^1.30.1 || ^2.1.0
-      '@opentelemetry/semantic-conventions': ^1.39.0
-
-  '@speed-highlight/core@1.2.15':
-    resolution: {integrity: sha512-BMq1K3DsElxDWawkX6eLg9+CKJrTVGCBAWVuHXVUV2u0s2711qiChLSId6ikYPfxhdYocLNt3wWwSvDiTvFabw==}
-
-  '@standard-schema/spec@1.1.0':
-    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
-
-  '@swc/helpers@0.5.15':
-    resolution: {integrity: sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==}
-
-  '@tailwindcss/node@4.1.18':
-    resolution: {integrity: sha512-DoR7U1P7iYhw16qJ49fgXUlry1t4CpXeErJHnQ44JgTSKMaZUdf17cfn5mHchfJ4KRBZRFA/Coo+MUF5+gOaCQ==}
-
-  '@tailwindcss/oxide-android-arm64@4.1.18':
-    resolution: {integrity: sha512-dJHz7+Ugr9U/diKJA0W6N/6/cjI+ZTAoxPf9Iz9BFRF2GzEX8IvXxFIi/dZBloVJX/MZGvRuFA9rqwdiIEZQ0Q==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [android]
-
-  '@tailwindcss/oxide-darwin-arm64@4.1.18':
-    resolution: {integrity: sha512-Gc2q4Qhs660bhjyBSKgq6BYvwDz4G+BuyJ5H1xfhmDR3D8HnHCmT/BSkvSL0vQLy/nkMLY20PQ2OoYMO15Jd0A==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@tailwindcss/oxide-darwin-x64@4.1.18':
-    resolution: {integrity: sha512-FL5oxr2xQsFrc3X9o1fjHKBYBMD1QZNyc1Xzw/h5Qu4XnEBi3dZn96HcHm41c/euGV+GRiXFfh2hUCyKi/e+yw==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@tailwindcss/oxide-freebsd-x64@4.1.18':
-    resolution: {integrity: sha512-Fj+RHgu5bDodmV1dM9yAxlfJwkkWvLiRjbhuO2LEtwtlYlBgiAT4x/j5wQr1tC3SANAgD+0YcmWVrj8R9trVMA==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18':
-    resolution: {integrity: sha512-Fp+Wzk/Ws4dZn+LV2Nqx3IilnhH51YZoRaYHQsVq3RQvEl+71VGKFpkfHrLM/Li+kt5c0DJe/bHXK1eHgDmdiA==}
-    engines: {node: '>= 10'}
-    cpu: [arm]
-    os: [linux]
-
-  '@tailwindcss/oxide-linux-arm64-gnu@4.1.18':
-    resolution: {integrity: sha512-S0n3jboLysNbh55Vrt7pk9wgpyTTPD0fdQeh7wQfMqLPM/Hrxi+dVsLsPrycQjGKEQk85Kgbx+6+QnYNiHalnw==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
-    resolution: {integrity: sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
-    resolution: {integrity: sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@tailwindcss/oxide-linux-x64-musl@4.1.18':
-    resolution: {integrity: sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@tailwindcss/oxide-wasm32-wasi@4.1.18':
-    resolution: {integrity: sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA==}
-    engines: {node: '>=14.0.0'}
-    cpu: [wasm32]
-    bundledDependencies:
-      - '@napi-rs/wasm-runtime'
-      - '@emnapi/core'
-      - '@emnapi/runtime'
-      - '@tybys/wasm-util'
-      - '@emnapi/wasi-threads'
-      - tslib
-
-  '@tailwindcss/oxide-win32-arm64-msvc@4.1.18':
-    resolution: {integrity: sha512-HjSA7mr9HmC8fu6bdsZvZ+dhjyGCLdotjVOgLA2vEqxEBZaQo9YTX4kwgEvPCpRh8o4uWc4J/wEoFzhEmjvPbA==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@tailwindcss/oxide-win32-x64-msvc@4.1.18':
-    resolution: {integrity: sha512-bJWbyYpUlqamC8dpR7pfjA0I7vdF6t5VpUGMWRkXVE3AXgIZjYUYAK7II1GNaxR8J1SSrSrppRar8G++JekE3Q==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [win32]
-
-  '@tailwindcss/oxide@4.1.18':
-    resolution: {integrity: sha512-EgCR5tTS5bUSKQgzeMClT6iCY3ToqE1y+ZB0AKldj809QXk1Y+3jB0upOYZrn9aGIzPtUsP7sX4QQ4XtjBB95A==}
-    engines: {node: '>= 10'}
-
-  '@tailwindcss/postcss@4.1.18':
-    resolution: {integrity: sha512-Ce0GFnzAOuPyfV5SxjXGn0CubwGcuDB0zcdaPuCSzAa/2vII24JTkH+I6jcbXLb1ctjZMZZI6OjDaLPJQL1S0g==}
-
-  '@turbo/darwin-64@2.9.7':
-    resolution: {integrity: sha512-wnvOWuVWJ5EUHNKxExEWiGlTeVpLG1L0PCu5MUozyC1P2SHGiWsmpW6/yAuShH91Fa2TAHOvdCRBzriZh4j4Eg==}
-    cpu: [x64]
-    os: [darwin]
-
-  '@turbo/darwin-arm64@2.9.7':
-    resolution: {integrity: sha512-mA0FIPMwwN3lodDkQYaGxj6PeT7ZaN5aCEbkKn/WB+ZB9yJdVWA4J83GH7t43jqDc5dcnVluVN5UFx3plRiXhA==}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@turbo/linux-64@2.9.7':
-    resolution: {integrity: sha512-fEbUYpgb5l7P+q+5tsWF2gw+/GSjUsuUTcnfm+f0lozUjgcjLKyOat6PgtAChmIFcTPchCL/8rJ3TvkBy01gfA==}
-    cpu: [x64]
-    os: [linux]
-
-  '@turbo/linux-arm64@2.9.7':
-    resolution: {integrity: sha512-VkUjulo9ytfHKUHOS5gy0XPoh4CTKPXWCL8nLdrlHVi9fSut31ECeUqnm/dAbETP5D4xo9mH9XkJ+qMzGe/zmg==}
-    cpu: [arm64]
-    os: [linux]
-
-  '@turbo/windows-64@2.9.7':
-    resolution: {integrity: sha512-/GWdY6/x4aIHqkYJq596Rpdk1x0MkpRPkJcLAoB3yGRwyUms0+u2F1GnV54IbyAZTeKLRWSJKzNC+QwVGdYchA==}
-    cpu: [x64]
-    os: [win32]
-
-  '@turbo/windows-arm64@2.9.7':
-    resolution: {integrity: sha512-xBBgxCC5PK2+WZ1PPRZdp+aJ0bMBcEbweXWux3RUHJvX9ZodcoQySkrW6qt+ahb+uk8ZjyQodLfDwtVSoYds1w==}
-    cpu: [arm64]
-    os: [win32]
-
-  '@tybys/wasm-util@0.10.2':
-    resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
-
-  '@types/babel__code-frame@7.27.0':
-    resolution: {integrity: sha512-Dwlo+LrxDx/0SpfmJ/BKveHf7QXWvLBLc+x03l5sbzykj3oB9nHygCpSECF1a+s+QIxbghe+KHqC90vGtxLRAA==}
-
-  '@types/chai@5.2.3':
-    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
-
-  '@types/deep-eql@4.0.2':
-    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
-
-  '@types/esrecurse@4.3.1':
-    resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
-
-  '@types/estree@1.0.8':
-    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
-
-  '@types/json-schema@7.0.15':
-    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
-
-  '@types/minimatch@5.1.2':
-    resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==}
-
-  '@types/node@12.20.55':
-    resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
-
-  '@types/node@25.6.0':
-    resolution: {integrity: sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==}
-
-  '@types/picomatch@4.0.3':
-    resolution: {integrity: sha512-iG0T6+nYJ9FAPmx9SsUlnwcq1ZVRuCXcVEvWnntoPlrOpwtSTKNDC9uVAxTsC3PUvJ+99n4RpAcNgBbHX3JSnQ==}
-
-  '@types/prompts@2.4.9':
-    resolution: {integrity: sha512-qTxFi6Buiu8+50/+3DGIWLHM6QuWsEKugJnnP6iv2Mc4ncxE4A/OJkjuVOA+5X0X1S/nq5VJRa8Lu+nwcvbrKA==}
-
-  '@types/react-dom@19.2.3':
-    resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
-    peerDependencies:
-      '@types/react': ^19.2.0
-
-  '@types/react@19.2.14':
-    resolution: {integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==}
-
-  '@types/semver@7.7.1':
-    resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==}
-
-  '@types/vscode@1.120.0':
-    resolution: {integrity: sha512-feaT4Rst+FkTch5zz/ZbNCxoIvo55YU80Be2kiL7OJcod4+CUYf2lUBPdIJzozNnSEMq1VRTGrWEcCGFB3fBmA==}
-
-  '@types/ws@8.18.1':
-    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
-
-  '@typescript-eslint/types@8.59.3':
-    resolution: {integrity: sha512-ePFoH0g4ludssdRFqqDxQePCxU4WQyRa9+XVwjm7yLn0FKhMeoetC+qBEEI1Eyb1pGSDveTIT09Bvw2WhlGayg==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  '@vercel/analytics@2.0.1':
-    resolution: {integrity: sha512-MTQG6V9qQrt1tsDeF+2Uoo5aPjqbVPys1xvnIftXSJYG2SrwXRHnqEvVoYID7BTruDz4lCd2Z7rM1BdkUehk2g==}
-    peerDependencies:
-      '@remix-run/react': ^2
-      '@sveltejs/kit': ^1 || ^2
-      next: '>= 13'
-      nuxt: '>= 3'
-      react: ^18 || ^19 || ^19.0.0-rc
-      svelte: '>= 4'
-      vue: ^3
-      vue-router: ^4
-    peerDependenciesMeta:
-      '@remix-run/react':
-        optional: true
-      '@sveltejs/kit':
-        optional: true
-      next:
-        optional: true
-      nuxt:
-        optional: true
-      react:
-        optional: true
-      svelte:
-        optional: true
-      vue:
-        optional: true
-      vue-router:
-        optional: true
-
-  '@vitest/expect@4.1.7':
-    resolution: {integrity: sha512-1R+tw0ortHEbZDGMymm+pN7/AFQ/RkFFdtd7EN+VBpynKmLbP8A3rpEXdshBJ7+8hQ9zBJh/i1s0yKNtxAnU7w==}
-
-  '@vitest/mocker@4.1.7':
-    resolution: {integrity: sha512-vY7nuamKgfvpA1Koa3oYIw/k7D6kZnpGyNMZW8loow2bsBYla1TFdqTaXncWdRn4pgwNs+90RhnXhJScDwQeJA==}
-    peerDependencies:
-      msw: ^2.4.9
-      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
-    peerDependenciesMeta:
-      msw:
-        optional: true
-      vite:
-        optional: true
-
-  '@vitest/pretty-format@4.1.7':
-    resolution: {integrity: sha512-umgCarTOYQWIaDMvGDRZij+6b9oVeLIyJzfN+AS88e0ZOU3QTgNNSTtjQOpcvWr3np1N0j4WgZj+sb3oYBDscw==}
-
-  '@vitest/runner@4.1.7':
-    resolution: {integrity: sha512-BapjmAQ2aI78WdMEfeUWivnfVzB+VPGwWRQcJE0OUq7qEeEcBsCSf+0T5iREBNE5nBb4wA5Ya0W6IA+sghdEFw==}
-
-  '@vitest/snapshot@4.1.7':
-    resolution: {integrity: sha512-ZacLzja+TmJeZ1h14xW2FB/WpeimUD3haBXQPyJqxvo8jQTmfeA8zv58mtjN2C7EHXZDYVcVYdYmAxjkWVvKCw==}
-
-  '@vitest/spy@4.1.7':
-    resolution: {integrity: sha512-kbkI5LMWakyuTIvs6fUJ5qdIVb1XVKsYJAT4OJ938cHMROYMSfmoQdZy0aaAnjbbc8F61vkoTqz/Az+/HiIu5Q==}
-
-  '@vitest/utils@4.1.7':
-    resolution: {integrity: sha512-T532WBu791cBxJlCl6SO+J14l81DQx6uQHm1bQbmCDY7nqlEIgkza/UFnSBNaUtSf41unldDFjdOBYEQC4b5Hw==}
-
-  '@voidzero-dev/vite-plus-core@0.1.20':
-    resolution: {integrity: sha512-4KmzRfzwTeG3JuvDijrdqWusSgRvLMKDPrVsDdtbDVVjEMq0VnM8lSH+Nvepd6Pg+SuSVUP212OIfH/3Yn1bfA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    peerDependencies:
-      '@arethetypeswrong/core': ^0.18.1
-      '@tsdown/css': 0.21.10
-      '@tsdown/exe': 0.21.10
-      '@types/node': ^20.19.0 || >=22.12.0
-      '@vitejs/devtools': ^0.1.0
-      esbuild: ^0.27.0 || ^0.28.0
-      jiti: '>=1.21.0'
-      less: ^4.0.0
-      publint: ^0.3.0
-      sass: ^1.70.0
-      sass-embedded: ^1.70.0
-      stylus: '>=0.54.8'
-      sugarss: ^5.0.0
-      terser: ^5.16.0
-      tsx: ^4.8.1
-      typescript: ^5.0.0 || ^6.0.0
-      unplugin-unused: ^0.5.0
-      yaml: ^2.4.2
-    peerDependenciesMeta:
-      '@arethetypeswrong/core':
-        optional: true
-      '@tsdown/css':
-        optional: true
-      '@tsdown/exe':
-        optional: true
-      '@types/node':
-        optional: true
-      '@vitejs/devtools':
-        optional: true
-      esbuild:
-        optional: true
-      jiti:
-        optional: true
-      less:
-        optional: true
-      publint:
-        optional: true
-      sass:
-        optional: true
-      sass-embedded:
-        optional: true
-      stylus:
-        optional: true
-      sugarss:
-        optional: true
-      terser:
-        optional: true
-      tsx:
-        optional: true
-      typescript:
-        optional: true
-      unplugin-unused:
-        optional: true
-      yaml:
-        optional: true
-
-  '@voidzero-dev/vite-plus-darwin-arm64@0.1.20':
-    resolution: {integrity: sha512-ykCOJk91h0IEMvljYGTauI4Svxr/CatZAitofvtEFqaTCLE3n06QCHD8qWphMM784VnPz1G/J2xuewxbQduNlg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@voidzero-dev/vite-plus-darwin-x64@0.1.20':
-    resolution: {integrity: sha512-5XxNW9cYEh85Z4BErALyWh/tLP/NZmxNXzUQ0FanhHreI2Zq7FfgbSqQNvC7/sYsPYTWf74RlxmIjzV7R/Lb5Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [darwin]
-
-  '@voidzero-dev/vite-plus-linux-arm64-gnu@0.1.20':
-    resolution: {integrity: sha512-Mc7npPBd9t/h0haURVCZGae+TfB0Yx2Ex8HbPKOVA4hnN9ynlMhMpLRFfTQAicDKYbEGDhfBcbCIX0vVv4vacA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@voidzero-dev/vite-plus-linux-arm64-musl@0.1.20':
-    resolution: {integrity: sha512-Oh/pxMdTLR/wsDl/OONjItjLOeTewFBLuKkH5RQmcI9g3AVqKzLj1/uawujgysBI5E25tonRRK7I2q/zu8Uqvg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@voidzero-dev/vite-plus-linux-x64-gnu@0.1.20':
-    resolution: {integrity: sha512-msO1ZoUX5aSK8L6kN1C3XQO4CcH9aFsNPRSNcO1cjk1kTnaLyVYzkVxgvbh3vk7nzZAAMkmyZ4SlMpqJrdahrg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@voidzero-dev/vite-plus-linux-x64-musl@0.1.20':
-    resolution: {integrity: sha512-U93urREvg23ZFDkxKkkfWWIOI4GI9erhbWAZpXG+GeYqygWKrVC6PUTXiuexVg3/CFg2sSMTdm1W6V7TFG5hYA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@voidzero-dev/vite-plus-test@0.1.20':
-    resolution: {integrity: sha512-vy2dJYw1bhgQ/+BrQrfwPlSKzQ2mm3YLJ9kGF7Yo0UJ2P3XKpshtgFIWLjSg/IASnC93OAx0c/7j3NM0I1RMuA==}
-    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
-    peerDependencies:
-      '@edge-runtime/vm': '*'
-      '@opentelemetry/api': ^1.9.0
-      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
-      '@vitest/coverage-istanbul': 4.1.5
-      '@vitest/coverage-v8': 4.1.5
-      '@vitest/ui': 4.1.5
-      happy-dom: '*'
-      jsdom: '*'
-      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
-    peerDependenciesMeta:
-      '@edge-runtime/vm':
-        optional: true
-      '@opentelemetry/api':
-        optional: true
-      '@types/node':
-        optional: true
-      '@vitest/coverage-istanbul':
-        optional: true
-      '@vitest/coverage-v8':
-        optional: true
-      '@vitest/ui':
-        optional: true
-      happy-dom:
-        optional: true
-      jsdom:
-        optional: true
-
-  '@voidzero-dev/vite-plus-win32-arm64-msvc@0.1.20':
-    resolution: {integrity: sha512-deXfe3h2OpzKV88s1PMUgVOJfN9LlnDDpIEVH6y2+YAXwlTSO7YeKBj2QmyS6ALZCI4Rfp4HOsB0OKMVBfEqww==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [arm64]
-    os: [win32]
-
-  '@voidzero-dev/vite-plus-win32-x64-msvc@0.1.20':
-    resolution: {integrity: sha512-ygdgQgo0N9oUI1Q2IdYBcvr+KLY6riaqLY/bkWNYtvHS4uk8a4GuEd0F08znWt2E8sFm29i35bYIzI6fFY2EBg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    cpu: [x64]
-    os: [win32]
-
-  '@xterm/headless@6.0.0':
-    resolution: {integrity: sha512-5Yj1QINYCyzrZtf8OFIHi47iQtI+0qYFPHmouEfG8dHNxbZ9Tb9YGSuLcsEwj9Z+OL75GJqPyJbyoFer80a2Hw==}
-
-  acorn-import-attributes@1.9.5:
-    resolution: {integrity: sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==}
-    peerDependencies:
-      acorn: ^8
-
-  acorn-jsx@5.3.2:
-    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
-    peerDependencies:
-      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
-
-  acorn@8.16.0:
-    resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==}
-    engines: {node: '>=0.4.0'}
-    hasBin: true
-
-  agent-install@0.0.5:
-    resolution: {integrity: sha512-nHlms9BkP8ZiY79HrwCGiA2DcNaXrAaJrCM/BEqQ7MEsSKyCk+2A76xPGylIfASZSZE0SaU3T0bNSg4rBPIJAQ==}
-    hasBin: true
-
-  ajv-formats@3.0.1:
-    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
-    peerDependencies:
-      ajv: ^8.0.0
-    peerDependenciesMeta:
-      ajv:
-        optional: true
-
-  ajv@6.14.0:
-    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
-
-  ajv@8.20.0:
-    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
-
-  ansi-colors@4.1.3:
-    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
-    engines: {node: '>=6'}
-
-  ansi-regex@5.0.1:
-    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
-    engines: {node: '>=8'}
-
-  ansi-regex@6.2.2:
-    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
-    engines: {node: '>=12'}
-
-  ansi-styles@4.3.0:
-    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
-    engines: {node: '>=8'}
-
-  argparse@1.0.10:
-    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
-
-  argparse@2.0.1:
-    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
-
-  arkregex@0.0.5:
-    resolution: {integrity: sha512-ncYjBdLlh5/QnVsAA8De16Tc9EqmYM7y/WU9j+236KcyYNUXogpz3sC4ATIZYzzLxwI+0sEOaQLEmLmRleaEXw==}
-
-  arktype@2.2.0:
-    resolution: {integrity: sha512-t54MZ7ti5BhOEvzEkgKnWvqj+UbDfWig+DHr5I34xatymPusKLS0lQpNJd8M6DzmIto2QGszHfNKoFIT8tMCZQ==}
-
-  array-union@2.1.0:
-    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
-    engines: {node: '>=8'}
-
-  assertion-error@2.0.1:
-    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
-    engines: {node: '>=12'}
-
-  atomically@2.1.1:
-    resolution: {integrity: sha512-P4w9o2dqARji6P7MHprklbfiArZAWvo07yW7qs3pdljb3BWr12FIB7W+p0zJiuiVsUpRO0iZn1kFFcpPegg0tQ==}
-
-  balanced-match@1.0.2:
-    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
-
-  balanced-match@4.0.4:
-    resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
-    engines: {node: 18 || 20 || >=22}
-
-  baseline-browser-mapping@2.9.19:
-    resolution: {integrity: sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==}
-    hasBin: true
-
-  better-path-resolve@1.0.0:
-    resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==}
-    engines: {node: '>=4'}
-
-  brace-expansion@1.1.13:
-    resolution: {integrity: sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==}
-
-  brace-expansion@2.1.1:
-    resolution: {integrity: sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==}
-
-  brace-expansion@5.0.6:
-    resolution: {integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==}
-    engines: {node: 18 || 20 || >=22}
-
-  braces@3.0.3:
-    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
-    engines: {node: '>=8'}
-
-  browserslist@4.28.1:
-    resolution: {integrity: sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==}
-    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
-    hasBin: true
-
-  buffer-from@1.1.2:
-    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
-
-  callsites@3.1.0:
-    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
-    engines: {node: '>=6'}
-
-  caniuse-lite@1.0.30001769:
-    resolution: {integrity: sha512-BCfFL1sHijQlBGWBMuJyhZUhzo7wer5sVj9hqekB/7xn0Ypy+pER/edCYQm4exbXj4WiySGp40P8UuTh6w1srg==}
-
-  chai@6.2.2:
-    resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
-    engines: {node: '>=18'}
-
-  chalk@4.1.2:
-    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
-    engines: {node: '>=10'}
-
-  chalk@5.6.2:
-    resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==}
-    engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
-
-  chardet@2.1.1:
-    resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
-
-  cjs-module-lexer@2.2.0:
-    resolution: {integrity: sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==}
-
-  cli-cursor@5.0.0:
-    resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==}
-    engines: {node: '>=18'}
-
-  cli-spinners@3.4.0:
-    resolution: {integrity: sha512-bXfOC4QcT1tKXGorxL3wbJm6XJPDqEnij2gQ2m7ESQuE+/z9YFIWnl/5RpTiKWbMq3EVKR4fRLJGn6DVfu0mpw==}
-    engines: {node: '>=18.20'}
-
-  client-only@0.0.1:
-    resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==}
-
-  color-convert@2.0.1:
-    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
-    engines: {node: '>=7.0.0'}
-
-  color-name@1.1.4:
-    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
-
-  commander@14.0.3:
-    resolution: {integrity: sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==}
-    engines: {node: '>=20'}
-
-  commander@2.20.3:
-    resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
-
-  concat-map@0.0.1:
-    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
-
-  conf@15.1.0:
-    resolution: {integrity: sha512-Uy5YN9KEu0WWDaZAVJ5FAmZoaJt9rdK6kH+utItPyGsCqCgaTKkrmZx3zoE0/3q6S3bcp3Ihkk+ZqPxWxFK5og==}
-    engines: {node: '>=20'}
-
-  confbox@0.2.4:
-    resolution: {integrity: sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==}
-
-  convert-source-map@2.0.0:
-    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
-
-  cross-env@10.1.0:
-    resolution: {integrity: sha512-GsYosgnACZTADcmEyJctkJIoqAhHjttw7RsFrVoJNXbsWWqaq6Ym+7kZjq6mS45O0jij6vtiReppKQEtqWy6Dw==}
-    engines: {node: '>=20'}
-    hasBin: true
-
-  cross-spawn@7.0.6:
-    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
-    engines: {node: '>= 8'}
-
-  csstype@3.2.3:
-    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
-
-  dataloader@1.4.0:
-    resolution: {integrity: sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==}
-
-  debounce-fn@6.0.0:
-    resolution: {integrity: sha512-rBMW+F2TXryBwB54Q0d8drNEI+TfoS9JpNTAoVpukbWEhjXQq4rySFYLaqXMFXwdv61Zb2OHtj5bviSoimqxRQ==}
-    engines: {node: '>=18'}
-
-  debug@4.4.3:
-    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
-    engines: {node: '>=6.0'}
-    peerDependencies:
-      supports-color: '*'
-    peerDependenciesMeta:
-      supports-color:
-        optional: true
-
-  deep-is@0.1.4:
-    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
-
-  detect-indent@6.1.0:
-    resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==}
-    engines: {node: '>=8'}
-
-  detect-libc@2.1.2:
-    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
-    engines: {node: '>=8'}
-
-  dir-glob@3.0.1:
-    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
-    engines: {node: '>=8'}
-
-  dot-prop@10.1.0:
-    resolution: {integrity: sha512-MVUtAugQMOff5RnBy2d9N31iG0lNwg1qAoAOn7pOK5wf94WIaE3My2p3uwTQuvS2AcqchkcR3bHByjaM0mmi7Q==}
-    engines: {node: '>=20'}
-
-  dotenv@8.6.0:
-    resolution: {integrity: sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==}
-    engines: {node: '>=10'}
-
-  effect@4.0.0-beta.70:
-    resolution: {integrity: sha512-8AwGTRiNriirHGEYHrOS0E9fzdhIqCdZjiHP1YXmNo2UyPGS43ILsymsSHT7V0DJS+8dvlKq2RxnrDBUhDNZHg==}
-
-  electron-to-chromium@1.5.286:
-    resolution: {integrity: sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A==}
-
-  enhanced-resolve@5.19.0:
-    resolution: {integrity: sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==}
-    engines: {node: '>=10.13.0'}
-
-  enquirer@2.4.1:
-    resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==}
-    engines: {node: '>=8.6'}
-
-  env-paths@3.0.0:
-    resolution: {integrity: sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-
-  es-module-lexer@1.7.0:
-    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
-
-  es-module-lexer@2.1.0:
-    resolution: {integrity: sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==}
-
-  esbuild@0.25.12:
-    resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==}
-    engines: {node: '>=18'}
-    hasBin: true
-
-  esbuild@0.27.3:
-    resolution: {integrity: sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==}
-    engines: {node: '>=18'}
-    hasBin: true
-
-  esbuild@0.28.1:
-    resolution: {integrity: sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==}
-    engines: {node: '>=18'}
-    hasBin: true
-
-  escalade@3.2.0:
-    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
-    engines: {node: '>=6'}
-
-  escape-string-regexp@4.0.0:
-    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
-    engines: {node: '>=10'}
-
-  eslint-plugin-react-hooks@7.1.1:
-    resolution: {integrity: sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0
-
-  eslint-scope@8.4.0:
-    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  eslint-scope@9.1.2:
-    resolution: {integrity: sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
-
-  eslint-visitor-keys@3.4.3:
-    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-
-  eslint-visitor-keys@4.2.1:
-    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  eslint-visitor-keys@5.0.1:
-    resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
-    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
-
-  eslint@9.39.2:
-    resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-    hasBin: true
-    peerDependencies:
-      jiti: '*'
-    peerDependenciesMeta:
-      jiti:
-        optional: true
-
-  espree@10.4.0:
-    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
-  esprima@4.0.1:
-    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
-    engines: {node: '>=4'}
-    hasBin: true
-
-  esquery@1.7.0:
-    resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==}
-    engines: {node: '>=0.10'}
-
-  esrecurse@4.3.0:
-    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
-    engines: {node: '>=4.0'}
-
-  estraverse@5.3.0:
-    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
-    engines: {node: '>=4.0'}
-
-  estree-walker@3.0.3:
-    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
-
-  esutils@2.0.3:
-    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
-    engines: {node: '>=0.10.0'}
-
-  expect-type@1.3.0:
-    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
-    engines: {node: '>=12.0.0'}
-
-  extendable-error@0.1.7:
-    resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==}
-
-  fast-check@4.8.0:
-    resolution: {integrity: sha512-GOJ158CUMnN6cSahsv4+ExARvIDuzzinFjkp0E9WtiBa5zcVeLozVkWaE4IzFcc+Y48Wp1EDlUZsXRyAztQcSg==}
-    engines: {node: '>=12.17.0'}
-
-  fast-deep-equal@3.1.3:
-    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
-
-  fast-glob@3.3.3:
-    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
-    engines: {node: '>=8.6.0'}
-
-  fast-json-stable-stringify@2.1.0:
-    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
-
-  fast-levenshtein@2.0.6:
-    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
-
-  fast-uri@3.1.2:
-    resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==}
-
-  fastq@1.20.1:
-    resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
-
-  fdir@6.5.0:
-    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
-    engines: {node: '>=12.0.0'}
-    peerDependencies:
-      picomatch: ^3 || ^4
-    peerDependenciesMeta:
-      picomatch:
-        optional: true
-
-  file-entry-cache@8.0.0:
-    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
-    engines: {node: '>=16.0.0'}
-
-  fill-range@7.1.1:
-    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
-    engines: {node: '>=8'}
-
-  find-my-way-ts@0.1.6:
-    resolution: {integrity: sha512-a85L9ZoXtNAey3Y6Z+eBWW658kO/MwR7zIafkIUPUMf3isZG0NCs2pjW2wtjxAKuJPxMAsHUIP4ZPGv0o5gyTA==}
-
-  find-up@4.1.0:
-    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
-    engines: {node: '>=8'}
-
-  find-up@5.0.0:
-    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
-    engines: {node: '>=10'}
-
-  flat-cache@4.0.1:
-    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
-    engines: {node: '>=16'}
-
-  flatted@3.4.2:
-    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
-
-  fs-extra@7.0.1:
-    resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==}
-    engines: {node: '>=6 <7 || >=8'}
-
-  fs-extra@8.1.0:
-    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
-    engines: {node: '>=6 <7 || >=8'}
-
-  fsevents@2.3.3:
-    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
-    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
-    os: [darwin]
-
-  gensync@1.0.0-beta.2:
-    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
-    engines: {node: '>=6.9.0'}
-
-  get-east-asian-width@1.4.0:
-    resolution: {integrity: sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==}
-    engines: {node: '>=18'}
-
-  glob-parent@5.1.2:
-    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
-    engines: {node: '>= 6'}
-
-  glob-parent@6.0.2:
-    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
-    engines: {node: '>=10.13.0'}
-
-  glob@13.0.6:
-    resolution: {integrity: sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==}
-    engines: {node: 18 || 20 || >=22}
-
-  globals@14.0.0:
-    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
-    engines: {node: '>=18'}
-
-  globby@11.1.0:
-    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
-    engines: {node: '>=10'}
-
-  graceful-fs@4.2.11:
-    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
-
-  has-flag@4.0.0:
-    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
-    engines: {node: '>=8'}
-
-  hermes-estree@0.25.1:
-    resolution: {integrity: sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==}
-
-  hermes-parser@0.25.1:
-    resolution: {integrity: sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==}
-
-  human-id@4.1.3:
-    resolution: {integrity: sha512-tsYlhAYpjCKa//8rXZ9DqKEawhPoSytweBC2eNvcaDK+57RZLHGqNs3PZTQO6yekLFSuvA6AlnAfrw1uBvtb+Q==}
-    hasBin: true
-
-  iconv-lite@0.7.2:
-    resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
-    engines: {node: '>=0.10.0'}
-
-  ignore@5.3.2:
-    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
-    engines: {node: '>= 4'}
-
-  import-fresh@3.3.1:
-    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
-    engines: {node: '>=6'}
-
-  import-in-the-middle@3.0.1:
-    resolution: {integrity: sha512-pYkiyXVL2Mf3pozdlDGV6NAObxQx13Ae8knZk1UJRJ6uRW/ZRmTGHlQYtrsSl7ubuE5F8CD1z+s1n4RHNuTtuA==}
-    engines: {node: '>=18'}
-
-  imurmurhash@0.1.4:
-    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
-    engines: {node: '>=0.8.19'}
-
-  ini@7.0.0:
-    resolution: {integrity: sha512-ifK0CgjALofS5bkrcTy4RaQ9Vx2Knf/eLeIO+NaswQEpH1UblrtTSCIvN71qQDMq0PeQ/SSPojvEJp9vvvfr+w==}
-    engines: {node: ^22.22.2 || ^24.15.0 || >=26.0.0}
-
-  is-extglob@2.1.1:
-    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
-    engines: {node: '>=0.10.0'}
-
-  is-glob@4.0.3:
-    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
-    engines: {node: '>=0.10.0'}
-
-  is-interactive@2.0.0:
-    resolution: {integrity: sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==}
-    engines: {node: '>=12'}
-
-  is-number@7.0.0:
-    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
-    engines: {node: '>=0.12.0'}
-
-  is-subdir@1.2.0:
-    resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==}
-    engines: {node: '>=4'}
-
-  is-unicode-supported@2.1.0:
-    resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==}
-    engines: {node: '>=18'}
-
-  is-windows@1.0.2:
-    resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
-    engines: {node: '>=0.10.0'}
-
-  isexe@2.0.0:
-    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
-
-  jiti@2.7.0:
-    resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
-    hasBin: true
-
-  js-tokens@4.0.0:
-    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
-
-  js-yaml@3.14.2:
-    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
-    hasBin: true
-
-  js-yaml@4.1.1:
-    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
-    hasBin: true
-
-  jsesc@3.1.0:
-    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
-    engines: {node: '>=6'}
-    hasBin: true
-
-  json-buffer@3.0.1:
-    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
-
-  json-schema-traverse@0.4.1:
-    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
-
-  json-schema-traverse@1.0.0:
-    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
-
-  json-schema-typed@8.0.2:
-    resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
-
-  json-stable-stringify-without-jsonify@1.0.1:
-    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
-
-  json5@2.2.3:
-    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
-    engines: {node: '>=6'}
-    hasBin: true
-
-  jsonc-parser@3.3.1:
-    resolution: {integrity: sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==}
-
-  jsonfile@4.0.0:
-    resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
-
-  keyv@4.5.4:
-    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
-
-  kleur@3.0.3:
-    resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
-    engines: {node: '>=6'}
-
-  kubernetes-types@1.30.0:
-    resolution: {integrity: sha512-Dew1okvhM/SQcIa2rcgujNndZwU8VnSapDgdxlYoB84ZlpAD43U6KLAFqYo17ykSFGHNPrg0qry0bP+GJd9v7Q==}
-
-  levn@0.4.1:
-    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
-    engines: {node: '>= 0.8.0'}
-
-  lightningcss-android-arm64@1.30.2:
-    resolution: {integrity: sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [arm64]
-    os: [android]
-
-  lightningcss-darwin-arm64@1.30.2:
-    resolution: {integrity: sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [arm64]
-    os: [darwin]
-
-  lightningcss-darwin-x64@1.30.2:
-    resolution: {integrity: sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [x64]
-    os: [darwin]
-
-  lightningcss-freebsd-x64@1.30.2:
-    resolution: {integrity: sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [x64]
-    os: [freebsd]
-
-  lightningcss-linux-arm-gnueabihf@1.30.2:
-    resolution: {integrity: sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [arm]
-    os: [linux]
-
-  lightningcss-linux-arm64-gnu@1.30.2:
-    resolution: {integrity: sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  lightningcss-linux-arm64-musl@1.30.2:
-    resolution: {integrity: sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  lightningcss-linux-x64-gnu@1.30.2:
-    resolution: {integrity: sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  lightningcss-linux-x64-musl@1.30.2:
-    resolution: {integrity: sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  lightningcss-win32-arm64-msvc@1.30.2:
-    resolution: {integrity: sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [arm64]
-    os: [win32]
-
-  lightningcss-win32-x64-msvc@1.30.2:
-    resolution: {integrity: sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==}
-    engines: {node: '>= 12.0.0'}
-    cpu: [x64]
-    os: [win32]
-
-  lightningcss@1.30.2:
-    resolution: {integrity: sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==}
-    engines: {node: '>= 12.0.0'}
-
-  locate-path@5.0.0:
-    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
-    engines: {node: '>=8'}
-
-  locate-path@6.0.0:
-    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
-    engines: {node: '>=10'}
-
-  lodash.merge@4.6.2:
-    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
-
-  lodash.startcase@4.4.0:
-    resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
-
-  log-symbols@7.0.1:
-    resolution: {integrity: sha512-ja1E3yCr9i/0hmBVaM0bfwDjnGy8I/s6PP4DFp+yP+a+mrHO4Rm7DtmnqROTUkHIkqffC84YY7AeqX6oFk0WFg==}
-    engines: {node: '>=18'}
-
-  lru-cache@11.5.0:
-    resolution: {integrity: sha512-5YgH9UJd7wVb9hIouI2adWpgqrrICkt070Dnj8EUY1+B4B2P9eRLPAkAAo6NICA7CEhOIeBHl46u9zSNpNu7zA==}
-    engines: {node: 20 || >=22}
-
-  lru-cache@5.1.1:
-    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
-
-  lucide-react@1.14.0:
-    resolution: {integrity: sha512-+1mdWcfSJVUsaTIjN9zoezmUhfXo5l0vP7ekBMPo3jcS/aIkxHnXqAPsByszMZx/Y8oQBRJxJx5xg+RH3urzxA==}
-    peerDependencies:
-      react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0
-
-  magic-string@0.30.21:
-    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
-
-  magicast@0.5.3:
-    resolution: {integrity: sha512-pVKE4UdSQ7DvHzivsCIFx2BJn1mHG6KsyrFcaxFx6tONdneEuThrDx0Cj3AMg58KyN4pzYT+LHOotxDQDjNvkw==}
-
-  merge2@1.4.1:
-    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
-    engines: {node: '>= 8'}
-
-  micromatch@4.0.8:
-    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
-    engines: {node: '>=8.6'}
-
-  mimic-function@5.0.1:
-    resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
-    engines: {node: '>=18'}
-
-  minimatch@10.2.5:
-    resolution: {integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==}
-    engines: {node: 18 || 20 || >=22}
-
-  minimatch@3.1.5:
-    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
-
-  minimatch@5.1.9:
-    resolution: {integrity: sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==}
-    engines: {node: '>=10'}
-
-  minipass@7.1.3:
-    resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
-    engines: {node: '>=16 || 14 >=14.17'}
-
-  module-details-from-path@1.0.4:
-    resolution: {integrity: sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w==}
-
-  mri@1.2.0:
-    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
-    engines: {node: '>=4'}
-
-  mrmime@2.0.1:
-    resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
-    engines: {node: '>=10'}
-
-  ms@2.1.3:
-    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
-
-  msgpackr-extract@3.0.3:
-    resolution: {integrity: sha512-P0efT1C9jIdVRefqjzOQ9Xml57zpOXnIuS+csaB4MdZbTdmGDLo8XhzBG1N7aO11gKDDkJvBLULeFTo46wwreA==}
-    hasBin: true
-
-  msgpackr@2.0.1:
-    resolution: {integrity: sha512-9J+tqTEsbHqY8YohazYgty7LgerFIWxvMLpUjqETSmjHojtJm2WnX2kK/2a1fLI7CO7ERP1YSEUXMucz4j+yBA==}
-
-  multipasta@0.2.7:
-    resolution: {integrity: sha512-KPA58d68KgGil15oDqXjkUBEBYc00XvbPj5/X+dyzeo/lWm9Nc25pQRlf1D+gv4OpK7NM0J1odrbu9JNNGvynA==}
-
-  nanoid@3.3.11:
-    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
-    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
-    hasBin: true
-
-  natural-compare@1.4.0:
-    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
-
-  next@16.2.4:
-    resolution: {integrity: sha512-kPvz56wF5frc+FxlHI5qnklCzbq53HTwORaWBGdT0vNoKh1Aya9XC8aPauH4NJxqtzbWsS5mAbctm4cr+EkQ2Q==}
-    engines: {node: '>=20.9.0'}
-    hasBin: true
-    peerDependencies:
-      '@opentelemetry/api': ^1.1.0
-      '@playwright/test': ^1.51.1
-      babel-plugin-react-compiler: '*'
-      react: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
-      react-dom: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
-      sass: ^1.3.0
-    peerDependenciesMeta:
-      '@opentelemetry/api':
-        optional: true
-      '@playwright/test':
-        optional: true
-      babel-plugin-react-compiler:
-        optional: true
-      sass:
-        optional: true
-
-  node-fetch@2.7.0:
-    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
-    engines: {node: 4.x || >=6.0.0}
-    peerDependencies:
-      encoding: ^0.1.0
-    peerDependenciesMeta:
-      encoding:
-        optional: true
-
-  node-gyp-build-optional-packages@5.2.2:
-    resolution: {integrity: sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==}
-    hasBin: true
-
-  node-releases@2.0.27:
-    resolution: {integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==}
-
-  normalize-path@3.0.0:
-    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
-    engines: {node: '>=0.10.0'}
-
-  obug@2.1.1:
-    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
-
-  onetime@7.0.0:
-    resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
-    engines: {node: '>=18'}
-
-  optionator@0.9.4:
-    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
-    engines: {node: '>= 0.8.0'}
-
-  ora@9.4.0:
-    resolution: {integrity: sha512-84cglkRILFxdtA8hAvLNdMrtBpPNBTrQ9/ulg0FA7xLMnD6mifv+enAIeRmvtv+WgdCE+LPGOfQmtJRrVaIVhQ==}
-    engines: {node: '>=20'}
-
-  outdent@0.5.0:
-    resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==}
-
-  oxc-parser@0.132.0:
-    resolution: {integrity: sha512-+0LAPHaqtfQlvWdpaAa09SmOaZZgP8C552xosEkGJ4+ruEwP1Vgx+sqBgcBCNfR6KDCmagGOZTde8wmAvcI/Hg==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  oxc-parser@0.135.0:
-    resolution: {integrity: sha512-/DaPStu0s2zzNSRRniKyTPM6Z/o+DapOp2JYNKDL8AsgaBGPK2IdZyB87SQjVH+xeQPz+Qr9mrjglfkYgtbVRA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  oxc-resolver@11.19.1:
-    resolution: {integrity: sha512-qE/CIg/spwrTBFt5aKmwe3ifeDdLfA2NESN30E42X/lII5ClF8V7Wt6WIJhcGZjp0/Q+nQ+9vgxGk//xZNX2hg==}
-
-  oxfmt@0.46.0:
-    resolution: {integrity: sha512-CopwJOwPAjZ9p76fCvz+mSOJTw9/NY3cSksZK3VO/bUQ8UoEcketNgUuYS0UB3p+R9XnXe7wGGXUmyFxc7QxJA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-
-  oxlint-tsgolint@0.23.0:
-    resolution: {integrity: sha512-3mBv3CoPbh8dFbzfDGIWa2ytZjn2v+3EX4aKRXjIhsoGFzG8GCjfRirz3rwZf1wYbZzsNLTSgpw8VjQuWdp/jA==}
-    hasBin: true
-
-  oxlint@1.66.0:
-    resolution: {integrity: sha512-N4LLxYLd94KEBqXDMDM5f+2PUpItTjDLreXe2Gn5KhjhCK4Qp2YUXaBi8Yu325ryOgKwt22m45fpD7nPOn69Yw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-    peerDependencies:
-      oxlint-tsgolint: ^0.23.0
-    peerDependenciesMeta:
-      oxlint-tsgolint:
-        optional: true
-
-  p-filter@2.1.0:
-    resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==}
-    engines: {node: '>=8'}
-
-  p-limit@2.3.0:
-    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
-    engines: {node: '>=6'}
-
-  p-limit@3.1.0:
-    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
-    engines: {node: '>=10'}
-
-  p-locate@4.1.0:
-    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
-    engines: {node: '>=8'}
-
-  p-locate@5.0.0:
-    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
-    engines: {node: '>=10'}
-
-  p-map@2.1.0:
-    resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==}
-    engines: {node: '>=6'}
-
-  p-try@2.2.0:
-    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
-    engines: {node: '>=6'}
-
-  package-manager-detector@0.2.11:
-    resolution: {integrity: sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==}
-
-  parent-module@1.0.1:
-    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
-    engines: {node: '>=6'}
-
-  path-exists@4.0.0:
-    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
-    engines: {node: '>=8'}
-
-  path-key@3.1.1:
-    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
-    engines: {node: '>=8'}
-
-  path-scurry@2.0.2:
-    resolution: {integrity: sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==}
-    engines: {node: 18 || 20 || >=22}
-
-  path-type@4.0.0:
-    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
-    engines: {node: '>=8'}
-
-  pathe@2.0.3:
-    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
-
-  picocolors@1.1.1:
-    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
-
-  picomatch@2.3.1:
-    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
-    engines: {node: '>=8.6'}
-
-  picomatch@4.0.4:
-    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
-    engines: {node: '>=12'}
-
-  pify@4.0.1:
-    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
-    engines: {node: '>=6'}
-
-  pixelmatch@7.2.0:
-    resolution: {integrity: sha512-xhcb4yHu9sM/G7foGzoLtXYcC0zHEaOXXjRKhGup0fw78Nf2Tkiapv4EQyMzrbcmQPsllAI7DbFY2UT7PlI9Pg==}
-    hasBin: true
-
-  pngjs@7.0.0:
-    resolution: {integrity: sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==}
-    engines: {node: '>=14.19.0'}
-
-  postcss@8.4.31:
-    resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==}
-    engines: {node: ^10 || ^12 || >=14}
-
-  postcss@8.5.6:
-    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
-    engines: {node: ^10 || ^12 || >=14}
-
-  prelude-ls@1.2.1:
-    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
-    engines: {node: '>= 0.8.0'}
-
-  prettier@2.8.8:
-    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
-    engines: {node: '>=10.13.0'}
-    hasBin: true
-
-  progress@2.0.3:
-    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
-    engines: {node: '>=0.4.0'}
-
-  prompts@2.4.2:
-    resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
-    engines: {node: '>= 6'}
-
-  proxy-from-env@1.1.0:
-    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
-
-  punycode@2.3.1:
-    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
-    engines: {node: '>=6'}
-
-  pure-rand@8.4.0:
-    resolution: {integrity: sha512-IoM8YF/jY0hiugFo/wOWqfmarlE6J0wc6fDK1PhftMk7MGhVZl88sZimmqBBFomLOCSmcCCpsfj7wXASCpvK9A==}
-
-  quansync@0.2.11:
-    resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==}
-
-  queue-microtask@1.2.3:
-    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
-
-  react-dom@19.2.5:
-    resolution: {integrity: sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag==}
-    peerDependencies:
-      react: ^19.2.5
-
-  react@19.2.5:
-    resolution: {integrity: sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA==}
-    engines: {node: '>=0.10.0'}
-
-  read-yaml-file@1.1.0:
-    resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==}
-    engines: {node: '>=6'}
-
-  require-from-string@2.0.2:
-    resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
-    engines: {node: '>=0.10.0'}
-
-  require-in-the-middle@8.0.1:
-    resolution: {integrity: sha512-QT7FVMXfWOYFbeRBF6nu+I6tr2Tf3u0q8RIEjNob/heKY/nh7drD/k7eeMFmSQgnTtCzLDcCu/XEnpW2wk4xCQ==}
-    engines: {node: '>=9.3.0 || >=8.10.0 <9.0.0'}
-
-  resolve-from@4.0.0:
-    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
-    engines: {node: '>=4'}
-
-  resolve-from@5.0.0:
-    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
-    engines: {node: '>=8'}
-
-  restore-cursor@5.1.0:
-    resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==}
-    engines: {node: '>=18'}
-
-  reusify@1.1.0:
-    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
-    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
-
-  rollup@4.57.1:
-    resolution: {integrity: sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==}
-    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
-    hasBin: true
-
-  run-parallel@1.2.0:
-    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
-
-  sade@1.8.1:
-    resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==}
-    engines: {node: '>=6'}
-
-  safe-stable-stringify@2.5.0:
-    resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
-    engines: {node: '>=10'}
-
-  safer-buffer@2.1.2:
-    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
-
-  scheduler@0.27.0:
-    resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
-
-  semver@6.3.1:
-    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
-    hasBin: true
-
-  semver@7.7.4:
-    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
-    engines: {node: '>=10'}
-    hasBin: true
-
-  sharp@0.34.5:
-    resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
-    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
-
-  shebang-command@2.0.0:
-    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
-    engines: {node: '>=8'}
-
-  shebang-regex@3.0.0:
-    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
-    engines: {node: '>=8'}
-
-  siginfo@2.0.0:
-    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
-
-  signal-exit@4.1.0:
-    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
-    engines: {node: '>=14'}
-
-  sirv@3.0.2:
-    resolution: {integrity: sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==}
-    engines: {node: '>=18'}
-
-  sisteransi@1.0.5:
-    resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
-
-  slash@3.0.0:
-    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
-    engines: {node: '>=8'}
-
-  source-map-js@1.2.1:
-    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
-    engines: {node: '>=0.10.0'}
-
-  source-map-support@0.5.21:
-    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
-
-  source-map@0.6.1:
-    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
-    engines: {node: '>=0.10.0'}
-
-  spawndamnit@3.0.1:
-    resolution: {integrity: sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==}
-
-  sprintf-js@1.0.3:
-    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
-
-  stackback@0.0.2:
-    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
-
-  std-env@4.0.0:
-    resolution: {integrity: sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==}
-
-  stdin-discarder@0.3.2:
-    resolution: {integrity: sha512-eCPu1qRxPVkl5605OTWF8Wz40b4Mf45NY5LQmVPQ599knfs5QhASUm9GbJ5BDMDOXgrnh0wyEdvzmL//YMlw0A==}
-    engines: {node: '>=18'}
-
-  string-width@8.1.1:
-    resolution: {integrity: sha512-KpqHIdDL9KwYk22wEOg/VIqYbrnLeSApsKT/bSj6Ez7pn3CftUiLAv2Lccpq1ALcpLV9UX1Ppn92npZWu2w/aw==}
-    engines: {node: '>=20'}
-
-  strip-ansi@6.0.1:
-    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
-    engines: {node: '>=8'}
-
-  strip-ansi@7.1.2:
-    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
-    engines: {node: '>=12'}
-
-  strip-bom@3.0.0:
-    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
-    engines: {node: '>=4'}
-
-  strip-json-comments@3.1.1:
-    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
-    engines: {node: '>=8'}
-
-  stubborn-fs@2.0.0:
-    resolution: {integrity: sha512-Y0AvSwDw8y+nlSNFXMm2g6L51rBGdAQT20J3YSOqxC53Lo3bjWRtr2BKcfYoAf352WYpsZSTURrA0tqhfgudPA==}
-
-  stubborn-utils@1.0.2:
-    resolution: {integrity: sha512-zOh9jPYI+xrNOyisSelgym4tolKTJCQd5GBhK0+0xJvcYDcwlOoxF/rnFKQ2KRZknXSG9jWAp66fwP6AxN9STg==}
-
-  styled-jsx@5.1.6:
-    resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==}
-    engines: {node: '>= 12.0.0'}
-    peerDependencies:
-      '@babel/core': '*'
-      babel-plugin-macros: '*'
-      react: '>= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0'
-    peerDependenciesMeta:
-      '@babel/core':
-        optional: true
-      babel-plugin-macros:
-        optional: true
-
-  supports-color@7.2.0:
-    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
-    engines: {node: '>=8'}
-
-  tagged-tag@1.0.0:
-    resolution: {integrity: sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==}
-    engines: {node: '>=20'}
-
-  tailwindcss@4.1.18:
-    resolution: {integrity: sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==}
-
-  tapable@2.3.0:
-    resolution: {integrity: sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==}
-    engines: {node: '>=6'}
-
-  term-size@2.2.1:
-    resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
-    engines: {node: '>=8'}
-
-  terser@5.46.0:
-    resolution: {integrity: sha512-jTwoImyr/QbOWFFso3YoU3ik0jBBDJ6JTOQiy/J2YxVJdZCc+5u7skhNwiOR3FQIygFqVUPHl7qbbxtjW2K3Qg==}
-    engines: {node: '>=10'}
-    hasBin: true
-
-  tinybench@2.9.0:
-    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
-
-  tinyexec@1.1.1:
-    resolution: {integrity: sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==}
-    engines: {node: '>=18'}
-
-  tinyglobby@0.2.15:
-    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
-    engines: {node: '>=12.0.0'}
-
-  tinyglobby@0.2.16:
-    resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
-    engines: {node: '>=12.0.0'}
-
-  tinypool@2.1.0:
-    resolution: {integrity: sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==}
-    engines: {node: ^20.0.0 || >=22.0.0}
-
-  tinyrainbow@3.1.0:
-    resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
-    engines: {node: '>=14.0.0'}
-
-  to-regex-range@5.0.1:
-    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
-    engines: {node: '>=8.0'}
-
-  toml@4.1.1:
-    resolution: {integrity: sha512-EBJnVBr3dTXdA89WVFoAIPUqkBjxPMwRqsfuo1r240tKFHXv3zgca4+NJib/h6TyvGF7vOawz0jGuryJCdNHrw==}
-    engines: {node: '>=20'}
-
-  totalist@3.0.1:
-    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
-    engines: {node: '>=6'}
-
-  tr46@0.0.3:
-    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
-
-  ts-json-schema-generator@2.9.0:
-    resolution: {integrity: sha512-NR5ZE108uiPtBHBJNGnhwoUaUx5vWTDJzDFG9YlRoqxPU76n+5FClRh92dcGgysbe1smRmYalM9Saj97GW1J4Q==}
-    engines: {node: '>=22.0.0'}
-    hasBin: true
-
-  tslib@2.8.1:
-    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
-
-  tsx@4.22.4:
-    resolution: {integrity: sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==}
-    engines: {node: '>=18.0.0'}
-    hasBin: true
-
-  turbo@2.9.7:
-    resolution: {integrity: sha512-epxzqVO2s0IxcSWcgb+qKrtco8isfe7g3VtiS6hkYnEK4A9XQDZbrtavQ6MtWR1KoQn+1fUomaQth2rfRHlUlg==}
-    hasBin: true
-
-  type-check@0.4.0:
-    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
-    engines: {node: '>= 0.8.0'}
-
-  type-fest@5.6.0:
-    resolution: {integrity: sha512-8ZiHFm91orbSAe2PSAiSVBVko18pbhbiB3U9GglSzF/zCGkR+rxpHx6sEMCUm4kxY4LjDIUGgCfUMtwfZfjfUA==}
-    engines: {node: '>=20'}
-
-  typescript@5.9.3:
-    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
-    engines: {node: '>=14.17'}
-    hasBin: true
-
-  typescript@6.0.3:
-    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
-    engines: {node: '>=14.17'}
-    hasBin: true
-
-  uint8array-extras@1.5.0:
-    resolution: {integrity: sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==}
-    engines: {node: '>=18'}
-
-  undici-types@7.19.2:
-    resolution: {integrity: sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==}
-
-  undici@6.26.0:
-    resolution: {integrity: sha512-4yqz8a3n5HmGTlsbADNtr/dJlhkh/55Rq798G6ibiULcXbDtaLpTl1pvdqcbFfeoj3iSi52lePFM7h9H21cw/A==}
-    engines: {node: '>=18.17'}
-
-  universalify@0.1.2:
-    resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
-    engines: {node: '>= 4.0.0'}
-
-  update-browserslist-db@1.2.3:
-    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
-    hasBin: true
-    peerDependencies:
-      browserslist: '>= 4.21.0'
-
-  uri-js@4.4.1:
-    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
-
-  uuid@14.0.0:
-    resolution: {integrity: sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==}
-    hasBin: true
-
-  vite-plus@0.1.20:
-    resolution: {integrity: sha512-hxJqXTxiiFhszwAeD0MvKlztVuXE4TztTdJ64BPxGqgY67F0PDa5eZkUsrN91Ae8aYUMfweW6V/J57OUO9/0zw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-
-  vite@7.3.1:
-    resolution: {integrity: sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-    peerDependencies:
-      '@types/node': ^20.19.0 || >=22.12.0
-      jiti: '>=1.21.0'
-      less: ^4.0.0
-      lightningcss: ^1.21.0
-      sass: ^1.70.0
-      sass-embedded: ^1.70.0
-      stylus: '>=0.54.8'
-      sugarss: ^5.0.0
-      terser: ^5.16.0
-      tsx: ^4.8.1
-      yaml: ^2.4.2
-    peerDependenciesMeta:
-      '@types/node':
-        optional: true
-      jiti:
-        optional: true
-      less:
-        optional: true
-      lightningcss:
-        optional: true
-      sass:
-        optional: true
-      sass-embedded:
-        optional: true
-      stylus:
-        optional: true
-      sugarss:
-        optional: true
-      terser:
-        optional: true
-      tsx:
-        optional: true
-      yaml:
-        optional: true
-
-  vitest@4.1.7:
-    resolution: {integrity: sha512-flYyaFd2CgoCoU+0UKt3pxksgC+S02iTDN0n3LtqaMeXsI9SBcdNujc2k0DeFLzUn/0k538yNjOSdwgCqcrwJA==}
-    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
-    hasBin: true
-    peerDependencies:
-      '@edge-runtime/vm': '*'
-      '@opentelemetry/api': ^1.9.0
-      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
-      '@vitest/browser-playwright': 4.1.7
-      '@vitest/browser-preview': 4.1.7
-      '@vitest/browser-webdriverio': 4.1.7
-      '@vitest/coverage-istanbul': 4.1.7
-      '@vitest/coverage-v8': 4.1.7
-      '@vitest/ui': 4.1.7
-      happy-dom: '*'
-      jsdom: '*'
-      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
-    peerDependenciesMeta:
-      '@edge-runtime/vm':
-        optional: true
-      '@opentelemetry/api':
-        optional: true
-      '@types/node':
-        optional: true
-      '@vitest/browser-playwright':
-        optional: true
-      '@vitest/browser-preview':
-        optional: true
-      '@vitest/browser-webdriverio':
-        optional: true
-      '@vitest/coverage-istanbul':
-        optional: true
-      '@vitest/coverage-v8':
-        optional: true
-      '@vitest/ui':
-        optional: true
-      happy-dom:
-        optional: true
-      jsdom:
-        optional: true
-
-  vscode-jsonrpc@8.2.0:
-    resolution: {integrity: sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==}
-    engines: {node: '>=14.0.0'}
-
-  vscode-languageclient@9.0.1:
-    resolution: {integrity: sha512-JZiimVdvimEuHh5olxhxkht09m3JzUGwggb5eRUkzzJhZ2KjCN0nh55VfiED9oez9DyF8/fz1g1iBV3h+0Z2EA==}
-    engines: {vscode: ^1.82.0}
-
-  vscode-languageserver-protocol@3.17.5:
-    resolution: {integrity: sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==}
-
-  vscode-languageserver-textdocument@1.0.12:
-    resolution: {integrity: sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==}
-
-  vscode-languageserver-types@3.17.5:
-    resolution: {integrity: sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==}
-
-  vscode-languageserver@9.0.1:
-    resolution: {integrity: sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==}
-    hasBin: true
-
-  vscode-uri@3.1.0:
-    resolution: {integrity: sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==}
-
-  webidl-conversions@3.0.1:
-    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
-
-  whatwg-url@5.0.0:
-    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
-
-  when-exit@2.1.5:
-    resolution: {integrity: sha512-VGkKJ564kzt6Ms1dbgPP/yuIoQCrsFAnRbptpC5wOEsDaNsbCB2bnfnaA8i/vRs5tjUSEOtIuvl9/MyVsvQZCg==}
-
-  which@2.0.2:
-    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
-    engines: {node: '>= 8'}
-    hasBin: true
-
-  why-is-node-running@2.3.0:
-    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
-    engines: {node: '>=8'}
-    hasBin: true
-
-  word-wrap@1.2.5:
-    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
-    engines: {node: '>=0.10.0'}
-
-  ws@8.20.0:
-    resolution: {integrity: sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==}
-    engines: {node: '>=10.0.0'}
-    peerDependencies:
-      bufferutil: ^4.0.1
-      utf-8-validate: '>=5.0.2'
-    peerDependenciesMeta:
-      bufferutil:
-        optional: true
-      utf-8-validate:
-        optional: true
-
-  yallist@3.1.1:
-    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
-
-  yaml@2.9.0:
-    resolution: {integrity: sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==}
-    engines: {node: '>= 14.6'}
-    hasBin: true
-
-  yocto-queue@0.1.0:
-    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
-    engines: {node: '>=10'}
-
-  yoctocolors@2.1.2:
-    resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==}
-    engines: {node: '>=18'}
-
-  zod-validation-error@4.0.2:
-    resolution: {integrity: sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==}
-    engines: {node: '>=18.0.0'}
-    peerDependencies:
-      zod: ^3.25.0 || ^4.0.0
-
-  zod@4.3.6:
-    resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
-
-snapshots:
-
-  '@alloc/quick-lru@5.2.0': {}
-
-  '@ark/schema@0.56.0':
-    dependencies:
-      '@ark/util': 0.56.0
-
-  '@ark/util@0.56.0': {}
-
-  '@babel/code-frame@7.29.0':
-    dependencies:
-      '@babel/helper-validator-identifier': 7.28.5
-      js-tokens: 4.0.0
-      picocolors: 1.1.1
-
-  '@babel/compat-data@7.29.0': {}
-
-  '@babel/core@7.29.0':
-    dependencies:
-      '@babel/code-frame': 7.29.0
-      '@babel/generator': 7.29.1
-      '@babel/helper-compilation-targets': 7.28.6
-      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.29.0)
-      '@babel/helpers': 7.28.6
-      '@babel/parser': 7.29.0
-      '@babel/template': 7.28.6
-      '@babel/traverse': 7.29.0
-      '@babel/types': 7.29.0
-      '@jridgewell/remapping': 2.3.5
-      convert-source-map: 2.0.0
-      debug: 4.4.3
-      gensync: 1.0.0-beta.2
-      json5: 2.2.3
-      semver: 6.3.1
-    transitivePeerDependencies:
-      - supports-color
-
-  '@babel/generator@7.29.1':
-    dependencies:
-      '@babel/parser': 7.29.0
-      '@babel/types': 7.29.0
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-      jsesc: 3.1.0
-
-  '@babel/helper-compilation-targets@7.28.6':
-    dependencies:
-      '@babel/compat-data': 7.29.0
-      '@babel/helper-validator-option': 7.27.1
-      browserslist: 4.28.1
-      lru-cache: 5.1.1
-      semver: 6.3.1
-
-  '@babel/helper-globals@7.28.0': {}
-
-  '@babel/helper-module-imports@7.28.6':
-    dependencies:
-      '@babel/traverse': 7.29.0
-      '@babel/types': 7.29.0
-    transitivePeerDependencies:
-      - supports-color
-
-  '@babel/helper-module-transforms@7.28.6(@babel/core@7.29.0)':
-    dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-module-imports': 7.28.6
-      '@babel/helper-validator-identifier': 7.28.5
-      '@babel/traverse': 7.29.0
-    transitivePeerDependencies:
-      - supports-color
-
-  '@babel/helper-string-parser@7.27.1': {}
-
-  '@babel/helper-string-parser@7.29.7': {}
-
-  '@babel/helper-validator-identifier@7.28.5': {}
-
-  '@babel/helper-validator-identifier@7.29.7': {}
-
-  '@babel/helper-validator-option@7.27.1': {}
-
-  '@babel/helpers@7.28.6':
-    dependencies:
-      '@babel/template': 7.28.6
-      '@babel/types': 7.29.0
-
-  '@babel/parser@7.29.0':
-    dependencies:
-      '@babel/types': 7.29.0
-
-  '@babel/parser@7.29.7':
-    dependencies:
-      '@babel/types': 7.29.7
-
-  '@babel/runtime@7.29.2': {}
-
-  '@babel/template@7.28.6':
-    dependencies:
-      '@babel/code-frame': 7.29.0
-      '@babel/parser': 7.29.0
-      '@babel/types': 7.29.0
-
-  '@babel/traverse@7.29.0':
-    dependencies:
-      '@babel/code-frame': 7.29.0
-      '@babel/generator': 7.29.1
-      '@babel/helper-globals': 7.28.0
-      '@babel/parser': 7.29.0
-      '@babel/template': 7.28.6
-      '@babel/types': 7.29.0
-      debug: 4.4.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@babel/types@7.29.0':
-    dependencies:
-      '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
-
-  '@babel/types@7.29.7':
-    dependencies:
-      '@babel/helper-string-parser': 7.29.7
-      '@babel/helper-validator-identifier': 7.29.7
-
-  '@changesets/apply-release-plan@7.1.1':
-    dependencies:
-      '@changesets/config': 3.1.4
-      '@changesets/get-version-range-type': 0.4.0
-      '@changesets/git': 3.0.4
-      '@changesets/should-skip-package': 0.1.2
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-      detect-indent: 6.1.0
-      fs-extra: 7.0.1
-      lodash.startcase: 4.4.0
-      outdent: 0.5.0
-      prettier: 2.8.8
-      resolve-from: 5.0.0
-      semver: 7.7.4
-
-  '@changesets/assemble-release-plan@6.0.10':
-    dependencies:
-      '@changesets/errors': 0.2.0
-      '@changesets/get-dependents-graph': 2.1.4
-      '@changesets/should-skip-package': 0.1.2
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-      semver: 7.7.4
-
-  '@changesets/changelog-git@0.2.1':
-    dependencies:
-      '@changesets/types': 6.1.0
-
-  '@changesets/changelog-github@0.7.0':
-    dependencies:
-      '@changesets/get-github-info': 0.8.0
-      '@changesets/types': 6.1.0
-      dotenv: 8.6.0
-    transitivePeerDependencies:
-      - encoding
-
-  '@changesets/cli@2.31.0(@types/node@25.6.0)':
-    dependencies:
-      '@changesets/apply-release-plan': 7.1.1
-      '@changesets/assemble-release-plan': 6.0.10
-      '@changesets/changelog-git': 0.2.1
-      '@changesets/config': 3.1.4
-      '@changesets/errors': 0.2.0
-      '@changesets/get-dependents-graph': 2.1.4
-      '@changesets/get-release-plan': 4.0.16
-      '@changesets/git': 3.0.4
-      '@changesets/logger': 0.1.1
-      '@changesets/pre': 2.0.2
-      '@changesets/read': 0.6.7
-      '@changesets/should-skip-package': 0.1.2
-      '@changesets/types': 6.1.0
-      '@changesets/write': 0.4.0
-      '@inquirer/external-editor': 1.0.3(@types/node@25.6.0)
-      '@manypkg/get-packages': 1.1.3
-      ansi-colors: 4.1.3
-      enquirer: 2.4.1
-      fs-extra: 7.0.1
-      mri: 1.2.0
-      package-manager-detector: 0.2.11
-      picocolors: 1.1.1
-      resolve-from: 5.0.0
-      semver: 7.7.4
-      spawndamnit: 3.0.1
-      term-size: 2.2.1
-    transitivePeerDependencies:
-      - '@types/node'
-
-  '@changesets/config@3.1.4':
-    dependencies:
-      '@changesets/errors': 0.2.0
-      '@changesets/get-dependents-graph': 2.1.4
-      '@changesets/logger': 0.1.1
-      '@changesets/should-skip-package': 0.1.2
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-      fs-extra: 7.0.1
-      micromatch: 4.0.8
-
-  '@changesets/errors@0.2.0':
-    dependencies:
-      extendable-error: 0.1.7
-
-  '@changesets/get-dependents-graph@2.1.4':
-    dependencies:
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-      picocolors: 1.1.1
-      semver: 7.7.4
-
-  '@changesets/get-github-info@0.8.0':
-    dependencies:
-      dataloader: 1.4.0
-      node-fetch: 2.7.0
-    transitivePeerDependencies:
-      - encoding
-
-  '@changesets/get-release-plan@4.0.16':
-    dependencies:
-      '@changesets/assemble-release-plan': 6.0.10
-      '@changesets/config': 3.1.4
-      '@changesets/pre': 2.0.2
-      '@changesets/read': 0.6.7
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-
-  '@changesets/get-version-range-type@0.4.0': {}
-
-  '@changesets/git@3.0.4':
-    dependencies:
-      '@changesets/errors': 0.2.0
-      '@manypkg/get-packages': 1.1.3
-      is-subdir: 1.2.0
-      micromatch: 4.0.8
-      spawndamnit: 3.0.1
-
-  '@changesets/logger@0.1.1':
-    dependencies:
-      picocolors: 1.1.1
-
-  '@changesets/parse@0.4.3':
-    dependencies:
-      '@changesets/types': 6.1.0
-      js-yaml: 4.1.1
-
-  '@changesets/pre@2.0.2':
-    dependencies:
-      '@changesets/errors': 0.2.0
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-      fs-extra: 7.0.1
-
-  '@changesets/read@0.6.7':
-    dependencies:
-      '@changesets/git': 3.0.4
-      '@changesets/logger': 0.1.1
-      '@changesets/parse': 0.4.3
-      '@changesets/types': 6.1.0
-      fs-extra: 7.0.1
-      p-filter: 2.1.0
-      picocolors: 1.1.1
-
-  '@changesets/should-skip-package@0.1.2':
-    dependencies:
-      '@changesets/types': 6.1.0
-      '@manypkg/get-packages': 1.1.3
-
-  '@changesets/types@4.1.0': {}
-
-  '@changesets/types@6.1.0': {}
-
-  '@changesets/write@0.4.0':
-    dependencies:
-      '@changesets/types': 6.1.0
-      fs-extra: 7.0.1
-      human-id: 4.1.3
-      prettier: 2.8.8
-
-  '@effect/platform-node-shared@4.0.0-beta.70(effect@4.0.0-beta.70)':
-    dependencies:
-      '@types/ws': 8.18.1
-      effect: 4.0.0-beta.70
-      ws: 8.20.0
-    transitivePeerDependencies:
-      - bufferutil
-      - utf-8-validate
-
-  '@effect/vitest@4.0.0-beta.70(effect@4.0.0-beta.70)(vitest@4.1.7(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0)))':
-    dependencies:
-      effect: 4.0.0-beta.70
-      vitest: 4.1.7(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))
-
-  '@emnapi/core@1.10.0':
-    dependencies:
-      '@emnapi/wasi-threads': 1.2.1
-      tslib: 2.8.1
-    optional: true
-
-  '@emnapi/runtime@1.10.0':
-    dependencies:
-      tslib: 2.8.1
-    optional: true
-
-  '@emnapi/wasi-threads@1.2.1':
-    dependencies:
-      tslib: 2.8.1
-    optional: true
-
-  '@epic-web/invariant@1.0.0': {}
-
-  '@esbuild/aix-ppc64@0.25.12':
-    optional: true
-
-  '@esbuild/aix-ppc64@0.27.3':
-    optional: true
-
-  '@esbuild/aix-ppc64@0.28.1':
-    optional: true
-
-  '@esbuild/android-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/android-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/android-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/android-arm@0.25.12':
-    optional: true
-
-  '@esbuild/android-arm@0.27.3':
-    optional: true
-
-  '@esbuild/android-arm@0.28.1':
-    optional: true
-
-  '@esbuild/android-x64@0.25.12':
-    optional: true
-
-  '@esbuild/android-x64@0.27.3':
-    optional: true
-
-  '@esbuild/android-x64@0.28.1':
-    optional: true
-
-  '@esbuild/darwin-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/darwin-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/darwin-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/darwin-x64@0.25.12':
-    optional: true
-
-  '@esbuild/darwin-x64@0.27.3':
-    optional: true
-
-  '@esbuild/darwin-x64@0.28.1':
-    optional: true
-
-  '@esbuild/freebsd-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/freebsd-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/freebsd-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/freebsd-x64@0.25.12':
-    optional: true
-
-  '@esbuild/freebsd-x64@0.27.3':
-    optional: true
-
-  '@esbuild/freebsd-x64@0.28.1':
-    optional: true
-
-  '@esbuild/linux-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/linux-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/linux-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/linux-arm@0.25.12':
-    optional: true
-
-  '@esbuild/linux-arm@0.27.3':
-    optional: true
-
-  '@esbuild/linux-arm@0.28.1':
-    optional: true
-
-  '@esbuild/linux-ia32@0.25.12':
-    optional: true
-
-  '@esbuild/linux-ia32@0.27.3':
-    optional: true
-
-  '@esbuild/linux-ia32@0.28.1':
-    optional: true
-
-  '@esbuild/linux-loong64@0.25.12':
-    optional: true
-
-  '@esbuild/linux-loong64@0.27.3':
-    optional: true
-
-  '@esbuild/linux-loong64@0.28.1':
-    optional: true
-
-  '@esbuild/linux-mips64el@0.25.12':
-    optional: true
-
-  '@esbuild/linux-mips64el@0.27.3':
-    optional: true
-
-  '@esbuild/linux-mips64el@0.28.1':
-    optional: true
-
-  '@esbuild/linux-ppc64@0.25.12':
-    optional: true
-
-  '@esbuild/linux-ppc64@0.27.3':
-    optional: true
-
-  '@esbuild/linux-ppc64@0.28.1':
-    optional: true
-
-  '@esbuild/linux-riscv64@0.25.12':
-    optional: true
-
-  '@esbuild/linux-riscv64@0.27.3':
-    optional: true
-
-  '@esbuild/linux-riscv64@0.28.1':
-    optional: true
-
-  '@esbuild/linux-s390x@0.25.12':
-    optional: true
-
-  '@esbuild/linux-s390x@0.27.3':
-    optional: true
-
-  '@esbuild/linux-s390x@0.28.1':
-    optional: true
-
-  '@esbuild/linux-x64@0.25.12':
-    optional: true
-
-  '@esbuild/linux-x64@0.27.3':
-    optional: true
-
-  '@esbuild/linux-x64@0.28.1':
-    optional: true
-
-  '@esbuild/netbsd-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/netbsd-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/netbsd-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/netbsd-x64@0.25.12':
-    optional: true
-
-  '@esbuild/netbsd-x64@0.27.3':
-    optional: true
-
-  '@esbuild/netbsd-x64@0.28.1':
-    optional: true
-
-  '@esbuild/openbsd-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/openbsd-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/openbsd-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/openbsd-x64@0.25.12':
-    optional: true
-
-  '@esbuild/openbsd-x64@0.27.3':
-    optional: true
-
-  '@esbuild/openbsd-x64@0.28.1':
-    optional: true
-
-  '@esbuild/openharmony-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/openharmony-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/openharmony-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/sunos-x64@0.25.12':
-    optional: true
-
-  '@esbuild/sunos-x64@0.27.3':
-    optional: true
-
-  '@esbuild/sunos-x64@0.28.1':
-    optional: true
-
-  '@esbuild/win32-arm64@0.25.12':
-    optional: true
-
-  '@esbuild/win32-arm64@0.27.3':
-    optional: true
-
-  '@esbuild/win32-arm64@0.28.1':
-    optional: true
-
-  '@esbuild/win32-ia32@0.25.12':
-    optional: true
-
-  '@esbuild/win32-ia32@0.27.3':
-    optional: true
-
-  '@esbuild/win32-ia32@0.28.1':
-    optional: true
-
-  '@esbuild/win32-x64@0.25.12':
-    optional: true
-
-  '@esbuild/win32-x64@0.27.3':
-    optional: true
-
-  '@esbuild/win32-x64@0.28.1':
-    optional: true
-
-  '@eslint-community/eslint-utils@4.9.1(eslint@9.39.2(jiti@2.7.0))':
-    dependencies:
-      eslint: 9.39.2(jiti@2.7.0)
-      eslint-visitor-keys: 3.4.3
-
-  '@eslint-community/regexpp@4.12.2': {}
-
-  '@eslint/config-array@0.21.2':
-    dependencies:
-      '@eslint/object-schema': 2.1.7
-      debug: 4.4.3
-      minimatch: 3.1.5
-    transitivePeerDependencies:
-      - supports-color
-
-  '@eslint/config-helpers@0.4.2':
-    dependencies:
-      '@eslint/core': 0.17.0
-
-  '@eslint/core@0.17.0':
-    dependencies:
-      '@types/json-schema': 7.0.15
-
-  '@eslint/eslintrc@3.3.5':
-    dependencies:
-      ajv: 6.14.0
-      debug: 4.4.3
-      espree: 10.4.0
-      globals: 14.0.0
-      ignore: 5.3.2
-      import-fresh: 3.3.1
-      js-yaml: 4.1.1
-      minimatch: 3.1.5
-      strip-json-comments: 3.1.1
-    transitivePeerDependencies:
-      - supports-color
-
-  '@eslint/js@9.39.2': {}
-
-  '@eslint/object-schema@2.1.7': {}
-
-  '@eslint/plugin-kit@0.4.1':
-    dependencies:
-      '@eslint/core': 0.17.0
-      levn: 0.4.1
-
-  '@humanfs/core@0.19.1': {}
-
-  '@humanfs/node@0.16.7':
-    dependencies:
-      '@humanfs/core': 0.19.1
-      '@humanwhocodes/retry': 0.4.3
-
-  '@humanwhocodes/module-importer@1.0.1': {}
-
-  '@humanwhocodes/retry@0.4.3': {}
-
-  '@iarna/toml@2.2.5': {}
-
-  '@img/colour@1.0.0':
-    optional: true
-
-  '@img/sharp-darwin-arm64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-darwin-arm64': 1.2.4
-    optional: true
-
-  '@img/sharp-darwin-x64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-darwin-x64': 1.2.4
-    optional: true
-
-  '@img/sharp-libvips-darwin-arm64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-darwin-x64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linux-arm64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linux-arm@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linux-ppc64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linux-riscv64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linux-s390x@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linux-x64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
-    optional: true
-
-  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
-    optional: true
-
-  '@img/sharp-linux-arm64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linux-arm64': 1.2.4
-    optional: true
-
-  '@img/sharp-linux-arm@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linux-arm': 1.2.4
-    optional: true
-
-  '@img/sharp-linux-ppc64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linux-ppc64': 1.2.4
-    optional: true
-
-  '@img/sharp-linux-riscv64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linux-riscv64': 1.2.4
-    optional: true
-
-  '@img/sharp-linux-s390x@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linux-s390x': 1.2.4
-    optional: true
-
-  '@img/sharp-linux-x64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linux-x64': 1.2.4
-    optional: true
-
-  '@img/sharp-linuxmusl-arm64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
-    optional: true
-
-  '@img/sharp-linuxmusl-x64@0.34.5':
-    optionalDependencies:
-      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
-    optional: true
-
-  '@img/sharp-wasm32@0.34.5':
-    dependencies:
-      '@emnapi/runtime': 1.10.0
-    optional: true
-
-  '@img/sharp-win32-arm64@0.34.5':
-    optional: true
-
-  '@img/sharp-win32-ia32@0.34.5':
-    optional: true
-
-  '@img/sharp-win32-x64@0.34.5':
-    optional: true
-
-  '@inquirer/external-editor@1.0.3(@types/node@25.6.0)':
-    dependencies:
-      chardet: 2.1.1
-      iconv-lite: 0.7.2
-    optionalDependencies:
-      '@types/node': 25.6.0
-
-  '@jridgewell/gen-mapping@0.3.13':
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
-      '@jridgewell/trace-mapping': 0.3.31
-
-  '@jridgewell/remapping@2.3.5':
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-
-  '@jridgewell/resolve-uri@3.1.2': {}
-
-  '@jridgewell/source-map@0.3.11':
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-    optional: true
-
-  '@jridgewell/sourcemap-codec@1.5.5': {}
-
-  '@jridgewell/trace-mapping@0.3.31':
-    dependencies:
-      '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.5
-
-  '@manypkg/find-root@1.1.0':
-    dependencies:
-      '@babel/runtime': 7.29.2
-      '@types/node': 12.20.55
-      find-up: 4.1.0
-      fs-extra: 8.1.0
-
-  '@manypkg/get-packages@1.1.3':
-    dependencies:
-      '@babel/runtime': 7.29.2
-      '@changesets/types': 4.1.0
-      '@manypkg/find-root': 1.1.0
-      fs-extra: 8.1.0
-      globby: 11.1.0
-      read-yaml-file: 1.1.0
-
-  '@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.3':
-    optional: true
-
-  '@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.3':
-    optional: true
-
-  '@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.3':
-    optional: true
-
-  '@msgpackr-extract/msgpackr-extract-linux-arm@3.0.3':
-    optional: true
-
-  '@msgpackr-extract/msgpackr-extract-linux-x64@3.0.3':
-    optional: true
-
-  '@msgpackr-extract/msgpackr-extract-win32-x64@3.0.3':
-    optional: true
-
-  '@napi-rs/wasm-runtime@1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)':
-    dependencies:
-      '@emnapi/core': 1.10.0
-      '@emnapi/runtime': 1.10.0
-      '@tybys/wasm-util': 0.10.2
-    optional: true
-
-  '@next/env@16.2.4': {}
-
-  '@next/swc-darwin-arm64@16.2.4':
-    optional: true
-
-  '@next/swc-darwin-x64@16.2.4':
-    optional: true
-
-  '@next/swc-linux-arm64-gnu@16.2.4':
-    optional: true
-
-  '@next/swc-linux-arm64-musl@16.2.4':
-    optional: true
-
-  '@next/swc-linux-x64-gnu@16.2.4':
-    optional: true
-
-  '@next/swc-linux-x64-musl@16.2.4':
-    optional: true
-
-  '@next/swc-win32-arm64-msvc@16.2.4':
-    optional: true
-
-  '@next/swc-win32-x64-msvc@16.2.4':
-    optional: true
-
-  '@nodelib/fs.scandir@2.1.5':
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      run-parallel: 1.2.0
-
-  '@nodelib/fs.stat@2.0.5': {}
-
-  '@nodelib/fs.walk@1.2.8':
-    dependencies:
-      '@nodelib/fs.scandir': 2.1.5
-      fastq: 1.20.1
-
-  '@opentelemetry/api-logs@0.214.0':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-
-  '@opentelemetry/api@1.9.1': {}
-
-  '@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1)':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/semantic-conventions': 1.41.1
-
-  '@opentelemetry/instrumentation@0.214.0(@opentelemetry/api@1.9.1)':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/api-logs': 0.214.0
-      import-in-the-middle: 3.0.1
-      require-in-the-middle: 8.0.1
-    transitivePeerDependencies:
-      - supports-color
-
-  '@opentelemetry/resources@2.7.1(@opentelemetry/api@1.9.1)':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/semantic-conventions': 1.41.1
-
-  '@opentelemetry/sdk-trace-base@2.7.1(@opentelemetry/api@1.9.1)':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/resources': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/semantic-conventions': 1.41.1
-
-  '@opentelemetry/semantic-conventions@1.41.1': {}
-
-  '@oxc-parser/binding-android-arm-eabi@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-android-arm-eabi@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-android-arm64@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-android-arm64@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-darwin-arm64@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-darwin-arm64@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-darwin-x64@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-darwin-x64@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-freebsd-x64@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-freebsd-x64@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm-gnueabihf@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm-gnueabihf@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm-musleabihf@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm-musleabihf@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm64-gnu@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm64-gnu@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm64-musl@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-arm64-musl@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-ppc64-gnu@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-ppc64-gnu@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-riscv64-gnu@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-riscv64-gnu@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-riscv64-musl@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-riscv64-musl@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-s390x-gnu@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-s390x-gnu@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-x64-gnu@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-x64-gnu@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-x64-musl@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-linux-x64-musl@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-openharmony-arm64@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-openharmony-arm64@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-wasm32-wasi@0.132.0':
-    dependencies:
-      '@emnapi/core': 1.10.0
-      '@emnapi/runtime': 1.10.0
-      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
-    optional: true
-
-  '@oxc-parser/binding-wasm32-wasi@0.135.0':
-    dependencies:
-      '@emnapi/core': 1.10.0
-      '@emnapi/runtime': 1.10.0
-      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
-    optional: true
-
-  '@oxc-parser/binding-win32-arm64-msvc@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-win32-arm64-msvc@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-win32-ia32-msvc@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-win32-ia32-msvc@0.135.0':
-    optional: true
-
-  '@oxc-parser/binding-win32-x64-msvc@0.132.0':
-    optional: true
-
-  '@oxc-parser/binding-win32-x64-msvc@0.135.0':
-    optional: true
-
-  '@oxc-project/runtime@0.127.0': {}
-
-  '@oxc-project/types@0.127.0': {}
-
-  '@oxc-project/types@0.132.0': {}
-
-  '@oxc-project/types@0.135.0': {}
-
-  '@oxc-resolver/binding-android-arm-eabi@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-android-arm64@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-darwin-arm64@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-darwin-x64@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-freebsd-x64@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-arm-gnueabihf@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-arm-musleabihf@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-arm64-gnu@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-arm64-musl@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-ppc64-gnu@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-riscv64-gnu@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-riscv64-musl@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-s390x-gnu@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-x64-gnu@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-linux-x64-musl@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-openharmony-arm64@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-wasm32-wasi@11.19.1(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)':
-    dependencies:
-      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
-    transitivePeerDependencies:
-      - '@emnapi/core'
-      - '@emnapi/runtime'
-    optional: true
-
-  '@oxc-resolver/binding-win32-arm64-msvc@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-win32-ia32-msvc@11.19.1':
-    optional: true
-
-  '@oxc-resolver/binding-win32-x64-msvc@11.19.1':
-    optional: true
-
-  '@oxfmt/binding-android-arm-eabi@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-android-arm64@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-darwin-arm64@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-darwin-x64@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-freebsd-x64@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-arm-gnueabihf@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-arm-musleabihf@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-arm64-gnu@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-arm64-musl@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-ppc64-gnu@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-riscv64-gnu@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-riscv64-musl@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-s390x-gnu@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-x64-gnu@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-linux-x64-musl@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-openharmony-arm64@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-win32-arm64-msvc@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-win32-ia32-msvc@0.46.0':
-    optional: true
-
-  '@oxfmt/binding-win32-x64-msvc@0.46.0':
-    optional: true
-
-  '@oxlint-tsgolint/darwin-arm64@0.23.0':
-    optional: true
-
-  '@oxlint-tsgolint/darwin-x64@0.23.0':
-    optional: true
-
-  '@oxlint-tsgolint/linux-arm64@0.23.0':
-    optional: true
-
-  '@oxlint-tsgolint/linux-x64@0.23.0':
-    optional: true
-
-  '@oxlint-tsgolint/win32-arm64@0.23.0':
-    optional: true
-
-  '@oxlint-tsgolint/win32-x64@0.23.0':
-    optional: true
-
-  '@oxlint/binding-android-arm-eabi@1.66.0':
-    optional: true
-
-  '@oxlint/binding-android-arm64@1.66.0':
-    optional: true
-
-  '@oxlint/binding-darwin-arm64@1.66.0':
-    optional: true
-
-  '@oxlint/binding-darwin-x64@1.66.0':
-    optional: true
-
-  '@oxlint/binding-freebsd-x64@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-arm-gnueabihf@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-arm-musleabihf@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-arm64-gnu@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-arm64-musl@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-ppc64-gnu@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-riscv64-gnu@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-riscv64-musl@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-s390x-gnu@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-x64-gnu@1.66.0':
-    optional: true
-
-  '@oxlint/binding-linux-x64-musl@1.66.0':
-    optional: true
-
-  '@oxlint/binding-openharmony-arm64@1.66.0':
-    optional: true
-
-  '@oxlint/binding-win32-arm64-msvc@1.66.0':
-    optional: true
-
-  '@oxlint/binding-win32-ia32-msvc@1.66.0':
-    optional: true
-
-  '@oxlint/binding-win32-x64-msvc@1.66.0':
-    optional: true
-
-  '@polka/url@1.0.0-next.29': {}
-
-  '@rayhanadev/truffler@0.4.2':
-    dependencies:
-      '@speed-highlight/core': 1.2.15
-      arktype: 2.2.0
-      oxc-parser: 0.132.0
-      sade: 1.8.1
-
-  '@rollup/rollup-android-arm-eabi@4.57.1':
-    optional: true
-
-  '@rollup/rollup-android-arm64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-darwin-arm64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-darwin-x64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-freebsd-arm64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-freebsd-x64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-arm-gnueabihf@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-arm-musleabihf@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-arm64-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-arm64-musl@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-loong64-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-loong64-musl@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-ppc64-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-ppc64-musl@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-riscv64-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-riscv64-musl@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-s390x-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-x64-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-linux-x64-musl@4.57.1':
-    optional: true
-
-  '@rollup/rollup-openbsd-x64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-openharmony-arm64@4.57.1':
-    optional: true
-
-  '@rollup/rollup-win32-arm64-msvc@4.57.1':
-    optional: true
-
-  '@rollup/rollup-win32-ia32-msvc@4.57.1':
-    optional: true
-
-  '@rollup/rollup-win32-x64-gnu@4.57.1':
-    optional: true
-
-  '@rollup/rollup-win32-x64-msvc@4.57.1':
-    optional: true
-
-  '@sentry/cli-darwin@3.4.3':
-    optional: true
-
-  '@sentry/cli-linux-arm64@3.4.3':
-    optional: true
-
-  '@sentry/cli-linux-arm@3.4.3':
-    optional: true
-
-  '@sentry/cli-linux-i686@3.4.3':
-    optional: true
-
-  '@sentry/cli-linux-x64@3.4.3':
-    optional: true
-
-  '@sentry/cli-win32-arm64@3.4.3':
-    optional: true
-
-  '@sentry/cli-win32-i686@3.4.3':
-    optional: true
-
-  '@sentry/cli-win32-x64@3.4.3':
-    optional: true
-
-  '@sentry/cli@3.4.3':
-    dependencies:
-      progress: 2.0.3
-      proxy-from-env: 1.1.0
-      undici: 6.26.0
-      which: 2.0.2
-    optionalDependencies:
-      '@sentry/cli-darwin': 3.4.3
-      '@sentry/cli-linux-arm': 3.4.3
-      '@sentry/cli-linux-arm64': 3.4.3
-      '@sentry/cli-linux-i686': 3.4.3
-      '@sentry/cli-linux-x64': 3.4.3
-      '@sentry/cli-win32-arm64': 3.4.3
-      '@sentry/cli-win32-i686': 3.4.3
-      '@sentry/cli-win32-x64': 3.4.3
-
-  '@sentry/core@10.54.0': {}
-
-  '@sentry/node-core@10.54.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/instrumentation@0.214.0(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/semantic-conventions@1.41.1)':
-    dependencies:
-      '@sentry/core': 10.54.0
-      '@sentry/opentelemetry': 10.54.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/semantic-conventions@1.41.1)
-      import-in-the-middle: 3.0.1
-    optionalDependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/instrumentation': 0.214.0(@opentelemetry/api@1.9.1)
-      '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/semantic-conventions': 1.41.1
-
-  '@sentry/node@10.54.0':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/instrumentation': 0.214.0(@opentelemetry/api@1.9.1)
-      '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/semantic-conventions': 1.41.1
-      '@sentry/core': 10.54.0
-      '@sentry/node-core': 10.54.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/instrumentation@0.214.0(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/semantic-conventions@1.41.1)
-      '@sentry/opentelemetry': 10.54.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/semantic-conventions@1.41.1)
-      import-in-the-middle: 3.0.1
-    transitivePeerDependencies:
-      - '@opentelemetry/exporter-trace-otlp-http'
-      - supports-color
-
-  '@sentry/opentelemetry@10.54.0(@opentelemetry/api@1.9.1)(@opentelemetry/core@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/sdk-trace-base@2.7.1(@opentelemetry/api@1.9.1))(@opentelemetry/semantic-conventions@1.41.1)':
-    dependencies:
-      '@opentelemetry/api': 1.9.1
-      '@opentelemetry/core': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/sdk-trace-base': 2.7.1(@opentelemetry/api@1.9.1)
-      '@opentelemetry/semantic-conventions': 1.41.1
-      '@sentry/core': 10.54.0
-
-  '@speed-highlight/core@1.2.15': {}
-
-  '@standard-schema/spec@1.1.0': {}
-
-  '@swc/helpers@0.5.15':
-    dependencies:
-      tslib: 2.8.1
-
-  '@tailwindcss/node@4.1.18':
-    dependencies:
-      '@jridgewell/remapping': 2.3.5
-      enhanced-resolve: 5.19.0
-      jiti: 2.7.0
-      lightningcss: 1.30.2
-      magic-string: 0.30.21
-      source-map-js: 1.2.1
-      tailwindcss: 4.1.18
-
-  '@tailwindcss/oxide-android-arm64@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-darwin-arm64@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-darwin-x64@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-freebsd-x64@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-linux-arm64-gnu@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-linux-x64-musl@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-wasm32-wasi@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-win32-arm64-msvc@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide-win32-x64-msvc@4.1.18':
-    optional: true
-
-  '@tailwindcss/oxide@4.1.18':
-    optionalDependencies:
-      '@tailwindcss/oxide-android-arm64': 4.1.18
-      '@tailwindcss/oxide-darwin-arm64': 4.1.18
-      '@tailwindcss/oxide-darwin-x64': 4.1.18
-      '@tailwindcss/oxide-freebsd-x64': 4.1.18
-      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.1.18
-      '@tailwindcss/oxide-linux-arm64-gnu': 4.1.18
-      '@tailwindcss/oxide-linux-arm64-musl': 4.1.18
-      '@tailwindcss/oxide-linux-x64-gnu': 4.1.18
-      '@tailwindcss/oxide-linux-x64-musl': 4.1.18
-      '@tailwindcss/oxide-wasm32-wasi': 4.1.18
-      '@tailwindcss/oxide-win32-arm64-msvc': 4.1.18
-      '@tailwindcss/oxide-win32-x64-msvc': 4.1.18
-
-  '@tailwindcss/postcss@4.1.18':
-    dependencies:
-      '@alloc/quick-lru': 5.2.0
-      '@tailwindcss/node': 4.1.18
-      '@tailwindcss/oxide': 4.1.18
-      postcss: 8.5.6
-      tailwindcss: 4.1.18
-
-  '@turbo/darwin-64@2.9.7':
-    optional: true
-
-  '@turbo/darwin-arm64@2.9.7':
-    optional: true
-
-  '@turbo/linux-64@2.9.7':
-    optional: true
-
-  '@turbo/linux-arm64@2.9.7':
-    optional: true
-
-  '@turbo/windows-64@2.9.7':
-    optional: true
-
-  '@turbo/windows-arm64@2.9.7':
-    optional: true
-
-  '@tybys/wasm-util@0.10.2':
-    dependencies:
-      tslib: 2.8.1
-    optional: true
-
-  '@types/babel__code-frame@7.27.0': {}
-
-  '@types/chai@5.2.3':
-    dependencies:
-      '@types/deep-eql': 4.0.2
-      assertion-error: 2.0.1
-
-  '@types/deep-eql@4.0.2': {}
-
-  '@types/esrecurse@4.3.1': {}
-
-  '@types/estree@1.0.8': {}
-
-  '@types/json-schema@7.0.15': {}
-
-  '@types/minimatch@5.1.2': {}
-
-  '@types/node@12.20.55': {}
-
-  '@types/node@25.6.0':
-    dependencies:
-      undici-types: 7.19.2
-
-  '@types/picomatch@4.0.3': {}
-
-  '@types/prompts@2.4.9':
-    dependencies:
-      '@types/node': 25.6.0
-      kleur: 3.0.3
-
-  '@types/react-dom@19.2.3(@types/react@19.2.14)':
-    dependencies:
-      '@types/react': 19.2.14
-
-  '@types/react@19.2.14':
-    dependencies:
-      csstype: 3.2.3
-
-  '@types/semver@7.7.1': {}
-
-  '@types/vscode@1.120.0': {}
-
-  '@types/ws@8.18.1':
-    dependencies:
-      '@types/node': 25.6.0
-
-  '@typescript-eslint/types@8.59.3': {}
-
-  '@vercel/analytics@2.0.1(next@16.2.4(@opentelemetry/api@1.9.1)(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react@19.2.5)':
-    optionalDependencies:
-      next: 16.2.4(@opentelemetry/api@1.9.1)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
-      react: 19.2.5
-
-  '@vitest/expect@4.1.7':
-    dependencies:
-      '@standard-schema/spec': 1.1.0
-      '@types/chai': 5.2.3
-      '@vitest/spy': 4.1.7
-      '@vitest/utils': 4.1.7
-      chai: 6.2.2
-      tinyrainbow: 3.1.0
-
-  '@vitest/mocker@4.1.7(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))':
-    dependencies:
-      '@vitest/spy': 4.1.7
-      estree-walker: 3.0.3
-      magic-string: 0.30.21
-    optionalDependencies:
-      vite: 7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0)
-
-  '@vitest/pretty-format@4.1.7':
-    dependencies:
-      tinyrainbow: 3.1.0
-
-  '@vitest/runner@4.1.7':
-    dependencies:
-      '@vitest/utils': 4.1.7
-      pathe: 2.0.3
-
-  '@vitest/snapshot@4.1.7':
-    dependencies:
-      '@vitest/pretty-format': 4.1.7
-      '@vitest/utils': 4.1.7
-      magic-string: 0.30.21
-      pathe: 2.0.3
-
-  '@vitest/spy@4.1.7': {}
-
-  '@vitest/utils@4.1.7':
-    dependencies:
-      '@vitest/pretty-format': 4.1.7
-      convert-source-map: 2.0.0
-      tinyrainbow: 3.1.0
-
-  '@voidzero-dev/vite-plus-core@0.1.20(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)':
-    dependencies:
-      '@oxc-project/runtime': 0.127.0
-      '@oxc-project/types': 0.127.0
-      lightningcss: 1.30.2
-      postcss: 8.5.6
-    optionalDependencies:
-      '@types/node': 25.6.0
-      esbuild: 0.28.1
-      fsevents: 2.3.3
-      jiti: 2.7.0
-      terser: 5.46.0
-      tsx: 4.22.4
-      typescript: 6.0.3
-      yaml: 2.9.0
-
-  '@voidzero-dev/vite-plus-darwin-arm64@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-darwin-x64@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-linux-arm64-gnu@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-linux-arm64-musl@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-linux-x64-gnu@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-linux-x64-musl@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-test@0.1.20(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))(yaml@2.9.0)':
-    dependencies:
-      '@standard-schema/spec': 1.1.0
-      '@types/chai': 5.2.3
-      '@voidzero-dev/vite-plus-core': 0.1.20(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)
-      es-module-lexer: 1.7.0
-      obug: 2.1.1
-      pixelmatch: 7.2.0
-      pngjs: 7.0.0
-      sirv: 3.0.2
-      std-env: 4.0.0
-      tinybench: 2.9.0
-      tinyexec: 1.1.1
-      tinyglobby: 0.2.15
-      vite: 7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0)
-      ws: 8.20.0
-    optionalDependencies:
-      '@opentelemetry/api': 1.9.1
-      '@types/node': 25.6.0
-    transitivePeerDependencies:
-      - '@arethetypeswrong/core'
-      - '@tsdown/css'
-      - '@tsdown/exe'
-      - '@vitejs/devtools'
-      - bufferutil
-      - esbuild
-      - jiti
-      - less
-      - publint
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - terser
-      - tsx
-      - typescript
-      - unplugin-unused
-      - utf-8-validate
-      - yaml
-
-  '@voidzero-dev/vite-plus-win32-arm64-msvc@0.1.20':
-    optional: true
-
-  '@voidzero-dev/vite-plus-win32-x64-msvc@0.1.20':
-    optional: true
-
-  '@xterm/headless@6.0.0': {}
-
-  acorn-import-attributes@1.9.5(acorn@8.16.0):
-    dependencies:
-      acorn: 8.16.0
-
-  acorn-jsx@5.3.2(acorn@8.16.0):
-    dependencies:
-      acorn: 8.16.0
-
-  acorn@8.16.0: {}
-
-  agent-install@0.0.5:
-    dependencies:
-      '@iarna/toml': 2.2.5
-      commander: 14.0.3
-      jsonc-parser: 3.3.1
-      picocolors: 1.1.1
-      prompts: 2.4.2
-      yaml: 2.9.0
-
-  ajv-formats@3.0.1(ajv@8.20.0):
-    optionalDependencies:
-      ajv: 8.20.0
-
-  ajv@6.14.0:
-    dependencies:
-      fast-deep-equal: 3.1.3
-      fast-json-stable-stringify: 2.1.0
-      json-schema-traverse: 0.4.1
-      uri-js: 4.4.1
-
-  ajv@8.20.0:
-    dependencies:
-      fast-deep-equal: 3.1.3
-      fast-uri: 3.1.2
-      json-schema-traverse: 1.0.0
-      require-from-string: 2.0.2
-
-  ansi-colors@4.1.3: {}
-
-  ansi-regex@5.0.1: {}
-
-  ansi-regex@6.2.2: {}
-
-  ansi-styles@4.3.0:
-    dependencies:
-      color-convert: 2.0.1
-
-  argparse@1.0.10:
-    dependencies:
-      sprintf-js: 1.0.3
-
-  argparse@2.0.1: {}
-
-  arkregex@0.0.5:
-    dependencies:
-      '@ark/util': 0.56.0
-
-  arktype@2.2.0:
-    dependencies:
-      '@ark/schema': 0.56.0
-      '@ark/util': 0.56.0
-      arkregex: 0.0.5
-
-  array-union@2.1.0: {}
-
-  assertion-error@2.0.1: {}
-
-  atomically@2.1.1:
-    dependencies:
-      stubborn-fs: 2.0.0
-      when-exit: 2.1.5
-
-  balanced-match@1.0.2: {}
-
-  balanced-match@4.0.4: {}
-
-  baseline-browser-mapping@2.9.19: {}
-
-  better-path-resolve@1.0.0:
-    dependencies:
-      is-windows: 1.0.2
-
-  brace-expansion@1.1.13:
-    dependencies:
-      balanced-match: 1.0.2
-      concat-map: 0.0.1
-
-  brace-expansion@2.1.1:
-    dependencies:
-      balanced-match: 1.0.2
-
-  brace-expansion@5.0.6:
-    dependencies:
-      balanced-match: 4.0.4
-
-  braces@3.0.3:
-    dependencies:
-      fill-range: 7.1.1
-
-  browserslist@4.28.1:
-    dependencies:
-      baseline-browser-mapping: 2.9.19
-      caniuse-lite: 1.0.30001769
-      electron-to-chromium: 1.5.286
-      node-releases: 2.0.27
-      update-browserslist-db: 1.2.3(browserslist@4.28.1)
-
-  buffer-from@1.1.2:
-    optional: true
-
-  callsites@3.1.0: {}
-
-  caniuse-lite@1.0.30001769: {}
-
-  chai@6.2.2: {}
-
-  chalk@4.1.2:
-    dependencies:
-      ansi-styles: 4.3.0
-      supports-color: 7.2.0
-
-  chalk@5.6.2: {}
-
-  chardet@2.1.1: {}
-
-  cjs-module-lexer@2.2.0: {}
-
-  cli-cursor@5.0.0:
-    dependencies:
-      restore-cursor: 5.1.0
-
-  cli-spinners@3.4.0: {}
-
-  client-only@0.0.1: {}
-
-  color-convert@2.0.1:
-    dependencies:
-      color-name: 1.1.4
-
-  color-name@1.1.4: {}
-
-  commander@14.0.3: {}
-
-  commander@2.20.3:
-    optional: true
-
-  concat-map@0.0.1: {}
-
-  conf@15.1.0:
-    dependencies:
-      ajv: 8.20.0
-      ajv-formats: 3.0.1(ajv@8.20.0)
-      atomically: 2.1.1
-      debounce-fn: 6.0.0
-      dot-prop: 10.1.0
-      env-paths: 3.0.0
-      json-schema-typed: 8.0.2
-      semver: 7.7.4
-      uint8array-extras: 1.5.0
-
-  confbox@0.2.4: {}
-
-  convert-source-map@2.0.0: {}
-
-  cross-env@10.1.0:
-    dependencies:
-      '@epic-web/invariant': 1.0.0
-      cross-spawn: 7.0.6
-
-  cross-spawn@7.0.6:
-    dependencies:
-      path-key: 3.1.1
-      shebang-command: 2.0.0
-      which: 2.0.2
-
-  csstype@3.2.3: {}
-
-  dataloader@1.4.0: {}
-
-  debounce-fn@6.0.0:
-    dependencies:
-      mimic-function: 5.0.1
-
-  debug@4.4.3:
-    dependencies:
-      ms: 2.1.3
-
-  deep-is@0.1.4: {}
-
-  detect-indent@6.1.0: {}
-
-  detect-libc@2.1.2: {}
-
-  dir-glob@3.0.1:
-    dependencies:
-      path-type: 4.0.0
-
-  dot-prop@10.1.0:
-    dependencies:
-      type-fest: 5.6.0
-
-  dotenv@8.6.0: {}
-
-  effect@4.0.0-beta.70:
-    dependencies:
-      '@standard-schema/spec': 1.1.0
-      fast-check: 4.8.0
-      find-my-way-ts: 0.1.6
-      ini: 7.0.0
-      kubernetes-types: 1.30.0
-      msgpackr: 2.0.1
-      multipasta: 0.2.7
-      toml: 4.1.1
-      uuid: 14.0.0
-      yaml: 2.9.0
-
-  electron-to-chromium@1.5.286: {}
-
-  enhanced-resolve@5.19.0:
-    dependencies:
-      graceful-fs: 4.2.11
-      tapable: 2.3.0
-
-  enquirer@2.4.1:
-    dependencies:
-      ansi-colors: 4.1.3
-      strip-ansi: 6.0.1
-
-  env-paths@3.0.0: {}
-
-  es-module-lexer@1.7.0: {}
-
-  es-module-lexer@2.1.0: {}
-
-  esbuild@0.25.12:
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.25.12
-      '@esbuild/android-arm': 0.25.12
-      '@esbuild/android-arm64': 0.25.12
-      '@esbuild/android-x64': 0.25.12
-      '@esbuild/darwin-arm64': 0.25.12
-      '@esbuild/darwin-x64': 0.25.12
-      '@esbuild/freebsd-arm64': 0.25.12
-      '@esbuild/freebsd-x64': 0.25.12
-      '@esbuild/linux-arm': 0.25.12
-      '@esbuild/linux-arm64': 0.25.12
-      '@esbuild/linux-ia32': 0.25.12
-      '@esbuild/linux-loong64': 0.25.12
-      '@esbuild/linux-mips64el': 0.25.12
-      '@esbuild/linux-ppc64': 0.25.12
-      '@esbuild/linux-riscv64': 0.25.12
-      '@esbuild/linux-s390x': 0.25.12
-      '@esbuild/linux-x64': 0.25.12
-      '@esbuild/netbsd-arm64': 0.25.12
-      '@esbuild/netbsd-x64': 0.25.12
-      '@esbuild/openbsd-arm64': 0.25.12
-      '@esbuild/openbsd-x64': 0.25.12
-      '@esbuild/openharmony-arm64': 0.25.12
-      '@esbuild/sunos-x64': 0.25.12
-      '@esbuild/win32-arm64': 0.25.12
-      '@esbuild/win32-ia32': 0.25.12
-      '@esbuild/win32-x64': 0.25.12
-
-  esbuild@0.27.3:
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.27.3
-      '@esbuild/android-arm': 0.27.3
-      '@esbuild/android-arm64': 0.27.3
-      '@esbuild/android-x64': 0.27.3
-      '@esbuild/darwin-arm64': 0.27.3
-      '@esbuild/darwin-x64': 0.27.3
-      '@esbuild/freebsd-arm64': 0.27.3
-      '@esbuild/freebsd-x64': 0.27.3
-      '@esbuild/linux-arm': 0.27.3
-      '@esbuild/linux-arm64': 0.27.3
-      '@esbuild/linux-ia32': 0.27.3
-      '@esbuild/linux-loong64': 0.27.3
-      '@esbuild/linux-mips64el': 0.27.3
-      '@esbuild/linux-ppc64': 0.27.3
-      '@esbuild/linux-riscv64': 0.27.3
-      '@esbuild/linux-s390x': 0.27.3
-      '@esbuild/linux-x64': 0.27.3
-      '@esbuild/netbsd-arm64': 0.27.3
-      '@esbuild/netbsd-x64': 0.27.3
-      '@esbuild/openbsd-arm64': 0.27.3
-      '@esbuild/openbsd-x64': 0.27.3
-      '@esbuild/openharmony-arm64': 0.27.3
-      '@esbuild/sunos-x64': 0.27.3
-      '@esbuild/win32-arm64': 0.27.3
-      '@esbuild/win32-ia32': 0.27.3
-      '@esbuild/win32-x64': 0.27.3
-
-  esbuild@0.28.1:
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.28.1
-      '@esbuild/android-arm': 0.28.1
-      '@esbuild/android-arm64': 0.28.1
-      '@esbuild/android-x64': 0.28.1
-      '@esbuild/darwin-arm64': 0.28.1
-      '@esbuild/darwin-x64': 0.28.1
-      '@esbuild/freebsd-arm64': 0.28.1
-      '@esbuild/freebsd-x64': 0.28.1
-      '@esbuild/linux-arm': 0.28.1
-      '@esbuild/linux-arm64': 0.28.1
-      '@esbuild/linux-ia32': 0.28.1
-      '@esbuild/linux-loong64': 0.28.1
-      '@esbuild/linux-mips64el': 0.28.1
-      '@esbuild/linux-ppc64': 0.28.1
-      '@esbuild/linux-riscv64': 0.28.1
-      '@esbuild/linux-s390x': 0.28.1
-      '@esbuild/linux-x64': 0.28.1
-      '@esbuild/netbsd-arm64': 0.28.1
-      '@esbuild/netbsd-x64': 0.28.1
-      '@esbuild/openbsd-arm64': 0.28.1
-      '@esbuild/openbsd-x64': 0.28.1
-      '@esbuild/openharmony-arm64': 0.28.1
-      '@esbuild/sunos-x64': 0.28.1
-      '@esbuild/win32-arm64': 0.28.1
-      '@esbuild/win32-ia32': 0.28.1
-      '@esbuild/win32-x64': 0.28.1
-
-  escalade@3.2.0: {}
-
-  escape-string-regexp@4.0.0: {}
-
-  eslint-plugin-react-hooks@7.1.1(eslint@9.39.2(jiti@2.7.0)):
-    dependencies:
-      '@babel/core': 7.29.0
-      '@babel/parser': 7.29.0
-      eslint: 9.39.2(jiti@2.7.0)
-      hermes-parser: 0.25.1
-      zod: 4.3.6
-      zod-validation-error: 4.0.2(zod@4.3.6)
-    transitivePeerDependencies:
-      - supports-color
-
-  eslint-scope@8.4.0:
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 5.3.0
-
-  eslint-scope@9.1.2:
-    dependencies:
-      '@types/esrecurse': 4.3.1
-      '@types/estree': 1.0.8
-      esrecurse: 4.3.0
-      estraverse: 5.3.0
-
-  eslint-visitor-keys@3.4.3: {}
-
-  eslint-visitor-keys@4.2.1: {}
-
-  eslint-visitor-keys@5.0.1: {}
-
-  eslint@9.39.2(jiti@2.7.0):
-    dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.2(jiti@2.7.0))
-      '@eslint-community/regexpp': 4.12.2
-      '@eslint/config-array': 0.21.2
-      '@eslint/config-helpers': 0.4.2
-      '@eslint/core': 0.17.0
-      '@eslint/eslintrc': 3.3.5
-      '@eslint/js': 9.39.2
-      '@eslint/plugin-kit': 0.4.1
-      '@humanfs/node': 0.16.7
-      '@humanwhocodes/module-importer': 1.0.1
-      '@humanwhocodes/retry': 0.4.3
-      '@types/estree': 1.0.8
-      ajv: 6.14.0
-      chalk: 4.1.2
-      cross-spawn: 7.0.6
-      debug: 4.4.3
-      escape-string-regexp: 4.0.0
-      eslint-scope: 8.4.0
-      eslint-visitor-keys: 4.2.1
-      espree: 10.4.0
-      esquery: 1.7.0
-      esutils: 2.0.3
-      fast-deep-equal: 3.1.3
-      file-entry-cache: 8.0.0
-      find-up: 5.0.0
-      glob-parent: 6.0.2
-      ignore: 5.3.2
-      imurmurhash: 0.1.4
-      is-glob: 4.0.3
-      json-stable-stringify-without-jsonify: 1.0.1
-      lodash.merge: 4.6.2
-      minimatch: 3.1.5
-      natural-compare: 1.4.0
-      optionator: 0.9.4
-    optionalDependencies:
-      jiti: 2.7.0
-    transitivePeerDependencies:
-      - supports-color
-
-  espree@10.4.0:
-    dependencies:
-      acorn: 8.16.0
-      acorn-jsx: 5.3.2(acorn@8.16.0)
-      eslint-visitor-keys: 4.2.1
-
-  esprima@4.0.1: {}
-
-  esquery@1.7.0:
-    dependencies:
-      estraverse: 5.3.0
-
-  esrecurse@4.3.0:
-    dependencies:
-      estraverse: 5.3.0
-
-  estraverse@5.3.0: {}
-
-  estree-walker@3.0.3:
-    dependencies:
-      '@types/estree': 1.0.8
-
-  esutils@2.0.3: {}
-
-  expect-type@1.3.0: {}
-
-  extendable-error@0.1.7: {}
-
-  fast-check@4.8.0:
-    dependencies:
-      pure-rand: 8.4.0
-
-  fast-deep-equal@3.1.3: {}
-
-  fast-glob@3.3.3:
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      '@nodelib/fs.walk': 1.2.8
-      glob-parent: 5.1.2
-      merge2: 1.4.1
-      micromatch: 4.0.8
-
-  fast-json-stable-stringify@2.1.0: {}
-
-  fast-levenshtein@2.0.6: {}
-
-  fast-uri@3.1.2: {}
-
-  fastq@1.20.1:
-    dependencies:
-      reusify: 1.1.0
-
-  fdir@6.5.0(picomatch@4.0.4):
-    optionalDependencies:
-      picomatch: 4.0.4
-
-  file-entry-cache@8.0.0:
-    dependencies:
-      flat-cache: 4.0.1
-
-  fill-range@7.1.1:
-    dependencies:
-      to-regex-range: 5.0.1
-
-  find-my-way-ts@0.1.6: {}
-
-  find-up@4.1.0:
-    dependencies:
-      locate-path: 5.0.0
-      path-exists: 4.0.0
-
-  find-up@5.0.0:
-    dependencies:
-      locate-path: 6.0.0
-      path-exists: 4.0.0
-
-  flat-cache@4.0.1:
-    dependencies:
-      flatted: 3.4.2
-      keyv: 4.5.4
-
-  flatted@3.4.2: {}
-
-  fs-extra@7.0.1:
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 4.0.0
-      universalify: 0.1.2
-
-  fs-extra@8.1.0:
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 4.0.0
-      universalify: 0.1.2
-
-  fsevents@2.3.3:
-    optional: true
-
-  gensync@1.0.0-beta.2: {}
-
-  get-east-asian-width@1.4.0: {}
-
-  glob-parent@5.1.2:
-    dependencies:
-      is-glob: 4.0.3
-
-  glob-parent@6.0.2:
-    dependencies:
-      is-glob: 4.0.3
-
-  glob@13.0.6:
-    dependencies:
-      minimatch: 10.2.5
-      minipass: 7.1.3
-      path-scurry: 2.0.2
-
-  globals@14.0.0: {}
-
-  globby@11.1.0:
-    dependencies:
-      array-union: 2.1.0
-      dir-glob: 3.0.1
-      fast-glob: 3.3.3
-      ignore: 5.3.2
-      merge2: 1.4.1
-      slash: 3.0.0
-
-  graceful-fs@4.2.11: {}
-
-  has-flag@4.0.0: {}
-
-  hermes-estree@0.25.1: {}
-
-  hermes-parser@0.25.1:
-    dependencies:
-      hermes-estree: 0.25.1
-
-  human-id@4.1.3: {}
-
-  iconv-lite@0.7.2:
-    dependencies:
-      safer-buffer: 2.1.2
-
-  ignore@5.3.2: {}
-
-  import-fresh@3.3.1:
-    dependencies:
-      parent-module: 1.0.1
-      resolve-from: 4.0.0
-
-  import-in-the-middle@3.0.1:
-    dependencies:
-      acorn: 8.16.0
-      acorn-import-attributes: 1.9.5(acorn@8.16.0)
-      cjs-module-lexer: 2.2.0
-      module-details-from-path: 1.0.4
-
-  imurmurhash@0.1.4: {}
-
-  ini@7.0.0: {}
-
-  is-extglob@2.1.1: {}
-
-  is-glob@4.0.3:
-    dependencies:
-      is-extglob: 2.1.1
-
-  is-interactive@2.0.0: {}
-
-  is-number@7.0.0: {}
-
-  is-subdir@1.2.0:
-    dependencies:
-      better-path-resolve: 1.0.0
-
-  is-unicode-supported@2.1.0: {}
-
-  is-windows@1.0.2: {}
-
-  isexe@2.0.0: {}
-
-  jiti@2.7.0: {}
-
-  js-tokens@4.0.0: {}
-
-  js-yaml@3.14.2:
-    dependencies:
-      argparse: 1.0.10
-      esprima: 4.0.1
-
-  js-yaml@4.1.1:
-    dependencies:
-      argparse: 2.0.1
-
-  jsesc@3.1.0: {}
-
-  json-buffer@3.0.1: {}
-
-  json-schema-traverse@0.4.1: {}
-
-  json-schema-traverse@1.0.0: {}
-
-  json-schema-typed@8.0.2: {}
-
-  json-stable-stringify-without-jsonify@1.0.1: {}
-
-  json5@2.2.3: {}
-
-  jsonc-parser@3.3.1: {}
-
-  jsonfile@4.0.0:
-    optionalDependencies:
-      graceful-fs: 4.2.11
-
-  keyv@4.5.4:
-    dependencies:
-      json-buffer: 3.0.1
-
-  kleur@3.0.3: {}
-
-  kubernetes-types@1.30.0: {}
-
-  levn@0.4.1:
-    dependencies:
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
-
-  lightningcss-android-arm64@1.30.2:
-    optional: true
-
-  lightningcss-darwin-arm64@1.30.2:
-    optional: true
-
-  lightningcss-darwin-x64@1.30.2:
-    optional: true
-
-  lightningcss-freebsd-x64@1.30.2:
-    optional: true
-
-  lightningcss-linux-arm-gnueabihf@1.30.2:
-    optional: true
-
-  lightningcss-linux-arm64-gnu@1.30.2:
-    optional: true
-
-  lightningcss-linux-arm64-musl@1.30.2:
-    optional: true
-
-  lightningcss-linux-x64-gnu@1.30.2:
-    optional: true
-
-  lightningcss-linux-x64-musl@1.30.2:
-    optional: true
-
-  lightningcss-win32-arm64-msvc@1.30.2:
-    optional: true
-
-  lightningcss-win32-x64-msvc@1.30.2:
-    optional: true
-
-  lightningcss@1.30.2:
-    dependencies:
-      detect-libc: 2.1.2
-    optionalDependencies:
-      lightningcss-android-arm64: 1.30.2
-      lightningcss-darwin-arm64: 1.30.2
-      lightningcss-darwin-x64: 1.30.2
-      lightningcss-freebsd-x64: 1.30.2
-      lightningcss-linux-arm-gnueabihf: 1.30.2
-      lightningcss-linux-arm64-gnu: 1.30.2
-      lightningcss-linux-arm64-musl: 1.30.2
-      lightningcss-linux-x64-gnu: 1.30.2
-      lightningcss-linux-x64-musl: 1.30.2
-      lightningcss-win32-arm64-msvc: 1.30.2
-      lightningcss-win32-x64-msvc: 1.30.2
-
-  locate-path@5.0.0:
-    dependencies:
-      p-locate: 4.1.0
-
-  locate-path@6.0.0:
-    dependencies:
-      p-locate: 5.0.0
-
-  lodash.merge@4.6.2: {}
-
-  lodash.startcase@4.4.0: {}
-
-  log-symbols@7.0.1:
-    dependencies:
-      is-unicode-supported: 2.1.0
-      yoctocolors: 2.1.2
-
-  lru-cache@11.5.0: {}
-
-  lru-cache@5.1.1:
-    dependencies:
-      yallist: 3.1.1
-
-  lucide-react@1.14.0(react@19.2.5):
-    dependencies:
-      react: 19.2.5
-
-  magic-string@0.30.21:
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
-
-  magicast@0.5.3:
-    dependencies:
-      '@babel/parser': 7.29.7
-      '@babel/types': 7.29.0
-      source-map-js: 1.2.1
-
-  merge2@1.4.1: {}
-
-  micromatch@4.0.8:
-    dependencies:
-      braces: 3.0.3
-      picomatch: 2.3.1
-
-  mimic-function@5.0.1: {}
-
-  minimatch@10.2.5:
-    dependencies:
-      brace-expansion: 5.0.6
-
-  minimatch@3.1.5:
-    dependencies:
-      brace-expansion: 1.1.13
-
-  minimatch@5.1.9:
-    dependencies:
-      brace-expansion: 2.1.1
-
-  minipass@7.1.3: {}
-
-  module-details-from-path@1.0.4: {}
-
-  mri@1.2.0: {}
-
-  mrmime@2.0.1: {}
-
-  ms@2.1.3: {}
-
-  msgpackr-extract@3.0.3:
-    dependencies:
-      node-gyp-build-optional-packages: 5.2.2
-    optionalDependencies:
-      '@msgpackr-extract/msgpackr-extract-darwin-arm64': 3.0.3
-      '@msgpackr-extract/msgpackr-extract-darwin-x64': 3.0.3
-      '@msgpackr-extract/msgpackr-extract-linux-arm': 3.0.3
-      '@msgpackr-extract/msgpackr-extract-linux-arm64': 3.0.3
-      '@msgpackr-extract/msgpackr-extract-linux-x64': 3.0.3
-      '@msgpackr-extract/msgpackr-extract-win32-x64': 3.0.3
-    optional: true
-
-  msgpackr@2.0.1:
-    optionalDependencies:
-      msgpackr-extract: 3.0.3
-
-  multipasta@0.2.7: {}
-
-  nanoid@3.3.11: {}
-
-  natural-compare@1.4.0: {}
-
-  next@16.2.4(@opentelemetry/api@1.9.1)(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
-    dependencies:
-      '@next/env': 16.2.4
-      '@swc/helpers': 0.5.15
-      baseline-browser-mapping: 2.9.19
-      caniuse-lite: 1.0.30001769
-      postcss: 8.4.31
-      react: 19.2.5
-      react-dom: 19.2.5(react@19.2.5)
-      styled-jsx: 5.1.6(react@19.2.5)
-    optionalDependencies:
-      '@next/swc-darwin-arm64': 16.2.4
-      '@next/swc-darwin-x64': 16.2.4
-      '@next/swc-linux-arm64-gnu': 16.2.4
-      '@next/swc-linux-arm64-musl': 16.2.4
-      '@next/swc-linux-x64-gnu': 16.2.4
-      '@next/swc-linux-x64-musl': 16.2.4
-      '@next/swc-win32-arm64-msvc': 16.2.4
-      '@next/swc-win32-x64-msvc': 16.2.4
-      '@opentelemetry/api': 1.9.1
-      sharp: 0.34.5
-    transitivePeerDependencies:
-      - '@babel/core'
-      - babel-plugin-macros
-
-  node-fetch@2.7.0:
-    dependencies:
-      whatwg-url: 5.0.0
-
-  node-gyp-build-optional-packages@5.2.2:
-    dependencies:
-      detect-libc: 2.1.2
-    optional: true
-
-  node-releases@2.0.27: {}
-
-  normalize-path@3.0.0: {}
-
-  obug@2.1.1: {}
-
-  onetime@7.0.0:
-    dependencies:
-      mimic-function: 5.0.1
-
-  optionator@0.9.4:
-    dependencies:
-      deep-is: 0.1.4
-      fast-levenshtein: 2.0.6
-      levn: 0.4.1
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
-      word-wrap: 1.2.5
-
-  ora@9.4.0:
-    dependencies:
-      chalk: 5.6.2
-      cli-cursor: 5.0.0
-      cli-spinners: 3.4.0
-      is-interactive: 2.0.0
-      is-unicode-supported: 2.1.0
-      log-symbols: 7.0.1
-      stdin-discarder: 0.3.2
-      string-width: 8.1.1
-
-  outdent@0.5.0: {}
-
-  oxc-parser@0.132.0:
-    dependencies:
-      '@oxc-project/types': 0.132.0
-    optionalDependencies:
-      '@oxc-parser/binding-android-arm-eabi': 0.132.0
-      '@oxc-parser/binding-android-arm64': 0.132.0
-      '@oxc-parser/binding-darwin-arm64': 0.132.0
-      '@oxc-parser/binding-darwin-x64': 0.132.0
-      '@oxc-parser/binding-freebsd-x64': 0.132.0
-      '@oxc-parser/binding-linux-arm-gnueabihf': 0.132.0
-      '@oxc-parser/binding-linux-arm-musleabihf': 0.132.0
-      '@oxc-parser/binding-linux-arm64-gnu': 0.132.0
-      '@oxc-parser/binding-linux-arm64-musl': 0.132.0
-      '@oxc-parser/binding-linux-ppc64-gnu': 0.132.0
-      '@oxc-parser/binding-linux-riscv64-gnu': 0.132.0
-      '@oxc-parser/binding-linux-riscv64-musl': 0.132.0
-      '@oxc-parser/binding-linux-s390x-gnu': 0.132.0
-      '@oxc-parser/binding-linux-x64-gnu': 0.132.0
-      '@oxc-parser/binding-linux-x64-musl': 0.132.0
-      '@oxc-parser/binding-openharmony-arm64': 0.132.0
-      '@oxc-parser/binding-wasm32-wasi': 0.132.0
-      '@oxc-parser/binding-win32-arm64-msvc': 0.132.0
-      '@oxc-parser/binding-win32-ia32-msvc': 0.132.0
-      '@oxc-parser/binding-win32-x64-msvc': 0.132.0
-
-  oxc-parser@0.135.0:
-    dependencies:
-      '@oxc-project/types': 0.135.0
-    optionalDependencies:
-      '@oxc-parser/binding-android-arm-eabi': 0.135.0
-      '@oxc-parser/binding-android-arm64': 0.135.0
-      '@oxc-parser/binding-darwin-arm64': 0.135.0
-      '@oxc-parser/binding-darwin-x64': 0.135.0
-      '@oxc-parser/binding-freebsd-x64': 0.135.0
-      '@oxc-parser/binding-linux-arm-gnueabihf': 0.135.0
-      '@oxc-parser/binding-linux-arm-musleabihf': 0.135.0
-      '@oxc-parser/binding-linux-arm64-gnu': 0.135.0
-      '@oxc-parser/binding-linux-arm64-musl': 0.135.0
-      '@oxc-parser/binding-linux-ppc64-gnu': 0.135.0
-      '@oxc-parser/binding-linux-riscv64-gnu': 0.135.0
-      '@oxc-parser/binding-linux-riscv64-musl': 0.135.0
-      '@oxc-parser/binding-linux-s390x-gnu': 0.135.0
-      '@oxc-parser/binding-linux-x64-gnu': 0.135.0
-      '@oxc-parser/binding-linux-x64-musl': 0.135.0
-      '@oxc-parser/binding-openharmony-arm64': 0.135.0
-      '@oxc-parser/binding-wasm32-wasi': 0.135.0
-      '@oxc-parser/binding-win32-arm64-msvc': 0.135.0
-      '@oxc-parser/binding-win32-ia32-msvc': 0.135.0
-      '@oxc-parser/binding-win32-x64-msvc': 0.135.0
-
-  oxc-resolver@11.19.1(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0):
-    optionalDependencies:
-      '@oxc-resolver/binding-android-arm-eabi': 11.19.1
-      '@oxc-resolver/binding-android-arm64': 11.19.1
-      '@oxc-resolver/binding-darwin-arm64': 11.19.1
-      '@oxc-resolver/binding-darwin-x64': 11.19.1
-      '@oxc-resolver/binding-freebsd-x64': 11.19.1
-      '@oxc-resolver/binding-linux-arm-gnueabihf': 11.19.1
-      '@oxc-resolver/binding-linux-arm-musleabihf': 11.19.1
-      '@oxc-resolver/binding-linux-arm64-gnu': 11.19.1
-      '@oxc-resolver/binding-linux-arm64-musl': 11.19.1
-      '@oxc-resolver/binding-linux-ppc64-gnu': 11.19.1
-      '@oxc-resolver/binding-linux-riscv64-gnu': 11.19.1
-      '@oxc-resolver/binding-linux-riscv64-musl': 11.19.1
-      '@oxc-resolver/binding-linux-s390x-gnu': 11.19.1
-      '@oxc-resolver/binding-linux-x64-gnu': 11.19.1
-      '@oxc-resolver/binding-linux-x64-musl': 11.19.1
-      '@oxc-resolver/binding-openharmony-arm64': 11.19.1
-      '@oxc-resolver/binding-wasm32-wasi': 11.19.1(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
-      '@oxc-resolver/binding-win32-arm64-msvc': 11.19.1
-      '@oxc-resolver/binding-win32-ia32-msvc': 11.19.1
-      '@oxc-resolver/binding-win32-x64-msvc': 11.19.1
-    transitivePeerDependencies:
-      - '@emnapi/core'
-      - '@emnapi/runtime'
-
-  oxfmt@0.46.0:
-    dependencies:
-      tinypool: 2.1.0
-    optionalDependencies:
-      '@oxfmt/binding-android-arm-eabi': 0.46.0
-      '@oxfmt/binding-android-arm64': 0.46.0
-      '@oxfmt/binding-darwin-arm64': 0.46.0
-      '@oxfmt/binding-darwin-x64': 0.46.0
-      '@oxfmt/binding-freebsd-x64': 0.46.0
-      '@oxfmt/binding-linux-arm-gnueabihf': 0.46.0
-      '@oxfmt/binding-linux-arm-musleabihf': 0.46.0
-      '@oxfmt/binding-linux-arm64-gnu': 0.46.0
-      '@oxfmt/binding-linux-arm64-musl': 0.46.0
-      '@oxfmt/binding-linux-ppc64-gnu': 0.46.0
-      '@oxfmt/binding-linux-riscv64-gnu': 0.46.0
-      '@oxfmt/binding-linux-riscv64-musl': 0.46.0
-      '@oxfmt/binding-linux-s390x-gnu': 0.46.0
-      '@oxfmt/binding-linux-x64-gnu': 0.46.0
-      '@oxfmt/binding-linux-x64-musl': 0.46.0
-      '@oxfmt/binding-openharmony-arm64': 0.46.0
-      '@oxfmt/binding-win32-arm64-msvc': 0.46.0
-      '@oxfmt/binding-win32-ia32-msvc': 0.46.0
-      '@oxfmt/binding-win32-x64-msvc': 0.46.0
-
-  oxlint-tsgolint@0.23.0:
-    optionalDependencies:
-      '@oxlint-tsgolint/darwin-arm64': 0.23.0
-      '@oxlint-tsgolint/darwin-x64': 0.23.0
-      '@oxlint-tsgolint/linux-arm64': 0.23.0
-      '@oxlint-tsgolint/linux-x64': 0.23.0
-      '@oxlint-tsgolint/win32-arm64': 0.23.0
-      '@oxlint-tsgolint/win32-x64': 0.23.0
-
-  oxlint@1.66.0(oxlint-tsgolint@0.23.0):
-    optionalDependencies:
-      '@oxlint/binding-android-arm-eabi': 1.66.0
-      '@oxlint/binding-android-arm64': 1.66.0
-      '@oxlint/binding-darwin-arm64': 1.66.0
-      '@oxlint/binding-darwin-x64': 1.66.0
-      '@oxlint/binding-freebsd-x64': 1.66.0
-      '@oxlint/binding-linux-arm-gnueabihf': 1.66.0
-      '@oxlint/binding-linux-arm-musleabihf': 1.66.0
-      '@oxlint/binding-linux-arm64-gnu': 1.66.0
-      '@oxlint/binding-linux-arm64-musl': 1.66.0
-      '@oxlint/binding-linux-ppc64-gnu': 1.66.0
-      '@oxlint/binding-linux-riscv64-gnu': 1.66.0
-      '@oxlint/binding-linux-riscv64-musl': 1.66.0
-      '@oxlint/binding-linux-s390x-gnu': 1.66.0
-      '@oxlint/binding-linux-x64-gnu': 1.66.0
-      '@oxlint/binding-linux-x64-musl': 1.66.0
-      '@oxlint/binding-openharmony-arm64': 1.66.0
-      '@oxlint/binding-win32-arm64-msvc': 1.66.0
-      '@oxlint/binding-win32-ia32-msvc': 1.66.0
-      '@oxlint/binding-win32-x64-msvc': 1.66.0
-      oxlint-tsgolint: 0.23.0
-
-  p-filter@2.1.0:
-    dependencies:
-      p-map: 2.1.0
-
-  p-limit@2.3.0:
-    dependencies:
-      p-try: 2.2.0
-
-  p-limit@3.1.0:
-    dependencies:
-      yocto-queue: 0.1.0
-
-  p-locate@4.1.0:
-    dependencies:
-      p-limit: 2.3.0
-
-  p-locate@5.0.0:
-    dependencies:
-      p-limit: 3.1.0
-
-  p-map@2.1.0: {}
-
-  p-try@2.2.0: {}
-
-  package-manager-detector@0.2.11:
-    dependencies:
-      quansync: 0.2.11
-
-  parent-module@1.0.1:
-    dependencies:
-      callsites: 3.1.0
-
-  path-exists@4.0.0: {}
-
-  path-key@3.1.1: {}
-
-  path-scurry@2.0.2:
-    dependencies:
-      lru-cache: 11.5.0
-      minipass: 7.1.3
-
-  path-type@4.0.0: {}
-
-  pathe@2.0.3: {}
-
-  picocolors@1.1.1: {}
-
-  picomatch@2.3.1: {}
-
-  picomatch@4.0.4: {}
-
-  pify@4.0.1: {}
-
-  pixelmatch@7.2.0:
-    dependencies:
-      pngjs: 7.0.0
-
-  pngjs@7.0.0: {}
-
-  postcss@8.4.31:
-    dependencies:
-      nanoid: 3.3.11
-      picocolors: 1.1.1
-      source-map-js: 1.2.1
-
-  postcss@8.5.6:
-    dependencies:
-      nanoid: 3.3.11
-      picocolors: 1.1.1
-      source-map-js: 1.2.1
-
-  prelude-ls@1.2.1: {}
-
-  prettier@2.8.8: {}
-
-  progress@2.0.3: {}
-
-  prompts@2.4.2:
-    dependencies:
-      kleur: 3.0.3
-      sisteransi: 1.0.5
-
-  proxy-from-env@1.1.0: {}
-
-  punycode@2.3.1: {}
-
-  pure-rand@8.4.0: {}
-
-  quansync@0.2.11: {}
-
-  queue-microtask@1.2.3: {}
-
-  react-dom@19.2.5(react@19.2.5):
-    dependencies:
-      react: 19.2.5
-      scheduler: 0.27.0
-
-  react@19.2.5: {}
-
-  read-yaml-file@1.1.0:
-    dependencies:
-      graceful-fs: 4.2.11
-      js-yaml: 3.14.2
-      pify: 4.0.1
-      strip-bom: 3.0.0
-
-  require-from-string@2.0.2: {}
-
-  require-in-the-middle@8.0.1:
-    dependencies:
-      debug: 4.4.3
-      module-details-from-path: 1.0.4
-    transitivePeerDependencies:
-      - supports-color
-
-  resolve-from@4.0.0: {}
-
-  resolve-from@5.0.0: {}
-
-  restore-cursor@5.1.0:
-    dependencies:
-      onetime: 7.0.0
-      signal-exit: 4.1.0
-
-  reusify@1.1.0: {}
-
-  rollup@4.57.1:
-    dependencies:
-      '@types/estree': 1.0.8
-    optionalDependencies:
-      '@rollup/rollup-android-arm-eabi': 4.57.1
-      '@rollup/rollup-android-arm64': 4.57.1
-      '@rollup/rollup-darwin-arm64': 4.57.1
-      '@rollup/rollup-darwin-x64': 4.57.1
-      '@rollup/rollup-freebsd-arm64': 4.57.1
-      '@rollup/rollup-freebsd-x64': 4.57.1
-      '@rollup/rollup-linux-arm-gnueabihf': 4.57.1
-      '@rollup/rollup-linux-arm-musleabihf': 4.57.1
-      '@rollup/rollup-linux-arm64-gnu': 4.57.1
-      '@rollup/rollup-linux-arm64-musl': 4.57.1
-      '@rollup/rollup-linux-loong64-gnu': 4.57.1
-      '@rollup/rollup-linux-loong64-musl': 4.57.1
-      '@rollup/rollup-linux-ppc64-gnu': 4.57.1
-      '@rollup/rollup-linux-ppc64-musl': 4.57.1
-      '@rollup/rollup-linux-riscv64-gnu': 4.57.1
-      '@rollup/rollup-linux-riscv64-musl': 4.57.1
-      '@rollup/rollup-linux-s390x-gnu': 4.57.1
-      '@rollup/rollup-linux-x64-gnu': 4.57.1
-      '@rollup/rollup-linux-x64-musl': 4.57.1
-      '@rollup/rollup-openbsd-x64': 4.57.1
-      '@rollup/rollup-openharmony-arm64': 4.57.1
-      '@rollup/rollup-win32-arm64-msvc': 4.57.1
-      '@rollup/rollup-win32-ia32-msvc': 4.57.1
-      '@rollup/rollup-win32-x64-gnu': 4.57.1
-      '@rollup/rollup-win32-x64-msvc': 4.57.1
-      fsevents: 2.3.3
-
-  run-parallel@1.2.0:
-    dependencies:
-      queue-microtask: 1.2.3
-
-  sade@1.8.1:
-    dependencies:
-      mri: 1.2.0
-
-  safe-stable-stringify@2.5.0: {}
-
-  safer-buffer@2.1.2: {}
-
-  scheduler@0.27.0: {}
-
-  semver@6.3.1: {}
-
-  semver@7.7.4: {}
-
-  sharp@0.34.5:
-    dependencies:
-      '@img/colour': 1.0.0
-      detect-libc: 2.1.2
-      semver: 7.7.4
-    optionalDependencies:
-      '@img/sharp-darwin-arm64': 0.34.5
-      '@img/sharp-darwin-x64': 0.34.5
-      '@img/sharp-libvips-darwin-arm64': 1.2.4
-      '@img/sharp-libvips-darwin-x64': 1.2.4
-      '@img/sharp-libvips-linux-arm': 1.2.4
-      '@img/sharp-libvips-linux-arm64': 1.2.4
-      '@img/sharp-libvips-linux-ppc64': 1.2.4
-      '@img/sharp-libvips-linux-riscv64': 1.2.4
-      '@img/sharp-libvips-linux-s390x': 1.2.4
-      '@img/sharp-libvips-linux-x64': 1.2.4
-      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
-      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
-      '@img/sharp-linux-arm': 0.34.5
-      '@img/sharp-linux-arm64': 0.34.5
-      '@img/sharp-linux-ppc64': 0.34.5
-      '@img/sharp-linux-riscv64': 0.34.5
-      '@img/sharp-linux-s390x': 0.34.5
-      '@img/sharp-linux-x64': 0.34.5
-      '@img/sharp-linuxmusl-arm64': 0.34.5
-      '@img/sharp-linuxmusl-x64': 0.34.5
-      '@img/sharp-wasm32': 0.34.5
-      '@img/sharp-win32-arm64': 0.34.5
-      '@img/sharp-win32-ia32': 0.34.5
-      '@img/sharp-win32-x64': 0.34.5
-    optional: true
-
-  shebang-command@2.0.0:
-    dependencies:
-      shebang-regex: 3.0.0
-
-  shebang-regex@3.0.0: {}
-
-  siginfo@2.0.0: {}
-
-  signal-exit@4.1.0: {}
-
-  sirv@3.0.2:
-    dependencies:
-      '@polka/url': 1.0.0-next.29
-      mrmime: 2.0.1
-      totalist: 3.0.1
-
-  sisteransi@1.0.5: {}
-
-  slash@3.0.0: {}
-
-  source-map-js@1.2.1: {}
-
-  source-map-support@0.5.21:
-    dependencies:
-      buffer-from: 1.1.2
-      source-map: 0.6.1
-    optional: true
-
-  source-map@0.6.1:
-    optional: true
-
-  spawndamnit@3.0.1:
-    dependencies:
-      cross-spawn: 7.0.6
-      signal-exit: 4.1.0
-
-  sprintf-js@1.0.3: {}
-
-  stackback@0.0.2: {}
-
-  std-env@4.0.0: {}
-
-  stdin-discarder@0.3.2: {}
-
-  string-width@8.1.1:
-    dependencies:
-      get-east-asian-width: 1.4.0
-      strip-ansi: 7.1.2
-
-  strip-ansi@6.0.1:
-    dependencies:
-      ansi-regex: 5.0.1
-
-  strip-ansi@7.1.2:
-    dependencies:
-      ansi-regex: 6.2.2
-
-  strip-bom@3.0.0: {}
-
-  strip-json-comments@3.1.1: {}
-
-  stubborn-fs@2.0.0:
-    dependencies:
-      stubborn-utils: 1.0.2
-
-  stubborn-utils@1.0.2: {}
-
-  styled-jsx@5.1.6(react@19.2.5):
-    dependencies:
-      client-only: 0.0.1
-      react: 19.2.5
-
-  supports-color@7.2.0:
-    dependencies:
-      has-flag: 4.0.0
-
-  tagged-tag@1.0.0: {}
-
-  tailwindcss@4.1.18: {}
-
-  tapable@2.3.0: {}
-
-  term-size@2.2.1: {}
-
-  terser@5.46.0:
-    dependencies:
-      '@jridgewell/source-map': 0.3.11
-      acorn: 8.16.0
-      commander: 2.20.3
-      source-map-support: 0.5.21
-    optional: true
-
-  tinybench@2.9.0: {}
-
-  tinyexec@1.1.1: {}
-
-  tinyglobby@0.2.15:
-    dependencies:
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
-
-  tinyglobby@0.2.16:
-    dependencies:
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
-
-  tinypool@2.1.0: {}
-
-  tinyrainbow@3.1.0: {}
-
-  to-regex-range@5.0.1:
-    dependencies:
-      is-number: 7.0.0
-
-  toml@4.1.1: {}
-
-  totalist@3.0.1: {}
-
-  tr46@0.0.3: {}
-
-  ts-json-schema-generator@2.9.0:
-    dependencies:
-      '@types/json-schema': 7.0.15
-      commander: 14.0.3
-      glob: 13.0.6
-      json5: 2.2.3
-      normalize-path: 3.0.0
-      safe-stable-stringify: 2.5.0
-      tslib: 2.8.1
-      typescript: 5.9.3
-
-  tslib@2.8.1: {}
-
-  tsx@4.22.4:
-    dependencies:
-      esbuild: 0.28.1
-    optionalDependencies:
-      fsevents: 2.3.3
-
-  turbo@2.9.7:
-    optionalDependencies:
-      '@turbo/darwin-64': 2.9.7
-      '@turbo/darwin-arm64': 2.9.7
-      '@turbo/linux-64': 2.9.7
-      '@turbo/linux-arm64': 2.9.7
-      '@turbo/windows-64': 2.9.7
-      '@turbo/windows-arm64': 2.9.7
-
-  type-check@0.4.0:
-    dependencies:
-      prelude-ls: 1.2.1
-
-  type-fest@5.6.0:
-    dependencies:
-      tagged-tag: 1.0.0
-
-  typescript@5.9.3: {}
-
-  typescript@6.0.3: {}
-
-  uint8array-extras@1.5.0: {}
-
-  undici-types@7.19.2: {}
-
-  undici@6.26.0: {}
-
-  universalify@0.1.2: {}
-
-  update-browserslist-db@1.2.3(browserslist@4.28.1):
-    dependencies:
-      browserslist: 4.28.1
-      escalade: 3.2.0
-      picocolors: 1.1.1
-
-  uri-js@4.4.1:
-    dependencies:
-      punycode: 2.3.1
-
-  uuid@14.0.0: {}
-
-  vite-plus@0.1.20(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))(yaml@2.9.0):
-    dependencies:
-      '@oxc-project/types': 0.127.0
-      '@voidzero-dev/vite-plus-core': 0.1.20(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)
-      '@voidzero-dev/vite-plus-test': 0.1.20(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.46.0)(tsx@4.22.4)(typescript@6.0.3)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))(yaml@2.9.0)
-      oxfmt: 0.46.0
-      oxlint: 1.66.0(oxlint-tsgolint@0.23.0)
-      oxlint-tsgolint: 0.23.0
-    optionalDependencies:
-      '@voidzero-dev/vite-plus-darwin-arm64': 0.1.20
-      '@voidzero-dev/vite-plus-darwin-x64': 0.1.20
-      '@voidzero-dev/vite-plus-linux-arm64-gnu': 0.1.20
-      '@voidzero-dev/vite-plus-linux-arm64-musl': 0.1.20
-      '@voidzero-dev/vite-plus-linux-x64-gnu': 0.1.20
-      '@voidzero-dev/vite-plus-linux-x64-musl': 0.1.20
-      '@voidzero-dev/vite-plus-win32-arm64-msvc': 0.1.20
-      '@voidzero-dev/vite-plus-win32-x64-msvc': 0.1.20
-    transitivePeerDependencies:
-      - '@arethetypeswrong/core'
-      - '@edge-runtime/vm'
-      - '@opentelemetry/api'
-      - '@tsdown/css'
-      - '@tsdown/exe'
-      - '@types/node'
-      - '@vitejs/devtools'
-      - '@vitest/coverage-istanbul'
-      - '@vitest/coverage-v8'
-      - '@vitest/ui'
-      - bufferutil
-      - esbuild
-      - happy-dom
-      - jiti
-      - jsdom
-      - less
-      - publint
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - terser
-      - tsx
-      - typescript
-      - unplugin-unused
-      - utf-8-validate
-      - vite
-      - yaml
-
-  vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0):
-    dependencies:
-      esbuild: 0.27.3
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
-      postcss: 8.5.6
-      rollup: 4.57.1
-      tinyglobby: 0.2.16
-    optionalDependencies:
-      '@types/node': 25.6.0
-      fsevents: 2.3.3
-      jiti: 2.7.0
-      lightningcss: 1.30.2
-      terser: 5.46.0
-      tsx: 4.22.4
-      yaml: 2.9.0
-
-  vitest@4.1.7(@opentelemetry/api@1.9.1)(@types/node@25.6.0)(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0)):
-    dependencies:
-      '@vitest/expect': 4.1.7
-      '@vitest/mocker': 4.1.7(vite@7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0))
-      '@vitest/pretty-format': 4.1.7
-      '@vitest/runner': 4.1.7
-      '@vitest/snapshot': 4.1.7
-      '@vitest/spy': 4.1.7
-      '@vitest/utils': 4.1.7
-      es-module-lexer: 2.1.0
-      expect-type: 1.3.0
-      magic-string: 0.30.21
-      obug: 2.1.1
-      pathe: 2.0.3
-      picomatch: 4.0.4
-      std-env: 4.0.0
-      tinybench: 2.9.0
-      tinyexec: 1.1.1
-      tinyglobby: 0.2.16
-      tinyrainbow: 3.1.0
-      vite: 7.3.1(@types/node@25.6.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.46.0)(tsx@4.22.4)(yaml@2.9.0)
-      why-is-node-running: 2.3.0
-    optionalDependencies:
-      '@opentelemetry/api': 1.9.1
-      '@types/node': 25.6.0
-    transitivePeerDependencies:
-      - msw
-
-  vscode-jsonrpc@8.2.0: {}
-
-  vscode-languageclient@9.0.1:
-    dependencies:
-      minimatch: 5.1.9
-      semver: 7.7.4
-      vscode-languageserver-protocol: 3.17.5
-
-  vscode-languageserver-protocol@3.17.5:
-    dependencies:
-      vscode-jsonrpc: 8.2.0
-      vscode-languageserver-types: 3.17.5
-
-  vscode-languageserver-textdocument@1.0.12: {}
-
-  vscode-languageserver-types@3.17.5: {}
-
-  vscode-languageserver@9.0.1:
-    dependencies:
-      vscode-languageserver-protocol: 3.17.5
-
-  vscode-uri@3.1.0: {}
-
-  webidl-conversions@3.0.1: {}
-
-  whatwg-url@5.0.0:
-    dependencies:
-      tr46: 0.0.3
-      webidl-conversions: 3.0.1
-
-  when-exit@2.1.5: {}
-
-  which@2.0.2:
-    dependencies:
-      isexe: 2.0.0
-
-  why-is-node-running@2.3.0:
-    dependencies:
-      siginfo: 2.0.0
-      stackback: 0.0.2
-
-  word-wrap@1.2.5: {}
-
-  ws@8.20.0: {}
-
-  yallist@3.1.1: {}
-
-  yaml@2.9.0: {}
-
-  yocto-queue@0.1.0: {}
-
-  yoctocolors@2.1.2: {}
-
-  zod-validation-error@4.0.2(zod@4.3.6):
-    dependencies:
-      zod: 4.3.6
-
-  zod@4.3.6: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 959ff85c45..e624435aaa 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -6,5 +6,32 @@ trustPolicy: no-downgrade
 blockExoticSubdeps: true
 
 overrides:
-  vite: npm:@voidzero-dev/vite-plus-core@^0.1.15
-  vitest: npm:@voidzero-dev/vite-plus-test@^0.1.15
+  vite: 'catalog:'
+  vitest: 'catalog:'
+onlyBuiltDependencies:
+  - '@parcel/watcher'
+  - '@sentry/cli'
+  - esbuild
+  - unrs-resolver
+catalog:
+  vite: npm:@voidzero-dev/vite-plus-core@0.0.0-commit.fd1ae7eab160c92f3907a20e80e92d2e87403c20
+  vitest: 4.1.9
+  vite-plus: 0.0.0-commit.fd1ae7eab160c92f3907a20e80e92d2e87403c20
+peerDependencyRules:
+  allowAny:
+    - vite
+    - vitest
+  allowedVersions:
+    vite: '*'
+    vitest: '*'
+minimumReleaseAgeExclude:
+  - vite-plus
+  - '@voidzero-dev/*'
+  - oxlint
+  - '@oxlint/*'
+  - oxlint-tsgolint
+  - '@oxlint-tsgolint/*'
+  - oxfmt
+  - '@oxfmt/*'
+  - vitest
+  - '@vitest/*'