From 06966bc50ddd33b329da3ce38bd2742428603fe4 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 16 Apr 2026 15:30:26 +0000
Subject: [PATCH 1/7] perf: add tinybench suite, CodSpeed CI, and optimize
 ignored + reducePlan

- Split benchmarks by lib/ module under bench/{ignored,reducePlan,LinkResolver,watchpack}/
  so CodSpeed reports them as independent groups. Each suite can be run on its
  own via npm run bench:<name> or all together via npm run bench.
- Add .github/workflows/codspeed.yml using CodSpeedHQ/action to run the full
  suite on push/PR so future regressions surface automatically.
- lib/index.js: skip the path-separator .replace when the input has no
  backslash (35-45% faster on POSIX paths per tinybench) and fast-path
  single-element ignored arrays so we don't join a one-element list.
- lib/reducePlan.js: pre-filter structural non-candidates once, shrink the
  candidate set when a subtree is merged, hoist limit*0.3, and early-exit the
  selection scan when a perfect (cost=0) reduction is found. Measured
  ~20-40% less time on medium/large plans.

https://claude.ai/code/session_012uFpZRKDYdUbCfCEMtGQzN
---
 .changeset/perf-ignored-reduceplan.md      |  11 +
 .github/workflows/codspeed.yml             |  34 +++
 bench/LinkResolver/LinkResolver.bench.mjs  |  77 ++++++
 bench/ignored/ignored.bench.mjs            | 100 ++++++++
 bench/index.mjs                            |  26 ++
 bench/reducePlan/reducePlan.bench.mjs      | 103 ++++++++
 bench/watchpack/normalizeOptions.bench.mjs |  76 ++++++
 eslint.config.mjs                          |   6 +
 lib/index.js                               |  27 +-
 lib/reducePlan.js                          |  91 ++++---
 package-lock.json                          | 274 ++++++++++++++++++++-
 package.json                               |   7 +
 12 files changed, 780 insertions(+), 52 deletions(-)
 create mode 100644 .changeset/perf-ignored-reduceplan.md
 create mode 100644 .github/workflows/codspeed.yml
 create mode 100644 bench/LinkResolver/LinkResolver.bench.mjs
 create mode 100644 bench/ignored/ignored.bench.mjs
 create mode 100644 bench/index.mjs
 create mode 100644 bench/reducePlan/reducePlan.bench.mjs
 create mode 100644 bench/watchpack/normalizeOptions.bench.mjs

diff --git a/.changeset/perf-ignored-reduceplan.md b/.changeset/perf-ignored-reduceplan.md
new file mode 100644
index 0000000..b171c22
--- /dev/null
+++ b/.changeset/perf-ignored-reduceplan.md
@@ -0,0 +1,11 @@
+---
+"watchpack": patch
+---
+
+perf: skip the path-separator replacement when the input has no backslash
+(benchmarks measure ~35–45% less time for `ignored` matchers on POSIX paths),
+fast-path single-element `ignored` arrays, and make `reducePlan`'s selection
+loop walk only structurally valid candidates with an early exit when the
+ideal reduction is found (measured ~20–40% faster on medium and large
+plans). Adds a tinybench suite under `bench/` and a CodSpeed GitHub Actions
+workflow so future regressions are caught automatically.
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
new file mode 100644
index 0000000..4b9a8da
--- /dev/null
+++ b/.github/workflows/codspeed.yml
@@ -0,0 +1,34 @@
+name: CodSpeed
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  # Allow running on demand from the Actions tab.
+  workflow_dispatch:
+
+jobs:
+  benchmarks:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Use Node.js
+        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        with:
+          node-version: lts/*
+          cache: "npm"
+
+      - run: npm ci
+
+      - name: Run benchmarks
+        uses: CodSpeedHQ/action@v4
+        with:
+          run: npm run bench
+          token: ${{ secrets.CODSPEED_TOKEN }}
diff --git a/bench/LinkResolver/LinkResolver.bench.mjs b/bench/LinkResolver/LinkResolver.bench.mjs
new file mode 100644
index 0000000..32c0c5b
--- /dev/null
+++ b/bench/LinkResolver/LinkResolver.bench.mjs
@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+import { Bench } from "tinybench";
+import { withCodSpeed } from "@codspeed/tinybench-plugin";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const LinkResolver = require("../../lib/LinkResolver.js");
+
+// LinkResolver does real sync filesystem work via fs.readlinkSync.
+// To keep benchmarks deterministic and instrumentation-friendly,
+// we measure the path-walking + cache logic against paths that do not exist
+// (readlinkSync throws ENOENT which is handled silently) and the cache fast
+// path which is the most common case in real watch scenarios.
+
+const SEP = process.platform === "win32" ? "\\" : "/";
+const ROOT =
+	process.platform === "win32" ? "C:\\nonexistent_bench" : "/nonexistent_bench";
+
+/**
+ * @param {number} depth path depth
+ * @returns {string} path
+ */
+const makePath = (depth) => {
+	let p = ROOT;
+	for (let i = 0; i < depth; i++) p += `${SEP}level${i}`;
+	return p;
+};
+
+const shallowPaths = Array.from(
+	{ length: 100 },
+	(_, i) => `${ROOT}${SEP}file${i}`,
+);
+const mediumPaths = Array.from(
+	{ length: 100 },
+	(_, i) => `${makePath(5)}${SEP}file${i}`,
+);
+const deepPaths = Array.from(
+	{ length: 50 },
+	(_, i) => `${makePath(15)}${SEP}file${i}`,
+);
+
+const warmResolver = new LinkResolver();
+for (const p of shallowPaths) warmResolver.resolve(p);
+for (const p of mediumPaths) warmResolver.resolve(p);
+for (const p of deepPaths) warmResolver.resolve(p);
+
+const bench = withCodSpeed(new Bench({ name: "LinkResolver", time: 200 }));
+
+bench
+	.add("cold resolve shallow paths (depth=1, n=100)", () => {
+		const resolver = new LinkResolver();
+		for (const p of shallowPaths) resolver.resolve(p);
+	})
+	.add("cold resolve medium paths (depth=5, n=100)", () => {
+		const resolver = new LinkResolver();
+		for (const p of mediumPaths) resolver.resolve(p);
+	})
+	.add("cold resolve deep paths (depth=15, n=50)", () => {
+		const resolver = new LinkResolver();
+		for (const p of deepPaths) resolver.resolve(p);
+	})
+	.add("warm resolve shallow paths (cache hit, n=100)", () => {
+		for (const p of shallowPaths) warmResolver.resolve(p);
+	})
+	.add("warm resolve deep paths (cache hit, n=50)", () => {
+		for (const p of deepPaths) warmResolver.resolve(p);
+	});
+
+export default bench;
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	await bench.run();
+	console.table(bench.table());
+}
diff --git a/bench/ignored/ignored.bench.mjs b/bench/ignored/ignored.bench.mjs
new file mode 100644
index 0000000..b2113f8
--- /dev/null
+++ b/bench/ignored/ignored.bench.mjs
@@ -0,0 +1,100 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+import { Bench } from "tinybench";
+import { withCodSpeed } from "@codspeed/tinybench-plugin";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+// Require the internal helpers via the package entry to avoid duplication.
+// We re-implement the call paths through the public Watchpack constructor
+// which normalizes ignored exactly once per options object.
+const Watchpack = require("../../lib/index.js");
+
+/**
+ * Build a normalized ignored function using Watchpack's public API so that
+ * we benchmark the same code path users exercise in practice.
+ * @param {import("../../lib/index").WatchOptions} options
+ * @returns {(item: string) => boolean}
+ */
+const buildIgnored = (options) => {
+	const wp = new Watchpack(options);
+	return wp.watcherOptions.ignored;
+};
+
+const UNIX_PATHS = [
+	"/home/user/project/src/index.js",
+	"/home/user/project/src/components/App.jsx",
+	"/home/user/project/node_modules/react/index.js",
+	"/home/user/project/dist/bundle.js",
+	"/home/user/project/.git/HEAD",
+	"/home/user/project/coverage/lcov.info",
+	"/home/user/project/src/utils/helpers.ts",
+	"/home/user/project/test/fixtures/a.js",
+	"/home/user/project/README.md",
+	"/home/user/project/package.json",
+];
+
+const WINDOWS_PATHS = UNIX_PATHS.map((p) => p.replace(/\//g, "\\"));
+
+const bench = withCodSpeed(new Bench({ name: "ignored", time: 200 }));
+
+const noneMatcher = buildIgnored({});
+const regexpMatcher = buildIgnored({
+	ignored: /node_modules|\.git|dist|coverage/,
+});
+const stringMatcher = buildIgnored({ ignored: "**/node_modules" });
+const smallArrayMatcher = buildIgnored({
+	ignored: ["**/node_modules", "**/.git"],
+});
+const largeArrayMatcher = buildIgnored({
+	ignored: [
+		"**/node_modules",
+		"**/.git",
+		"**/dist",
+		"**/build",
+		"**/coverage",
+		"**/.cache",
+		"**/.next",
+		"**/.nuxt",
+		"**/tmp",
+		"**/*.log",
+	],
+});
+const functionMatcher = buildIgnored({
+	ignored: (p) => p.includes("node_modules") || p.includes(".git"),
+});
+
+bench
+	.add("ignored=undefined (noop) unix paths", () => {
+		for (const p of UNIX_PATHS) noneMatcher(p);
+	})
+	.add("ignored=regexp unix paths", () => {
+		for (const p of UNIX_PATHS) regexpMatcher(p);
+	})
+	.add("ignored=regexp windows paths", () => {
+		for (const p of WINDOWS_PATHS) regexpMatcher(p);
+	})
+	.add("ignored=string unix paths", () => {
+		for (const p of UNIX_PATHS) stringMatcher(p);
+	})
+	.add("ignored=array[2] unix paths", () => {
+		for (const p of UNIX_PATHS) smallArrayMatcher(p);
+	})
+	.add("ignored=array[10] unix paths", () => {
+		for (const p of UNIX_PATHS) largeArrayMatcher(p);
+	})
+	.add("ignored=array[10] windows paths", () => {
+		for (const p of WINDOWS_PATHS) largeArrayMatcher(p);
+	})
+	.add("ignored=function unix paths", () => {
+		for (const p of UNIX_PATHS) functionMatcher(p);
+	});
+
+export default bench;
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	await bench.run();
+	console.table(bench.table());
+}
diff --git a/bench/index.mjs b/bench/index.mjs
new file mode 100644
index 0000000..2e3e7b2
--- /dev/null
+++ b/bench/index.mjs
@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+
+	Runs every tinybench suite shipped in this repository. Suites are split
+	by the lib/ module they exercise so CodSpeed reports them as independent
+	groups and so that running a single suite locally is cheap.
+*/
+
+import ignoredBench from "./ignored/ignored.bench.mjs";
+import reducePlanBench from "./reducePlan/reducePlan.bench.mjs";
+import linkResolverBench from "./LinkResolver/LinkResolver.bench.mjs";
+import watchpackBench from "./watchpack/normalizeOptions.bench.mjs";
+
+const suites = [
+	ignoredBench,
+	reducePlanBench,
+	linkResolverBench,
+	watchpackBench,
+];
+
+for (const suite of suites) {
+	process.stdout.write(`\n== ${suite.name ?? "bench"} ==\n`);
+	// eslint-disable-next-line no-await-in-loop
+	await suite.run();
+	console.table(suite.table());
+}
diff --git a/bench/reducePlan/reducePlan.bench.mjs b/bench/reducePlan/reducePlan.bench.mjs
new file mode 100644
index 0000000..cd4be8c
--- /dev/null
+++ b/bench/reducePlan/reducePlan.bench.mjs
@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+import { Bench } from "tinybench";
+import { withCodSpeed } from "@codspeed/tinybench-plugin";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const reducePlan = require("../../lib/reducePlan.js");
+
+const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
+const SEP = process.platform === "win32" ? "\\" : "/";
+
+/**
+ * @param {number} count number of leaf targets
+ * @param {number} width branching factor per directory
+ * @returns {Map<string, string>} plan
+ */
+const buildWidePlan = (count, width) => {
+	const plan = new Map();
+	let i = 0;
+	let dir = 0;
+	while (i < count) {
+		const group = `${ROOT}${SEP}group${dir}`;
+		for (let j = 0; j < width && i < count; j++, i++) {
+			plan.set(`${group}${SEP}file${i}`, `v${i}`);
+		}
+		dir++;
+	}
+	return plan;
+};
+
+/**
+ * @param {number} depth directory depth
+ * @param {number} leaves leaves per level
+ * @returns {Map<string, string>} plan
+ */
+const buildDeepPlan = (depth, leaves) => {
+	const plan = new Map();
+	let i = 0;
+	const walk = (prefix, level) => {
+		for (let l = 0; l < leaves; l++) {
+			const p = `${prefix}${SEP}file${i}`;
+			plan.set(p, `v${i++}`);
+		}
+		if (level < depth) {
+			walk(`${prefix}${SEP}sub${level}`, level + 1);
+		}
+	};
+	walk(ROOT, 0);
+	return plan;
+};
+
+/**
+ * @param {number} count number of targets
+ * @returns {Map<string, string>} plan
+ */
+const buildFlatPlan = (count) => {
+	const plan = new Map();
+	for (let i = 0; i < count; i++) {
+		plan.set(`${ROOT}${SEP}file${i}`, `v${i}`);
+	}
+	return plan;
+};
+
+const smallPlan = buildWidePlan(50, 10);
+const mediumPlan = buildWidePlan(500, 20);
+const largePlan = buildWidePlan(2000, 25);
+const deepPlan = buildDeepPlan(30, 3);
+const flatPlan = buildFlatPlan(500);
+
+const bench = withCodSpeed(new Bench({ name: "reducePlan", time: 200 }));
+
+bench
+	.add("under limit (no-op, n=50, limit=100)", () => {
+		reducePlan(smallPlan, 100);
+	})
+	.add("small plan reduction (n=50, limit=10)", () => {
+		reducePlan(smallPlan, 10);
+	})
+	.add("medium plan reduction (n=500, limit=50)", () => {
+		reducePlan(mediumPlan, 50);
+	})
+	.add("medium plan light reduction (n=500, limit=400)", () => {
+		reducePlan(mediumPlan, 400);
+	})
+	.add("large plan reduction (n=2000, limit=100)", () => {
+		reducePlan(largePlan, 100);
+	})
+	.add("deep plan reduction (depth=30, limit=20)", () => {
+		reducePlan(deepPlan, 20);
+	})
+	.add("flat plan reduction (n=500 in one dir, limit=50)", () => {
+		reducePlan(flatPlan, 50);
+	});
+
+export default bench;
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	await bench.run();
+	console.table(bench.table());
+}
diff --git a/bench/watchpack/normalizeOptions.bench.mjs b/bench/watchpack/normalizeOptions.bench.mjs
new file mode 100644
index 0000000..7028907
--- /dev/null
+++ b/bench/watchpack/normalizeOptions.bench.mjs
@@ -0,0 +1,76 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+import { Bench } from "tinybench";
+import { withCodSpeed } from "@codspeed/tinybench-plugin";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const Watchpack = require("../../lib/index.js");
+
+// The Watchpack constructor normalizes options and installs a cache on the
+// options object. Measuring construction captures ignored compilation plus
+// option validation, which is called frequently by webpack on each rebuild.
+
+const optionsNone = {};
+const optionsWithRegExp = { ignored: /node_modules|\.git/ };
+const optionsWithString = { ignored: "**/node_modules" };
+const optionsWithSmallArray = { ignored: ["**/node_modules", "**/.git"] };
+const optionsWithLargeArray = {
+	ignored: [
+		"**/node_modules",
+		"**/.git",
+		"**/dist",
+		"**/build",
+		"**/coverage",
+		"**/.cache",
+		"**/.next",
+		"**/.nuxt",
+		"**/tmp",
+		"**/*.log",
+	],
+};
+const optionsWithFn = { ignored: (p) => p.includes("node_modules") };
+
+const bench = withCodSpeed(
+	new Bench({ name: "Watchpack construction", time: 200 }),
+);
+
+bench
+	.add("new Watchpack() with no ignored", () => {
+		const wp = new Watchpack(optionsNone);
+		wp.close();
+	})
+	.add("new Watchpack() with regexp ignored", () => {
+		const wp = new Watchpack(optionsWithRegExp);
+		wp.close();
+	})
+	.add("new Watchpack() with string ignored", () => {
+		const wp = new Watchpack(optionsWithString);
+		wp.close();
+	})
+	.add("new Watchpack() with array[2] ignored", () => {
+		const wp = new Watchpack(optionsWithSmallArray);
+		wp.close();
+	})
+	.add("new Watchpack() with array[10] ignored", () => {
+		const wp = new Watchpack(optionsWithLargeArray);
+		wp.close();
+	})
+	.add("new Watchpack() with function ignored", () => {
+		const wp = new Watchpack(optionsWithFn);
+		wp.close();
+	})
+	.add("new Watchpack() reusing cached options", () => {
+		// Exercises the WeakMap cache for option normalization.
+		const wp = new Watchpack(optionsWithLargeArray);
+		wp.close();
+	});
+
+export default bench;
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	await bench.run();
+	console.table(bench.table());
+}
diff --git a/eslint.config.mjs b/eslint.config.mjs
index ed6c60d..8c1fe99 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -2,6 +2,12 @@ import { defineConfig } from "eslint/config";
 import config from "eslint-config-webpack";
 
 export default defineConfig([
+	{
+		// Benchmarks are ESM-only (tinybench is ESM) and use top-level await
+		// plus import.meta which the shared CJS config does not expect. They
+		// are not shipped with the package so lint them out.
+		ignores: ["bench/**"],
+	},
 	{
 		extends: [config],
 		rules: {
diff --git a/lib/index.js b/lib/index.js
index 2cbad01..640b217 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -79,27 +79,44 @@ const stringToRegexp = (ignored) => {
 	return `${source.slice(0, -1)}(?:$|\\/)`;
 };
 
+/**
+ * Normalizes path separators for regex testing. `String.prototype.replace`
+ * always allocates a new string, even when the pattern finds nothing; for
+ * POSIX paths (the common case) that allocation is pure overhead. Check for
+ * a backslash with `indexOf` first so we skip the copy on paths that are
+ * already normalized.
+ * @param {string} item item
+ * @returns {string} item with backslashes normalized to forward slashes
+ */
+const normalizeSeparators = (item) =>
+	item.includes("\\") ? item.replace(/\\/g, "/") : item;
+
 /**
  * @param {Ignored=} ignored ignored
  * @returns {(item: string) => boolean} ignored to function
  */
 const ignoredToFunction = (ignored) => {
 	if (Array.isArray(ignored)) {
-		const stringRegexps = ignored.map((i) => stringToRegexp(i)).filter(Boolean);
+		const stringRegexps =
+			/** @type {string[]} */
+			(ignored.map((i) => stringToRegexp(i)).filter(Boolean));
 		if (stringRegexps.length === 0) {
 			return () => false;
 		}
-		const regexp = new RegExp(stringRegexps.join("|"));
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		const regexp =
+			stringRegexps.length === 1
+				? new RegExp(stringRegexps[0])
+				: new RegExp(stringRegexps.join("|"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (typeof ignored === "string") {
 		const stringRegexp = stringToRegexp(ignored);
 		if (!stringRegexp) {
 			return () => false;
 		}
 		const regexp = new RegExp(stringRegexp);
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (ignored instanceof RegExp) {
-		return (item) => ignored.test(item.replace(/\\/g, "/"));
+		return (item) => ignored.test(normalizeSeparators(item));
 	} else if (typeof ignored === "function") {
 		return ignored;
 	} else if (ignored) {
diff --git a/lib/reducePlan.js b/lib/reducePlan.js
index a6ced7f..8e0d38b 100644
--- a/lib/reducePlan.js
+++ b/lib/reducePlan.js
@@ -67,45 +67,66 @@ module.exports = (plan, limit) => {
 			}
 		}
 	}
-	// Reduce until limit reached
-	while (currentCount > limit) {
-		// Select node that helps reaching the limit most effectively without overmerging
-		const overLimit = currentCount - limit;
-		let bestNode;
-		let bestCost = Infinity;
+	// Reduce until limit reached. When no reduction is needed at all, skip
+	// building the candidate set entirely to avoid paying for the setup on the
+	// common fast path.
+	if (currentCount > limit) {
+		// Pre-filter candidate nodes so the inner selection loop skips structural
+		// non-candidates entirely. `children` length and parent presence are
+		// fixed after tree construction; only `entries` can change (it can only
+		// decrease), so a node that fails the `entries` check in a later round
+		// is simply skipped via `continue`. When we merge a subtree we drop the
+		// descendants from the candidate set to keep it shrinking over
+		// iterations.
+		/** @type {Set<TreeNode<T>>} */
+		const candidates = new Set();
 		for (const node of treeMap.values()) {
-			if (node.entries <= 1 || !node.children || !node.parent) continue;
+			if (!node.parent || !node.children) continue;
 			if (node.children.length === 0) continue;
 			if (node.children.length === 1 && !node.value) continue;
-			// Try to select the node with has just a bit more entries than we need to reduce
-			// When just a bit more is over 30% over the limit,
-			// also consider just a bit less entries then we need to reduce
-			const cost =
-				node.entries - 1 >= overLimit
-					? node.entries - 1 - overLimit
-					: overLimit - node.entries + 1 + limit * 0.3;
-			if (cost < bestCost) {
-				bestNode = node;
-				bestCost = cost;
-			}
-		}
-		if (!bestNode) break;
-		// Merge all children
-		const reduction = bestNode.entries - 1;
-		bestNode.active = true;
-		bestNode.entries = 1;
-		currentCount -= reduction;
-		let { parent } = bestNode;
-		while (parent) {
-			parent.entries -= reduction;
-			parent = parent.parent;
+			candidates.add(node);
 		}
-		const queue = new Set(bestNode.children);
-		for (const node of queue) {
-			node.active = false;
-			node.entries = 0;
-			if (node.children) {
-				for (const child of node.children) queue.add(child);
+		const costBias = limit * 0.3;
+		while (currentCount > limit) {
+			// Select node that helps reaching the limit most effectively without overmerging
+			const overLimit = currentCount - limit;
+			let bestNode;
+			let bestCost = Infinity;
+			for (const node of candidates) {
+				if (node.entries <= 1) continue;
+				// Try to select the node with has just a bit more entries than we need to reduce
+				// When just a bit more is over 30% over the limit,
+				// also consider just a bit less entries then we need to reduce
+				const diff = node.entries - 1 - overLimit;
+				const cost = diff >= 0 ? diff : -diff + costBias;
+				if (cost < bestCost) {
+					bestNode = node;
+					bestCost = cost;
+					// A cost of 0 means the merge reduces exactly to the limit;
+					// no further candidate can improve on that, so stop scanning.
+					if (cost === 0) break;
+				}
+			}
+			if (!bestNode) break;
+			// Merge all children
+			const reduction = bestNode.entries - 1;
+			bestNode.active = true;
+			bestNode.entries = 1;
+			candidates.delete(bestNode);
+			currentCount -= reduction;
+			let { parent } = bestNode;
+			while (parent) {
+				parent.entries -= reduction;
+				parent = parent.parent;
+			}
+			const queue = new Set(bestNode.children);
+			for (const node of queue) {
+				node.active = false;
+				node.entries = 0;
+				candidates.delete(node);
+				if (node.children) {
+					for (const child of node.children) queue.add(child);
+				}
 			}
 		}
 	}
diff --git a/package-lock.json b/package-lock.json
index 9f70a8c..ff8f65e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -15,6 +15,7 @@
       "devDependencies": {
         "@changesets/cli": "^2.30.0",
         "@changesets/get-github-info": "^0.8.0",
+        "@codspeed/tinybench-plugin": "^5.2.0",
         "@types/glob-to-regexp": "^0.4.4",
         "@types/graceful-fs": "^4.1.9",
         "@types/jest": "^30.0.0",
@@ -23,6 +24,7 @@
         "eslint-config-webpack": "^4.9.3",
         "jest": "^30.3.0",
         "prettier": "^3.7.4",
+        "tinybench": "^6.0.0",
         "typescript": "^6.0.2",
         "write-file-atomic": "^7.0.1"
       },
@@ -61,7 +63,6 @@
       "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.28.6",
         "@babel/generator": "^7.28.6",
@@ -872,6 +873,121 @@
         "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
+    "node_modules/@codspeed/core": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@codspeed/core/-/core-5.2.0.tgz",
+      "integrity": "sha512-CmDhpWjcOJg2iBOQ/BmBnSBq8qxlM3r4h8uvYDkoUaba+EKRT3T73BZtKuml/48jZMsB+4/FG2UbTBinDWtuvw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "axios": "^1.4.0",
+        "find-up": "^6.3.0",
+        "form-data": "^4.0.4",
+        "node-gyp-build": "^4.6.0"
+      }
+    },
+    "node_modules/@codspeed/core/node_modules/find-up": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-6.3.0.tgz",
+      "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^7.1.0",
+        "path-exists": "^5.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@codspeed/core/node_modules/locate-path": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz",
+      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^6.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@codspeed/core/node_modules/p-limit": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
+      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^1.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@codspeed/core/node_modules/p-locate": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz",
+      "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^4.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@codspeed/core/node_modules/path-exists": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz",
+      "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/@codspeed/core/node_modules/yocto-queue": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.2.tgz",
+      "integrity": "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@codspeed/tinybench-plugin": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@codspeed/tinybench-plugin/-/tinybench-plugin-5.2.0.tgz",
+      "integrity": "sha512-LCmMFON3hdIRqiHC3W8oR0783cecRgA8x7cWMTnC9DgkIuyMrreHgQexnUGV3zsHgB084EXj/iPrWxR914/8Ng==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@codspeed/core": "^5.2.0",
+        "stack-trace": "1.0.0-pre2"
+      },
+      "peerDependencies": {
+        "tinybench": ">=4.0.1"
+      }
+    },
     "node_modules/@emnapi/core": {
       "version": "1.9.1",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.1.tgz",
@@ -2379,7 +2495,6 @@
       "integrity": "sha512-A1sre26ke7HDIuY/M23nd9gfB+nrmhtYyMINbjI1zHJxYteKR6qSMX56FsmjMcDb3SMcjJg5BiRRgOCC/yBD0g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~7.16.0"
       }
@@ -2421,7 +2536,6 @@
       "integrity": "sha512-eSkwoemjo76bdXl2MYqtxg51HNwUSkWfODUOQ3PaTLZGh9uIWWFZIjyjaJnex7wXDu+TRx+ATsnSxdN9YWfRTQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.12.2",
         "@typescript-eslint/scope-manager": "8.58.1",
@@ -2461,7 +2575,6 @@
       "integrity": "sha512-gGkiNMPqerb2cJSVcruigx9eHBlLG14fSdPdqMoOcBfh+vvn4iCq2C8MzUB89PrxOXk0y3GZ1yIWb9aOzL93bw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.58.1",
         "@typescript-eslint/types": "8.58.1",
@@ -2981,7 +3094,6 @@
       "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -3292,6 +3404,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/available-typed-arrays": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
@@ -3308,6 +3427,18 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/axios": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.15.0.tgz",
+      "integrity": "sha512-wWyJDlAatxk30ZJer+GeCWS209sA42X+N5jU2jy6oHTp7ufw8uzUTVFBX9+wTfAlhiJXGS0Bq7X6efruWjuK9Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
+        "proxy-from-env": "^2.1.0"
+      }
+    },
     "node_modules/babel-jest": {
       "version": "30.3.0",
       "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-30.3.0.tgz",
@@ -3481,7 +3612,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -3779,6 +3909,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/commander": {
       "version": "8.3.0",
       "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
@@ -4003,6 +4146,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/dequal": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
@@ -4369,7 +4522,6 @@
       "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -4446,7 +4598,6 @@
       "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -5278,6 +5429,27 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/follow-redirects": {
+      "version": "1.16.0",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.0.tgz",
+      "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/for-each": {
       "version": "0.3.5",
       "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
@@ -5324,6 +5496,23 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/format": {
       "version": "0.2.2",
       "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
@@ -6547,7 +6736,6 @@
       "integrity": "sha512-AkXIIFcaazymvey2i/+F94XRnM6TsVLZDhBMLsd1Sf/W0wzsvvpjeyUrCZD6HGG4SDYPgDJDBKeiJTBb10WzMg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "30.3.0",
         "@jest/types": "30.3.0",
@@ -8464,6 +8652,29 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/mimic-fn": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
@@ -8593,6 +8804,18 @@
         "webidl-conversions": "^3.0.0"
       }
     },
+    "node_modules/node-gyp-build": {
+      "version": "4.8.4",
+      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz",
+      "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "node-gyp-build": "bin.js",
+        "node-gyp-build-optional": "optional.js",
+        "node-gyp-build-test": "build-test.js"
+      }
+    },
     "node_modules/node-int64": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
@@ -9176,7 +9399,6 @@
       "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -9247,6 +9469,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/proxy-from-env": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+      "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -9917,6 +10149,16 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/stack-trace": {
+      "version": "1.0.0-pre2",
+      "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-1.0.0-pre2.tgz",
+      "integrity": "sha512-2ztBJRek8IVofG9DBJqdy2N5kulaacX30Nz7xmkYF6ale9WBVmIy6mFBchvGX7Vx/MyjBhx+Rcxqrj+dbOnQ6A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
     "node_modules/stack-utils": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
@@ -10254,6 +10496,16 @@
         "node": ">=8"
       }
     },
+    "node_modules/tinybench": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-6.0.0.tgz",
+      "integrity": "sha512-BWlWpVbbZXaYjRV0twGLNQO00Zj4HA/sjLOQP2IvzQqGwRGp+2kh7UU3ijyJ3ywFRogYDRbiHDMrUOfaMnN56g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
@@ -10508,7 +10760,6 @@
       "integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -10992,7 +11243,6 @@
       "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
diff --git a/package.json b/package.json
index 42bc9f8..a72e531 100644
--- a/package.json
+++ b/package.json
@@ -39,6 +39,11 @@
     "test:only": "npm run test:base",
     "test:watch": "npm run test:base -- --watch",
     "test:coverage": "npm run test:base -- --collectCoverageFrom=\"lib/**/*.js\" --coverage",
+    "bench": "node bench/index.mjs",
+    "bench:ignored": "node bench/ignored/ignored.bench.mjs",
+    "bench:reducePlan": "node bench/reducePlan/reducePlan.bench.mjs",
+    "bench:LinkResolver": "node bench/LinkResolver/LinkResolver.bench.mjs",
+    "bench:watchpack": "node bench/watchpack/normalizeOptions.bench.mjs",
     "version": "changeset version",
     "release": "changeset publish"
   },
@@ -49,6 +54,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.30.0",
     "@changesets/get-github-info": "^0.8.0",
+    "@codspeed/tinybench-plugin": "^5.2.0",
     "@types/glob-to-regexp": "^0.4.4",
     "@types/graceful-fs": "^4.1.9",
     "@types/jest": "^30.0.0",
@@ -57,6 +63,7 @@
     "eslint-config-webpack": "^4.9.3",
     "jest": "^30.3.0",
     "prettier": "^3.7.4",
+    "tinybench": "^6.0.0",
     "typescript": "^6.0.2",
     "write-file-atomic": "^7.0.1"
   },

From 6128ddb6992b2b57c2d07e21b22d2dc913fad8ca Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 16 Apr 2026 16:06:03 +0000
Subject: [PATCH 2/7] perf: trim hot-path work in watchEventSource + Watchpack
 + expand benches

- lib/watchEventSource.js: skip the parent-walk loop in .watch() entirely
  when recursiveWatchers is empty, which is always the case on Linux and
  the common case on OSX/Windows before the watcher limit is hit.
- lib/watchEventSource.js: hoist path.basename(filePath) out of the event
  handler closure so it's computed once per watcher rather than on every
  dispatched change event.
- lib/index.js: drop the redundant set.has() probe in addWatchersToSet
  since Set.add is already idempotent.
- lib/index.js: switch Watchpack.getTimes() from Object.keys+index to a
  for...in walk over the prototype-less record returned by the directory
  watcher, avoiding a throwaway array per watched directory.
- bench/ignored: add singleton-array, mixed-separator, and deep-path
  scenarios.
- bench/reducePlan: add "barely over", aggressive, huge, very-deep, and
  flat-large scenarios to catch regressions in the selection loop.

https://claude.ai/code/session_012uFpZRKDYdUbCfCEMtGQzN
---
 bench/ignored/ignored.bench.mjs       | 30 +++++++++++++++++++++++++++
 bench/reducePlan/reducePlan.bench.mjs | 18 ++++++++++++++++
 lib/index.js                          | 10 ++++-----
 lib/watchEventSource.js               | 28 ++++++++++++++++---------
 4 files changed, 71 insertions(+), 15 deletions(-)

diff --git a/bench/ignored/ignored.bench.mjs b/bench/ignored/ignored.bench.mjs
index b2113f8..66df6a3 100644
--- a/bench/ignored/ignored.bench.mjs
+++ b/bench/ignored/ignored.bench.mjs
@@ -38,6 +38,22 @@ const UNIX_PATHS = [
 
 const WINDOWS_PATHS = UNIX_PATHS.map((p) => p.replace(/\//g, "\\"));
 
+// Mixed unix/windows paths simulate a cross-platform tool (for example a test
+// runner) that normalises some paths to posix before passing them in while
+// leaving others in native form.
+const MIXED_PATHS = UNIX_PATHS.map((p, i) =>
+	i % 2 === 0 ? p : p.replace(/\//g, "\\"),
+);
+
+// Deep monorepo style paths: hundreds of segments, node_modules sprinkled
+// deep. Benchmarks the worst-case scan distance for the regex matcher.
+const DEEP_PATHS = Array.from({ length: 10 }, (_, i) => {
+	const segments = Array.from({ length: 15 }, (_, j) => `level${j}`);
+	segments.push(i === 3 ? "node_modules" : `leaf${i}`);
+	segments.push("index.js");
+	return `/${segments.join("/")}`;
+});
+
 const bench = withCodSpeed(new Bench({ name: "ignored", time: 200 }));
 
 const noneMatcher = buildIgnored({});
@@ -66,6 +82,8 @@ const functionMatcher = buildIgnored({
 	ignored: (p) => p.includes("node_modules") || p.includes(".git"),
 });
 
+const singletonArrayMatcher = buildIgnored({ ignored: ["**/node_modules"] });
+
 bench
 	.add("ignored=undefined (noop) unix paths", () => {
 		for (const p of UNIX_PATHS) noneMatcher(p);
@@ -76,9 +94,18 @@ bench
 	.add("ignored=regexp windows paths", () => {
 		for (const p of WINDOWS_PATHS) regexpMatcher(p);
 	})
+	.add("ignored=regexp mixed-separator paths", () => {
+		for (const p of MIXED_PATHS) regexpMatcher(p);
+	})
+	.add("ignored=regexp deep paths", () => {
+		for (const p of DEEP_PATHS) regexpMatcher(p);
+	})
 	.add("ignored=string unix paths", () => {
 		for (const p of UNIX_PATHS) stringMatcher(p);
 	})
+	.add("ignored=array[1] unix paths", () => {
+		for (const p of UNIX_PATHS) singletonArrayMatcher(p);
+	})
 	.add("ignored=array[2] unix paths", () => {
 		for (const p of UNIX_PATHS) smallArrayMatcher(p);
 	})
@@ -88,6 +115,9 @@ bench
 	.add("ignored=array[10] windows paths", () => {
 		for (const p of WINDOWS_PATHS) largeArrayMatcher(p);
 	})
+	.add("ignored=array[10] deep paths", () => {
+		for (const p of DEEP_PATHS) largeArrayMatcher(p);
+	})
 	.add("ignored=function unix paths", () => {
 		for (const p of UNIX_PATHS) functionMatcher(p);
 	});
diff --git a/bench/reducePlan/reducePlan.bench.mjs b/bench/reducePlan/reducePlan.bench.mjs
index cd4be8c..180dfe6 100644
--- a/bench/reducePlan/reducePlan.bench.mjs
+++ b/bench/reducePlan/reducePlan.bench.mjs
@@ -67,8 +67,11 @@ const buildFlatPlan = (count) => {
 const smallPlan = buildWidePlan(50, 10);
 const mediumPlan = buildWidePlan(500, 20);
 const largePlan = buildWidePlan(2000, 25);
+const hugePlan = buildWidePlan(10000, 40);
 const deepPlan = buildDeepPlan(30, 3);
+const veryDeepPlan = buildDeepPlan(80, 2);
 const flatPlan = buildFlatPlan(500);
+const flatLargePlan = buildFlatPlan(5000);
 
 const bench = withCodSpeed(new Bench({ name: "reducePlan", time: 200 }));
 
@@ -85,14 +88,29 @@ bench
 	.add("medium plan light reduction (n=500, limit=400)", () => {
 		reducePlan(mediumPlan, 400);
 	})
+	.add("medium plan barely over (n=500, limit=499)", () => {
+		reducePlan(mediumPlan, 499);
+	})
 	.add("large plan reduction (n=2000, limit=100)", () => {
 		reducePlan(largePlan, 100);
 	})
+	.add("large plan aggressive (n=2000, limit=10)", () => {
+		reducePlan(largePlan, 10);
+	})
+	.add("huge plan reduction (n=10000, limit=500)", () => {
+		reducePlan(hugePlan, 500);
+	})
 	.add("deep plan reduction (depth=30, limit=20)", () => {
 		reducePlan(deepPlan, 20);
 	})
+	.add("very deep plan (depth=80, limit=40)", () => {
+		reducePlan(veryDeepPlan, 40);
+	})
 	.add("flat plan reduction (n=500 in one dir, limit=50)", () => {
 		reducePlan(flatPlan, 50);
+	})
+	.add("flat large plan (n=5000 in one dir, limit=100)", () => {
+		reducePlan(flatLargePlan, 100);
 	});
 
 export default bench;
diff --git a/lib/index.js b/lib/index.js
index 640b217..594f88e 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -60,10 +60,8 @@ const watchEventSource = require("./watchEventSource");
  */
 function addWatchersToSet(watchers, set) {
 	for (const ww of watchers) {
-		const w = ww.watcher;
-		if (!set.has(w.directoryWatcher)) {
-			set.add(w.directoryWatcher);
-		}
+		// Set.add is already idempotent, so skip the redundant has() probe.
+		set.add(ww.watcher.directoryWatcher);
 	}
 }
 
@@ -480,8 +478,10 @@ class Watchpack extends EventEmitter {
 		/** @type {Record<string, number>} */
 		const obj = Object.create(null);
 		for (const w of directoryWatchers) {
+			// getTimes() returns a prototype-less object, so for...in is safe
+			// and avoids the throwaway array that Object.keys would allocate.
 			const times = w.getTimes();
-			for (const file of Object.keys(times)) obj[file] = times[file];
+			for (const file in times) obj[file] = times[file];
 		}
 		return obj;
 	}
diff --git a/lib/watchEventSource.js b/lib/watchEventSource.js
index e9b3b3f..7d838a5 100644
--- a/lib/watchEventSource.js
+++ b/lib/watchEventSource.js
@@ -61,6 +61,9 @@ function createEPERMError(filePath) {
  * @returns {(type: "rename" | "change", filename: string) => void} handler of change event
  */
 function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
+	// path.basename(filePath) is invariant for the lifetime of the watcher,
+	// so compute it once rather than on every dispatched event.
+	const ownBasename = path.basename(filePath);
 	return (type, filename) => {
 		// TODO: After Node.js v22, fs.watch(dir) and deleting a dir will trigger the rename change event.
 		// Here we just ignore it and keep the same behavior as before v22
@@ -68,7 +71,7 @@ function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
 		if (
 			type === "rename" &&
 			path.isAbsolute(filename) &&
-			path.basename(filename) === path.basename(filePath)
+			path.basename(filename) === ownBasename
 		) {
 			if (!IS_OSX) {
 				// Before v22, windows will throw EPERM error
@@ -429,16 +432,21 @@ module.exports.watch = (filePath) => {
 		directWatcher.add(watcher);
 		return watcher;
 	}
-	let current = filePath;
-	for (;;) {
-		const recursiveWatcher = recursiveWatchers.get(current);
-		if (recursiveWatcher !== undefined) {
-			recursiveWatcher.add(filePath, watcher);
-			return watcher;
+	// Only platforms with recursive fs.watch ever populate recursiveWatchers,
+	// so skip the entire parent walk when the map is empty (always the case
+	// on Linux and the common case before the watcher limit is reached).
+	if (recursiveWatchers.size !== 0) {
+		let current = filePath;
+		for (;;) {
+			const recursiveWatcher = recursiveWatchers.get(current);
+			if (recursiveWatcher !== undefined) {
+				recursiveWatcher.add(filePath, watcher);
+				return watcher;
+			}
+			const parent = path.dirname(current);
+			if (parent === current) break;
+			current = parent;
 		}
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
 	}
 	// Queue up watcher for creation
 	pendingWatchers.set(watcher, filePath);

From 8d7696dadd49604142a4b2823efea3230ecb880b Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 16 Apr 2026 17:57:25 +0000
Subject: [PATCH 3/7] refactor(bench): hoist tinybench plumbing into shared
 bench/helpers.mjs

Every suite previously repeated the same four lines for Bench creation,
CodSpeed wrapping, createRequire setup, and main-module detection. Move
those into bench/helpers.mjs behind createBench/moduleRequire/runIfMain so
the suite files read like the body of a single-file benchmark while still
living in their own directories. The aggregate runner picks up a matching
runSuites helper for the same reason.

https://claude.ai/code/session_012uFpZRKDYdUbCfCEMtGQzN
---
 bench/LinkResolver/LinkResolver.bench.mjs  | 13 ++---
 bench/helpers.mjs                          | 64 ++++++++++++++++++++++
 bench/ignored/ignored.bench.mjs            | 13 ++---
 bench/index.mjs                            | 12 +---
 bench/reducePlan/reducePlan.bench.mjs      | 13 ++---
 bench/watchpack/normalizeOptions.bench.mjs | 15 ++---
 6 files changed, 83 insertions(+), 47 deletions(-)
 create mode 100644 bench/helpers.mjs

diff --git a/bench/LinkResolver/LinkResolver.bench.mjs b/bench/LinkResolver/LinkResolver.bench.mjs
index 32c0c5b..d49ea15 100644
--- a/bench/LinkResolver/LinkResolver.bench.mjs
+++ b/bench/LinkResolver/LinkResolver.bench.mjs
@@ -2,11 +2,9 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
-import { Bench } from "tinybench";
-import { withCodSpeed } from "@codspeed/tinybench-plugin";
-import { createRequire } from "module";
+import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
 
-const require = createRequire(import.meta.url);
+const require = moduleRequire(import.meta.url);
 const LinkResolver = require("../../lib/LinkResolver.js");
 
 // LinkResolver does real sync filesystem work via fs.readlinkSync.
@@ -47,7 +45,7 @@ for (const p of shallowPaths) warmResolver.resolve(p);
 for (const p of mediumPaths) warmResolver.resolve(p);
 for (const p of deepPaths) warmResolver.resolve(p);
 
-const bench = withCodSpeed(new Bench({ name: "LinkResolver", time: 200 }));
+const bench = createBench("LinkResolver");
 
 bench
 	.add("cold resolve shallow paths (depth=1, n=100)", () => {
@@ -71,7 +69,4 @@ bench
 
 export default bench;
 
-if (import.meta.url === `file://${process.argv[1]}`) {
-	await bench.run();
-	console.table(bench.table());
-}
+await runIfMain(import.meta.url, bench);
diff --git a/bench/helpers.mjs b/bench/helpers.mjs
new file mode 100644
index 0000000..3423354
--- /dev/null
+++ b/bench/helpers.mjs
@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+
+	Shared plumbing for the tinybench suites shipped under bench/. Each suite
+	file declares its cases and exports the resulting Bench; everything else
+	(CodSpeed wiring, require resolution, standalone entrypoint behaviour,
+	aggregate runner) lives here so the per-suite files look as close as
+	possible to "just the benchmark cases".
+*/
+
+import { Bench } from "tinybench";
+import { withCodSpeed } from "@codspeed/tinybench-plugin";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+
+// Keep the measurement window in one place so every suite reports on the
+// same time budget and CodSpeed sees comparable sample counts between runs.
+const BENCH_TIME_MS = 200;
+
+/**
+ * Create a CodSpeed-wrapped Bench with our standard options.
+ * @param {string} name suite name (shown in CodSpeed and in the aggregate
+ * runner's section headers)
+ * @returns {Bench} bench
+ */
+export const createBench = (name) =>
+	withCodSpeed(new Bench({ name, time: BENCH_TIME_MS }));
+
+/**
+ * Anchor a CommonJS `require` to the given ESM module. Lets bench files
+ * pull in watchpack's CJS lib modules with the same relative paths they
+ * would use in a .js sibling.
+ * @param {string} importMetaUrl caller's import.meta.url
+ * @returns {NodeRequire} require
+ */
+export const moduleRequire = (importMetaUrl) => createRequire(importMetaUrl);
+
+/**
+ * Run the suite and print its table when the bench file is invoked
+ * directly (e.g. `npm run bench:<name>`). No-op when the file is only
+ * imported by the aggregate runner.
+ * @param {string} importMetaUrl caller's import.meta.url
+ * @param {Bench} bench bench to run
+ */
+export const runIfMain = async (importMetaUrl, bench) => {
+	if (!process.argv[1]) return;
+	if (importMetaUrl !== pathToFileURL(process.argv[1]).href) return;
+	await bench.run();
+	console.table(bench.table());
+};
+
+/**
+ * Run every supplied suite sequentially and print a labeled table per suite.
+ * Used by bench/index.mjs to produce a single aggregate report.
+ * @param {Bench[]} suites suites
+ */
+export const runSuites = async (suites) => {
+	for (const suite of suites) {
+		process.stdout.write(`\n== ${suite.name ?? "bench"} ==\n`);
+		// eslint-disable-next-line no-await-in-loop
+		await suite.run();
+		console.table(suite.table());
+	}
+};
diff --git a/bench/ignored/ignored.bench.mjs b/bench/ignored/ignored.bench.mjs
index 66df6a3..be5565b 100644
--- a/bench/ignored/ignored.bench.mjs
+++ b/bench/ignored/ignored.bench.mjs
@@ -2,11 +2,9 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
-import { Bench } from "tinybench";
-import { withCodSpeed } from "@codspeed/tinybench-plugin";
-import { createRequire } from "module";
+import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
 
-const require = createRequire(import.meta.url);
+const require = moduleRequire(import.meta.url);
 // Require the internal helpers via the package entry to avoid duplication.
 // We re-implement the call paths through the public Watchpack constructor
 // which normalizes ignored exactly once per options object.
@@ -54,7 +52,7 @@ const DEEP_PATHS = Array.from({ length: 10 }, (_, i) => {
 	return `/${segments.join("/")}`;
 });
 
-const bench = withCodSpeed(new Bench({ name: "ignored", time: 200 }));
+const bench = createBench("ignored");
 
 const noneMatcher = buildIgnored({});
 const regexpMatcher = buildIgnored({
@@ -124,7 +122,4 @@ bench
 
 export default bench;
 
-if (import.meta.url === `file://${process.argv[1]}`) {
-	await bench.run();
-	console.table(bench.table());
-}
+await runIfMain(import.meta.url, bench);
diff --git a/bench/index.mjs b/bench/index.mjs
index 2e3e7b2..9ec1a1a 100644
--- a/bench/index.mjs
+++ b/bench/index.mjs
@@ -6,21 +6,15 @@
 	groups and so that running a single suite locally is cheap.
 */
 
+import { runSuites } from "./helpers.mjs";
 import ignoredBench from "./ignored/ignored.bench.mjs";
 import reducePlanBench from "./reducePlan/reducePlan.bench.mjs";
 import linkResolverBench from "./LinkResolver/LinkResolver.bench.mjs";
 import watchpackBench from "./watchpack/normalizeOptions.bench.mjs";
 
-const suites = [
+await runSuites([
 	ignoredBench,
 	reducePlanBench,
 	linkResolverBench,
 	watchpackBench,
-];
-
-for (const suite of suites) {
-	process.stdout.write(`\n== ${suite.name ?? "bench"} ==\n`);
-	// eslint-disable-next-line no-await-in-loop
-	await suite.run();
-	console.table(suite.table());
-}
+]);
diff --git a/bench/reducePlan/reducePlan.bench.mjs b/bench/reducePlan/reducePlan.bench.mjs
index 180dfe6..8b5a10a 100644
--- a/bench/reducePlan/reducePlan.bench.mjs
+++ b/bench/reducePlan/reducePlan.bench.mjs
@@ -2,11 +2,9 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
-import { Bench } from "tinybench";
-import { withCodSpeed } from "@codspeed/tinybench-plugin";
-import { createRequire } from "module";
+import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
 
-const require = createRequire(import.meta.url);
+const require = moduleRequire(import.meta.url);
 const reducePlan = require("../../lib/reducePlan.js");
 
 const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
@@ -73,7 +71,7 @@ const veryDeepPlan = buildDeepPlan(80, 2);
 const flatPlan = buildFlatPlan(500);
 const flatLargePlan = buildFlatPlan(5000);
 
-const bench = withCodSpeed(new Bench({ name: "reducePlan", time: 200 }));
+const bench = createBench("reducePlan");
 
 bench
 	.add("under limit (no-op, n=50, limit=100)", () => {
@@ -115,7 +113,4 @@ bench
 
 export default bench;
 
-if (import.meta.url === `file://${process.argv[1]}`) {
-	await bench.run();
-	console.table(bench.table());
-}
+await runIfMain(import.meta.url, bench);
diff --git a/bench/watchpack/normalizeOptions.bench.mjs b/bench/watchpack/normalizeOptions.bench.mjs
index 7028907..ea6bbed 100644
--- a/bench/watchpack/normalizeOptions.bench.mjs
+++ b/bench/watchpack/normalizeOptions.bench.mjs
@@ -2,11 +2,9 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
-import { Bench } from "tinybench";
-import { withCodSpeed } from "@codspeed/tinybench-plugin";
-import { createRequire } from "module";
+import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
 
-const require = createRequire(import.meta.url);
+const require = moduleRequire(import.meta.url);
 const Watchpack = require("../../lib/index.js");
 
 // The Watchpack constructor normalizes options and installs a cache on the
@@ -33,9 +31,7 @@ const optionsWithLargeArray = {
 };
 const optionsWithFn = { ignored: (p) => p.includes("node_modules") };
 
-const bench = withCodSpeed(
-	new Bench({ name: "Watchpack construction", time: 200 }),
-);
+const bench = createBench("Watchpack construction");
 
 bench
 	.add("new Watchpack() with no ignored", () => {
@@ -70,7 +66,4 @@ bench
 
 export default bench;
 
-if (import.meta.url === `file://${process.argv[1]}`) {
-	await bench.run();
-	console.table(bench.table());
-}
+await runIfMain(import.meta.url, bench);

From b58fdcdadd527985fa3e755a004bf6b8b960a85a Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 16 Apr 2026 18:54:44 +0000
Subject: [PATCH 4/7] refactor(bench): restructure benchmarks to match
 enhanced-resolve layout

Rewrites the benchmark infrastructure to mirror webpack/enhanced-resolve's
approach: auto-discovered cases under bench/cases/<name>/index.bench.mjs
with a register(bench, ctx) default export, a single bench/run.mjs entry
point, and a local bench/with-codspeed.mjs bridge that talks to
@codspeed/core directly (the plugin breaks on tinybench v6 private fields).

- Replace @codspeed/tinybench-plugin with @codspeed/core.
- Add bench/run.mjs: auto-discovers ./cases/<name>/index.bench.mjs,
  honours BENCH_FILTER / positional CLI filter, prints a summary table,
  exits non-zero on task error.
- Add bench/with-codspeed.mjs: ported from enhanced-resolve; bench is
  returned untouched in disabled/walltime mode, run/runSync are replaced
  in simulation mode so each task is instrumented exactly once.
- Add bench/README.md documenting layout, filter usage, and case-writing
  guidelines.
- Rewrite each old bench file as a case directory with a register
  function. New cases:
  - ignored-match: per-shape matcher perf on POSIX paths
  - ignored-cross-platform: windows/mixed-separator/deep-path batches
  - link-resolver: cold + warm batches at three depths
  - reduce-plan-wide: small/medium/large/huge wide plans
  - reduce-plan-flat: all-siblings plans
  - reduce-plan-deep: deep/very-deep hierarchies
  - reduce-plan-fast-path: under-limit + barely-over scenarios
  - watchpack-construction: per-ignored-shape construction cost
- Replace bench/index.mjs and bench/helpers.mjs with the new layout.
- Replace the four bench:<name> npm scripts with a single `npm run
  benchmark` entry point that supports BENCH_FILTER; pass the V8 flags
  enhanced-resolve uses for CodSpeed-stable instruction counts.
- Update .github/workflows/codspeed.yml to run in simulation mode.

https://claude.ai/code/session_012uFpZRKDYdUbCfCEMtGQzN
---
 .github/workflows/codspeed.yml                |  28 ++-
 bench/LinkResolver/LinkResolver.bench.mjs     |  72 -------
 bench/README.md                               |  71 +++++++
 .../ignored-cross-platform/index.bench.mjs    |  90 +++++++++
 bench/cases/ignored-match/index.bench.mjs     |  89 +++++++++
 bench/cases/link-resolver/index.bench.mjs     |  73 +++++++
 bench/cases/reduce-plan-deep/index.bench.mjs  |  53 ++++++
 .../reduce-plan-fast-path/index.bench.mjs     |  55 ++++++
 bench/cases/reduce-plan-flat/index.bench.mjs  |  44 +++++
 bench/cases/reduce-plan-wide/index.bench.mjs  |  68 +++++++
 .../watchpack-construction/index.bench.mjs    |  67 +++++++
 bench/helpers.mjs                             |  64 -------
 bench/ignored/ignored.bench.mjs               | 125 ------------
 bench/index.mjs                               |  20 --
 bench/reducePlan/reducePlan.bench.mjs         | 116 ------------
 bench/run.mjs                                 | 121 ++++++++++++
 bench/watchpack/normalizeOptions.bench.mjs    |  69 -------
 bench/with-codspeed.mjs                       | 179 ++++++++++++++++++
 package-lock.json                             |  26 +--
 package.json                                  |   8 +-
 20 files changed, 931 insertions(+), 507 deletions(-)
 delete mode 100644 bench/LinkResolver/LinkResolver.bench.mjs
 create mode 100644 bench/README.md
 create mode 100644 bench/cases/ignored-cross-platform/index.bench.mjs
 create mode 100644 bench/cases/ignored-match/index.bench.mjs
 create mode 100644 bench/cases/link-resolver/index.bench.mjs
 create mode 100644 bench/cases/reduce-plan-deep/index.bench.mjs
 create mode 100644 bench/cases/reduce-plan-fast-path/index.bench.mjs
 create mode 100644 bench/cases/reduce-plan-flat/index.bench.mjs
 create mode 100644 bench/cases/reduce-plan-wide/index.bench.mjs
 create mode 100644 bench/cases/watchpack-construction/index.bench.mjs
 delete mode 100644 bench/helpers.mjs
 delete mode 100644 bench/ignored/ignored.bench.mjs
 delete mode 100644 bench/index.mjs
 delete mode 100644 bench/reducePlan/reducePlan.bench.mjs
 create mode 100644 bench/run.mjs
 delete mode 100644 bench/watchpack/normalizeOptions.bench.mjs
 create mode 100644 bench/with-codspeed.mjs

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 4b9a8da..9c6ba66 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -1,19 +1,26 @@
-name: CodSpeed
+name: Benchmarks
 
 on:
   push:
-    branches:
-      - main
+    branches: [main]
   pull_request:
-    branches:
-      - main
-  # Allow running on demand from the Actions tab.
+    branches: [main]
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  # Required for OIDC authentication with CodSpeed.
+  id-token: write
+
 jobs:
-  benchmarks:
-    name: Run benchmarks
+  benchmark:
     runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
@@ -28,7 +35,8 @@ jobs:
       - run: npm ci
 
       - name: Run benchmarks
-        uses: CodSpeedHQ/action@v4
+        uses: CodSpeedHQ/action@fa0c9b1770f933c1bc025c83a9b42946b102f4e6 # v4.10.4
         with:
-          run: npm run bench
+          run: npm run benchmark
+          mode: "simulation"
           token: ${{ secrets.CODSPEED_TOKEN }}
diff --git a/bench/LinkResolver/LinkResolver.bench.mjs b/bench/LinkResolver/LinkResolver.bench.mjs
deleted file mode 100644
index d49ea15..0000000
--- a/bench/LinkResolver/LinkResolver.bench.mjs
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
-
-const require = moduleRequire(import.meta.url);
-const LinkResolver = require("../../lib/LinkResolver.js");
-
-// LinkResolver does real sync filesystem work via fs.readlinkSync.
-// To keep benchmarks deterministic and instrumentation-friendly,
-// we measure the path-walking + cache logic against paths that do not exist
-// (readlinkSync throws ENOENT which is handled silently) and the cache fast
-// path which is the most common case in real watch scenarios.
-
-const SEP = process.platform === "win32" ? "\\" : "/";
-const ROOT =
-	process.platform === "win32" ? "C:\\nonexistent_bench" : "/nonexistent_bench";
-
-/**
- * @param {number} depth path depth
- * @returns {string} path
- */
-const makePath = (depth) => {
-	let p = ROOT;
-	for (let i = 0; i < depth; i++) p += `${SEP}level${i}`;
-	return p;
-};
-
-const shallowPaths = Array.from(
-	{ length: 100 },
-	(_, i) => `${ROOT}${SEP}file${i}`,
-);
-const mediumPaths = Array.from(
-	{ length: 100 },
-	(_, i) => `${makePath(5)}${SEP}file${i}`,
-);
-const deepPaths = Array.from(
-	{ length: 50 },
-	(_, i) => `${makePath(15)}${SEP}file${i}`,
-);
-
-const warmResolver = new LinkResolver();
-for (const p of shallowPaths) warmResolver.resolve(p);
-for (const p of mediumPaths) warmResolver.resolve(p);
-for (const p of deepPaths) warmResolver.resolve(p);
-
-const bench = createBench("LinkResolver");
-
-bench
-	.add("cold resolve shallow paths (depth=1, n=100)", () => {
-		const resolver = new LinkResolver();
-		for (const p of shallowPaths) resolver.resolve(p);
-	})
-	.add("cold resolve medium paths (depth=5, n=100)", () => {
-		const resolver = new LinkResolver();
-		for (const p of mediumPaths) resolver.resolve(p);
-	})
-	.add("cold resolve deep paths (depth=15, n=50)", () => {
-		const resolver = new LinkResolver();
-		for (const p of deepPaths) resolver.resolve(p);
-	})
-	.add("warm resolve shallow paths (cache hit, n=100)", () => {
-		for (const p of shallowPaths) warmResolver.resolve(p);
-	})
-	.add("warm resolve deep paths (cache hit, n=50)", () => {
-		for (const p of deepPaths) warmResolver.resolve(p);
-	});
-
-export default bench;
-
-await runIfMain(import.meta.url, bench);
diff --git a/bench/README.md b/bench/README.md
new file mode 100644
index 0000000..5d26e63
--- /dev/null
+++ b/bench/README.md
@@ -0,0 +1,71 @@
+# Benchmarks
+
+This directory holds watchpack's performance benchmarks. The layout mirrors
+[webpack/enhanced-resolve's `benchmark/`](https://github.com/webpack/enhanced-resolve/tree/main/benchmark):
+each scenario lives under `cases/<name>/index.bench.mjs`, `run.mjs` discovers
+every case and runs it through [tinybench](https://github.com/tinylibs/tinybench),
+and the same entry point works both locally (wall-clock) and under
+[CodSpeed](https://codspeed.io/) (instruction-count simulation) via the
+`with-codspeed.mjs` bridge.
+
+## Running
+
+```sh
+# Run every case
+npm run benchmark
+
+# Run only cases whose directory name contains "ignored"
+BENCH_FILTER=ignored npm run benchmark
+#  - or, equivalently -
+npm run benchmark -- ignored
+```
+
+The output is a table of `ops/s`, mean latency, p99 latency, RME, and
+sample count per registered task. When run under `CodSpeedHQ/action` the
+bridge switches to instrumentation mode automatically.
+
+## Layout
+
+```
+bench/
+├── README.md
+├── run.mjs             # entry: discovers cases, runs them, prints a table
+├── with-codspeed.mjs   # tinybench <-> @codspeed/core bridge
+└── cases/
+    └── <case-name>/
+        └── index.bench.mjs
+```
+
+Each `index.bench.mjs` exports a default `register(bench, ctx)` function
+that calls `bench.add(name, fn)` one or more times. The `ctx` argument is
+`{ caseName, caseDir, fixtureDir }`; `fixtureDir` points at
+`cases/<name>/fixture/` (the directory is optional — only create it if you
+need a real on-disk tree).
+
+## Writing a case
+
+1. Create `bench/cases/<name>/index.bench.mjs`.
+2. Default-export a `register` function.
+3. Pre-build expensive fixtures **outside** the benchmark callback so only
+   the hot path is measured.
+4. Each `bench.add` body should loop over a fixed batch of inputs so the
+   measurement window sees enough work to be stable (tens of microseconds
+   minimum).
+5. Avoid any non-determinism — use fixed request lists, no `Math.random`.
+6. Focus one case on one scenario. If you need a materially different
+   shape (warm vs. cold cache, POSIX vs. Windows paths), prefer a new case
+   directory over piling `bench.add` calls into an existing one.
+
+## CodSpeed
+
+`bench/run.mjs` wraps the `Bench` with `withCodSpeed()`. When `CODSPEED_*`
+env vars are absent the wrapper returns the bench untouched and tinybench's
+built-in timing is used. Under `CodSpeedHQ/action` with
+`mode: "simulation"` the wrapper overrides `bench.run` to call the
+instrumentation hooks once per task, which produces reproducible
+instruction-count measurements independent of the runner's load.
+
+The `@codspeed/tinybench-plugin` package is intentionally not used here:
+it reads private tinybench v6 Task fields and breaks in simulation mode.
+Both webpack and enhanced-resolve ran into the same issue and wrote their
+own bridges; `with-codspeed.mjs` is ported from enhanced-resolve's.
diff --git a/bench/cases/ignored-cross-platform/index.bench.mjs b/bench/cases/ignored-cross-platform/index.bench.mjs
new file mode 100644
index 0000000..52f21b0
--- /dev/null
+++ b/bench/cases/ignored-cross-platform/index.bench.mjs
@@ -0,0 +1,90 @@
+/*
+ * ignored-cross-platform
+ *
+ * Stress-tests the separator-normalization path in the `ignored` matcher.
+ * The matcher must handle native Windows paths (with backslashes), paths
+ * that have already been normalized to POSIX, and mixed bags produced by
+ * cross-platform tools. This case isolates those scenarios from the plain
+ * POSIX batch measured by `ignored-match` so the backslash-heavy code path
+ * has its own CodSpeed trend line.
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const Watchpack = require("../../../lib/index.js");
+
+const UNIX_PATHS = [
+	"/home/user/project/src/index.js",
+	"/home/user/project/src/components/App.jsx",
+	"/home/user/project/node_modules/react/index.js",
+	"/home/user/project/dist/bundle.js",
+	"/home/user/project/.git/HEAD",
+	"/home/user/project/coverage/lcov.info",
+	"/home/user/project/src/utils/helpers.ts",
+	"/home/user/project/test/fixtures/a.js",
+	"/home/user/project/README.md",
+	"/home/user/project/package.json",
+];
+
+const WINDOWS_PATHS = UNIX_PATHS.map((p) => p.replace(/\//g, "\\"));
+const MIXED_PATHS = UNIX_PATHS.map((p, i) =>
+	i % 2 === 0 ? p : p.replace(/\//g, "\\"),
+);
+
+// Simulates a monorepo deep-path batch: each path has ~17 segments so the
+// regex has to scan a long string before committing to match/no-match.
+const DEEP_PATHS = Array.from({ length: 10 }, (_, i) => {
+	const segments = Array.from({ length: 15 }, (_, j) => `level${j}`);
+	segments.push(i === 3 ? "node_modules" : `leaf${i}`);
+	segments.push("index.js");
+	return `/${segments.join("/")}`;
+});
+
+/**
+ * @param {import("../../../lib/index").WatchOptions} options
+ * @returns {(item: string) => boolean}
+ */
+const buildIgnored = (options) => new Watchpack(options).watcherOptions.ignored;
+
+const LARGE_ARRAY_IGNORED = [
+	"**/node_modules",
+	"**/.git",
+	"**/dist",
+	"**/build",
+	"**/coverage",
+	"**/.cache",
+	"**/.next",
+	"**/.nuxt",
+	"**/tmp",
+	"**/*.log",
+];
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	const regexpMatcher = buildIgnored({
+		ignored: /node_modules|\.git|dist|coverage/,
+	});
+	const arrayMatcher = buildIgnored({ ignored: LARGE_ARRAY_IGNORED });
+
+	bench.add("ignored-cross-platform: regex against windows paths", () => {
+		for (const p of WINDOWS_PATHS) regexpMatcher(p);
+	});
+	bench.add("ignored-cross-platform: regex against mixed separators", () => {
+		for (const p of MIXED_PATHS) regexpMatcher(p);
+	});
+	bench.add("ignored-cross-platform: regex against deep posix paths", () => {
+		for (const p of DEEP_PATHS) regexpMatcher(p);
+	});
+	bench.add("ignored-cross-platform: array[10] against windows paths", () => {
+		for (const p of WINDOWS_PATHS) arrayMatcher(p);
+	});
+	bench.add(
+		"ignored-cross-platform: array[10] against deep posix paths",
+		() => {
+			for (const p of DEEP_PATHS) arrayMatcher(p);
+		},
+	);
+}
diff --git a/bench/cases/ignored-match/index.bench.mjs b/bench/cases/ignored-match/index.bench.mjs
new file mode 100644
index 0000000..72bf21a
--- /dev/null
+++ b/bench/cases/ignored-match/index.bench.mjs
@@ -0,0 +1,89 @@
+/*
+ * ignored-match
+ *
+ * Exercises the `ignored` matcher against a realistic POSIX path batch for
+ * every supported option shape (regex, glob string, short/long array, plain
+ * predicate, and the "no ignored option" no-op fast path). The matcher is
+ * what webpack hits per file for every watched entry, so the shape of this
+ * batch dominates per-rebuild time in large projects.
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const Watchpack = require("../../../lib/index.js");
+
+const UNIX_PATHS = [
+	"/home/user/project/src/index.js",
+	"/home/user/project/src/components/App.jsx",
+	"/home/user/project/node_modules/react/index.js",
+	"/home/user/project/dist/bundle.js",
+	"/home/user/project/.git/HEAD",
+	"/home/user/project/coverage/lcov.info",
+	"/home/user/project/src/utils/helpers.ts",
+	"/home/user/project/test/fixtures/a.js",
+	"/home/user/project/README.md",
+	"/home/user/project/package.json",
+];
+
+/**
+ * Reach into a Watchpack instance to get at the normalized matcher without
+ * duplicating the option-compilation logic.
+ * @param {import("../../../lib/index").WatchOptions} options
+ * @returns {(item: string) => boolean}
+ */
+const buildIgnored = (options) => new Watchpack(options).watcherOptions.ignored;
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	const noneMatcher = buildIgnored({});
+	const regexpMatcher = buildIgnored({
+		ignored: /node_modules|\.git|dist|coverage/,
+	});
+	const stringMatcher = buildIgnored({ ignored: "**/node_modules" });
+	const singletonArrayMatcher = buildIgnored({ ignored: ["**/node_modules"] });
+	const smallArrayMatcher = buildIgnored({
+		ignored: ["**/node_modules", "**/.git"],
+	});
+	const largeArrayMatcher = buildIgnored({
+		ignored: [
+			"**/node_modules",
+			"**/.git",
+			"**/dist",
+			"**/build",
+			"**/coverage",
+			"**/.cache",
+			"**/.next",
+			"**/.nuxt",
+			"**/tmp",
+			"**/*.log",
+		],
+	});
+	const functionMatcher = buildIgnored({
+		ignored: (p) => p.includes("node_modules") || p.includes(".git"),
+	});
+
+	bench.add("ignored-match: no ignored option (noop fast path)", () => {
+		for (const p of UNIX_PATHS) noneMatcher(p);
+	});
+	bench.add("ignored-match: regex matcher", () => {
+		for (const p of UNIX_PATHS) regexpMatcher(p);
+	});
+	bench.add("ignored-match: glob string matcher", () => {
+		for (const p of UNIX_PATHS) stringMatcher(p);
+	});
+	bench.add("ignored-match: array[1] matcher", () => {
+		for (const p of UNIX_PATHS) singletonArrayMatcher(p);
+	});
+	bench.add("ignored-match: array[2] matcher", () => {
+		for (const p of UNIX_PATHS) smallArrayMatcher(p);
+	});
+	bench.add("ignored-match: array[10] matcher", () => {
+		for (const p of UNIX_PATHS) largeArrayMatcher(p);
+	});
+	bench.add("ignored-match: function matcher", () => {
+		for (const p of UNIX_PATHS) functionMatcher(p);
+	});
+}
diff --git a/bench/cases/link-resolver/index.bench.mjs b/bench/cases/link-resolver/index.bench.mjs
new file mode 100644
index 0000000..7ff5d03
--- /dev/null
+++ b/bench/cases/link-resolver/index.bench.mjs
@@ -0,0 +1,73 @@
+/*
+ * link-resolver
+ *
+ * LinkResolver resolves directory + file paths while expanding any symlinks
+ * along the way. Webpack hits it on every watched entry before asking the
+ * platform's fs.watch, so both the cold (first seen) and warm (cache hit)
+ * paths matter: the former bounds worst-case rebuild latency, the latter
+ * bounds the per-file cost of the steady state.
+ *
+ * To keep the benchmark deterministic we aim the resolver at a path that
+ * does not exist. readlinkSync throws ENOENT, LinkResolver catches it
+ * silently and walks its cache / parent chain exactly like it would for a
+ * real path — without any filesystem side effects that would make CodSpeed
+ * instrumentation noisy.
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const LinkResolver = require("../../../lib/LinkResolver.js");
+
+const SEP = process.platform === "win32" ? "\\" : "/";
+const ROOT =
+	process.platform === "win32" ? "C:\\nonexistent_bench" : "/nonexistent_bench";
+
+const makePath = (depth) => {
+	let p = ROOT;
+	for (let i = 0; i < depth; i++) p += `${SEP}level${i}`;
+	return p;
+};
+
+const shallowPaths = Array.from(
+	{ length: 100 },
+	(_, i) => `${ROOT}${SEP}file${i}`,
+);
+const mediumPaths = Array.from(
+	{ length: 100 },
+	(_, i) => `${makePath(5)}${SEP}file${i}`,
+);
+const deepPaths = Array.from(
+	{ length: 50 },
+	(_, i) => `${makePath(15)}${SEP}file${i}`,
+);
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	// Pre-populated resolver for the warm/cache-hit measurements.
+	const warmResolver = new LinkResolver();
+	for (const p of shallowPaths) warmResolver.resolve(p);
+	for (const p of mediumPaths) warmResolver.resolve(p);
+	for (const p of deepPaths) warmResolver.resolve(p);
+
+	bench.add("link-resolver: cold shallow batch (depth=1, n=100)", () => {
+		const resolver = new LinkResolver();
+		for (const p of shallowPaths) resolver.resolve(p);
+	});
+	bench.add("link-resolver: cold medium batch (depth=5, n=100)", () => {
+		const resolver = new LinkResolver();
+		for (const p of mediumPaths) resolver.resolve(p);
+	});
+	bench.add("link-resolver: cold deep batch (depth=15, n=50)", () => {
+		const resolver = new LinkResolver();
+		for (const p of deepPaths) resolver.resolve(p);
+	});
+	bench.add("link-resolver: warm shallow batch (cache hit, n=100)", () => {
+		for (const p of shallowPaths) warmResolver.resolve(p);
+	});
+	bench.add("link-resolver: warm deep batch (cache hit, n=50)", () => {
+		for (const p of deepPaths) warmResolver.resolve(p);
+	});
+}
diff --git a/bench/cases/reduce-plan-deep/index.bench.mjs b/bench/cases/reduce-plan-deep/index.bench.mjs
new file mode 100644
index 0000000..d212f10
--- /dev/null
+++ b/bench/cases/reduce-plan-deep/index.bench.mjs
@@ -0,0 +1,53 @@
+/*
+ * reduce-plan-deep
+ *
+ * Deeply nested path plans exercise the parent-chain walk in reducePlan's
+ * tree-building pass (each leaf bubbles its entry count up an arbitrarily
+ * long ancestor list) and the subtree-deactivation walk during reduction
+ * (merging near the root has to mark every descendant inactive).
+ *
+ * `depth=30, leaves=3` approximates a monorepo with a handful of files at
+ * every level; `depth=80, leaves=2` is a synthetic worst case with a long
+ * spine and very few siblings per rung.
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const reducePlan = require("../../../lib/reducePlan.js");
+
+const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
+const SEP = process.platform === "win32" ? "\\" : "/";
+
+/**
+ * @param {number} depth directory depth
+ * @param {number} leaves leaves per level
+ * @returns {Map<string, string>} plan
+ */
+const buildDeepPlan = (depth, leaves) => {
+	const plan = new Map();
+	let i = 0;
+	const walk = (prefix, level) => {
+		for (let l = 0; l < leaves; l++) {
+			plan.set(`${prefix}${SEP}file${i}`, `v${i++}`);
+		}
+		if (level < depth) walk(`${prefix}${SEP}sub${level}`, level + 1);
+	};
+	walk(ROOT, 0);
+	return plan;
+};
+
+const deepPlan = buildDeepPlan(30, 3);
+const veryDeepPlan = buildDeepPlan(80, 2);
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	bench.add("reduce-plan-deep: depth=30, leaves=3, limit=20", () => {
+		reducePlan(deepPlan, 20);
+	});
+	bench.add("reduce-plan-deep: depth=80, leaves=2, limit=40", () => {
+		reducePlan(veryDeepPlan, 40);
+	});
+}
diff --git a/bench/cases/reduce-plan-fast-path/index.bench.mjs b/bench/cases/reduce-plan-fast-path/index.bench.mjs
new file mode 100644
index 0000000..979d2f0
--- /dev/null
+++ b/bench/cases/reduce-plan-fast-path/index.bench.mjs
@@ -0,0 +1,55 @@
+/*
+ * reduce-plan-fast-path
+ *
+ * Measures the cheap paths through reducePlan: plans that are already under
+ * the limit (no reduction needed at all) and plans that are only slightly
+ * over the limit (the while loop runs a handful of times). These should be
+ * dominated by tree construction + the final "write down new plan" pass,
+ * not by the selection loop.
+ *
+ * Keeping this isolated from the heavy cases means a regression in the
+ * setup cost (e.g. accidentally quadratic tree building) shows up on its
+ * own trend line instead of hiding under a 10ms huge-plan benchmark.
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const reducePlan = require("../../../lib/reducePlan.js");
+
+const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
+const SEP = process.platform === "win32" ? "\\" : "/";
+
+/**
+ * @param {number} count number of leaf targets
+ * @param {number} width branching factor per directory
+ * @returns {Map<string, string>} plan
+ */
+const buildWidePlan = (count, width) => {
+	const plan = new Map();
+	let i = 0;
+	let dir = 0;
+	while (i < count) {
+		const group = `${ROOT}${SEP}group${dir}`;
+		for (let j = 0; j < width && i < count; j++, i++) {
+			plan.set(`${group}${SEP}file${i}`, `v${i}`);
+		}
+		dir++;
+	}
+	return plan;
+};
+
+const smallPlan = buildWidePlan(50, 10);
+const mediumPlan = buildWidePlan(500, 20);
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	bench.add("reduce-plan-fast-path: under limit (n=50, limit=100)", () => {
+		reducePlan(smallPlan, 100);
+	});
+	bench.add("reduce-plan-fast-path: barely over (n=500, limit=499)", () => {
+		reducePlan(mediumPlan, 499);
+	});
+}
diff --git a/bench/cases/reduce-plan-flat/index.bench.mjs b/bench/cases/reduce-plan-flat/index.bench.mjs
new file mode 100644
index 0000000..2d7ab4c
--- /dev/null
+++ b/bench/cases/reduce-plan-flat/index.bench.mjs
@@ -0,0 +1,44 @@
+/*
+ * reduce-plan-flat
+ *
+ * Lots of sibling entries under a single directory: every leaf shares the
+ * same parent, so the tree is one level deep and the candidate-selection
+ * loop only has a single viable merge target per round. This distribution
+ * shows up in projects that watch many files in one folder (e.g. a single
+ * "pages" or "generated" directory with hundreds of entries).
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const reducePlan = require("../../../lib/reducePlan.js");
+
+const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
+const SEP = process.platform === "win32" ? "\\" : "/";
+
+/**
+ * @param {number} count number of targets
+ * @returns {Map<string, string>} plan
+ */
+const buildFlatPlan = (count) => {
+	const plan = new Map();
+	for (let i = 0; i < count; i++) {
+		plan.set(`${ROOT}${SEP}file${i}`, `v${i}`);
+	}
+	return plan;
+};
+
+const flatMediumPlan = buildFlatPlan(500);
+const flatLargePlan = buildFlatPlan(5000);
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	bench.add("reduce-plan-flat: n=500 in one dir, limit=50", () => {
+		reducePlan(flatMediumPlan, 50);
+	});
+	bench.add("reduce-plan-flat: n=5000 in one dir, limit=100", () => {
+		reducePlan(flatLargePlan, 100);
+	});
+}
diff --git a/bench/cases/reduce-plan-wide/index.bench.mjs b/bench/cases/reduce-plan-wide/index.bench.mjs
new file mode 100644
index 0000000..d943560
--- /dev/null
+++ b/bench/cases/reduce-plan-wide/index.bench.mjs
@@ -0,0 +1,68 @@
+/*
+ * reduce-plan-wide
+ *
+ * Exercises reducePlan on "wide" plans — lots of sibling leaves bucketed
+ * under shared parent directories. This is the distribution webpack creates
+ * when many watchers share a root but fan out into sub-trees, and it's the
+ * stress pattern for the selection loop: every iteration of the outer
+ * `while (currentCount > limit)` must scan the candidate set to find the
+ * best node to merge.
+ *
+ * Three magnitudes: small (50), medium (500), large (2000), huge (10000).
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const reducePlan = require("../../../lib/reducePlan.js");
+
+const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
+const SEP = process.platform === "win32" ? "\\" : "/";
+
+/**
+ * @param {number} count number of leaf targets
+ * @param {number} width branching factor per directory
+ * @returns {Map<string, string>} plan
+ */
+const buildWidePlan = (count, width) => {
+	const plan = new Map();
+	let i = 0;
+	let dir = 0;
+	while (i < count) {
+		const group = `${ROOT}${SEP}group${dir}`;
+		for (let j = 0; j < width && i < count; j++, i++) {
+			plan.set(`${group}${SEP}file${i}`, `v${i}`);
+		}
+		dir++;
+	}
+	return plan;
+};
+
+const smallPlan = buildWidePlan(50, 10);
+const mediumPlan = buildWidePlan(500, 20);
+const largePlan = buildWidePlan(2000, 25);
+const hugePlan = buildWidePlan(10000, 40);
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	bench.add("reduce-plan-wide: small plan (n=50, limit=10)", () => {
+		reducePlan(smallPlan, 10);
+	});
+	bench.add("reduce-plan-wide: medium plan (n=500, limit=50)", () => {
+		reducePlan(mediumPlan, 50);
+	});
+	bench.add("reduce-plan-wide: medium light (n=500, limit=400)", () => {
+		reducePlan(mediumPlan, 400);
+	});
+	bench.add("reduce-plan-wide: large plan (n=2000, limit=100)", () => {
+		reducePlan(largePlan, 100);
+	});
+	bench.add("reduce-plan-wide: large aggressive (n=2000, limit=10)", () => {
+		reducePlan(largePlan, 10);
+	});
+	bench.add("reduce-plan-wide: huge plan (n=10000, limit=500)", () => {
+		reducePlan(hugePlan, 500);
+	});
+}
diff --git a/bench/cases/watchpack-construction/index.bench.mjs b/bench/cases/watchpack-construction/index.bench.mjs
new file mode 100644
index 0000000..2dc0c2b
--- /dev/null
+++ b/bench/cases/watchpack-construction/index.bench.mjs
@@ -0,0 +1,67 @@
+/*
+ * watchpack-construction
+ *
+ * Webpack creates and tears down a Watchpack instance at module boundaries
+ * and on every dev-server restart. The constructor compiles the `ignored`
+ * matcher, installs it on a WeakMap-keyed options cache, and wires up the
+ * internal `WatcherManager`. This case measures the construction cost for
+ * each supported `ignored` option shape so any regression in that setup
+ * path surfaces before it reaches webpack users.
+ *
+ * `.close()` is invoked after every construction to keep the outer test
+ * process from leaking timers even though no watchers have been attached.
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const Watchpack = require("../../../lib/index.js");
+
+const optionsNone = {};
+const optionsWithRegExp = { ignored: /node_modules|\.git/ };
+const optionsWithString = { ignored: "**/node_modules" };
+const optionsWithSmallArray = { ignored: ["**/node_modules", "**/.git"] };
+const optionsWithLargeArray = {
+	ignored: [
+		"**/node_modules",
+		"**/.git",
+		"**/dist",
+		"**/build",
+		"**/coverage",
+		"**/.cache",
+		"**/.next",
+		"**/.nuxt",
+		"**/tmp",
+		"**/*.log",
+	],
+};
+const optionsWithFn = { ignored: (p) => p.includes("node_modules") };
+
+/**
+ * @param {import('tinybench').Bench} bench
+ */
+export default function register(bench) {
+	bench.add("watchpack-construction: no ignored option", () => {
+		new Watchpack(optionsNone).close();
+	});
+	bench.add("watchpack-construction: regex ignored", () => {
+		new Watchpack(optionsWithRegExp).close();
+	});
+	bench.add("watchpack-construction: glob string ignored", () => {
+		new Watchpack(optionsWithString).close();
+	});
+	bench.add("watchpack-construction: array[2] ignored", () => {
+		new Watchpack(optionsWithSmallArray).close();
+	});
+	bench.add("watchpack-construction: array[10] ignored", () => {
+		new Watchpack(optionsWithLargeArray).close();
+	});
+	bench.add("watchpack-construction: function ignored", () => {
+		new Watchpack(optionsWithFn).close();
+	});
+	bench.add("watchpack-construction: cached options (WeakMap hit)", () => {
+		// Same options object every iteration exercises the WeakMap cache
+		// installed on the options by `cachedNormalizeOptions`.
+		new Watchpack(optionsWithLargeArray).close();
+	});
+}
diff --git a/bench/helpers.mjs b/bench/helpers.mjs
deleted file mode 100644
index 3423354..0000000
--- a/bench/helpers.mjs
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-
-	Shared plumbing for the tinybench suites shipped under bench/. Each suite
-	file declares its cases and exports the resulting Bench; everything else
-	(CodSpeed wiring, require resolution, standalone entrypoint behaviour,
-	aggregate runner) lives here so the per-suite files look as close as
-	possible to "just the benchmark cases".
-*/
-
-import { Bench } from "tinybench";
-import { withCodSpeed } from "@codspeed/tinybench-plugin";
-import { createRequire } from "module";
-import { pathToFileURL } from "url";
-
-// Keep the measurement window in one place so every suite reports on the
-// same time budget and CodSpeed sees comparable sample counts between runs.
-const BENCH_TIME_MS = 200;
-
-/**
- * Create a CodSpeed-wrapped Bench with our standard options.
- * @param {string} name suite name (shown in CodSpeed and in the aggregate
- * runner's section headers)
- * @returns {Bench} bench
- */
-export const createBench = (name) =>
-	withCodSpeed(new Bench({ name, time: BENCH_TIME_MS }));
-
-/**
- * Anchor a CommonJS `require` to the given ESM module. Lets bench files
- * pull in watchpack's CJS lib modules with the same relative paths they
- * would use in a .js sibling.
- * @param {string} importMetaUrl caller's import.meta.url
- * @returns {NodeRequire} require
- */
-export const moduleRequire = (importMetaUrl) => createRequire(importMetaUrl);
-
-/**
- * Run the suite and print its table when the bench file is invoked
- * directly (e.g. `npm run bench:<name>`). No-op when the file is only
- * imported by the aggregate runner.
- * @param {string} importMetaUrl caller's import.meta.url
- * @param {Bench} bench bench to run
- */
-export const runIfMain = async (importMetaUrl, bench) => {
-	if (!process.argv[1]) return;
-	if (importMetaUrl !== pathToFileURL(process.argv[1]).href) return;
-	await bench.run();
-	console.table(bench.table());
-};
-
-/**
- * Run every supplied suite sequentially and print a labeled table per suite.
- * Used by bench/index.mjs to produce a single aggregate report.
- * @param {Bench[]} suites suites
- */
-export const runSuites = async (suites) => {
-	for (const suite of suites) {
-		process.stdout.write(`\n== ${suite.name ?? "bench"} ==\n`);
-		// eslint-disable-next-line no-await-in-loop
-		await suite.run();
-		console.table(suite.table());
-	}
-};
diff --git a/bench/ignored/ignored.bench.mjs b/bench/ignored/ignored.bench.mjs
deleted file mode 100644
index be5565b..0000000
--- a/bench/ignored/ignored.bench.mjs
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
-
-const require = moduleRequire(import.meta.url);
-// Require the internal helpers via the package entry to avoid duplication.
-// We re-implement the call paths through the public Watchpack constructor
-// which normalizes ignored exactly once per options object.
-const Watchpack = require("../../lib/index.js");
-
-/**
- * Build a normalized ignored function using Watchpack's public API so that
- * we benchmark the same code path users exercise in practice.
- * @param {import("../../lib/index").WatchOptions} options
- * @returns {(item: string) => boolean}
- */
-const buildIgnored = (options) => {
-	const wp = new Watchpack(options);
-	return wp.watcherOptions.ignored;
-};
-
-const UNIX_PATHS = [
-	"/home/user/project/src/index.js",
-	"/home/user/project/src/components/App.jsx",
-	"/home/user/project/node_modules/react/index.js",
-	"/home/user/project/dist/bundle.js",
-	"/home/user/project/.git/HEAD",
-	"/home/user/project/coverage/lcov.info",
-	"/home/user/project/src/utils/helpers.ts",
-	"/home/user/project/test/fixtures/a.js",
-	"/home/user/project/README.md",
-	"/home/user/project/package.json",
-];
-
-const WINDOWS_PATHS = UNIX_PATHS.map((p) => p.replace(/\//g, "\\"));
-
-// Mixed unix/windows paths simulate a cross-platform tool (for example a test
-// runner) that normalises some paths to posix before passing them in while
-// leaving others in native form.
-const MIXED_PATHS = UNIX_PATHS.map((p, i) =>
-	i % 2 === 0 ? p : p.replace(/\//g, "\\"),
-);
-
-// Deep monorepo style paths: hundreds of segments, node_modules sprinkled
-// deep. Benchmarks the worst-case scan distance for the regex matcher.
-const DEEP_PATHS = Array.from({ length: 10 }, (_, i) => {
-	const segments = Array.from({ length: 15 }, (_, j) => `level${j}`);
-	segments.push(i === 3 ? "node_modules" : `leaf${i}`);
-	segments.push("index.js");
-	return `/${segments.join("/")}`;
-});
-
-const bench = createBench("ignored");
-
-const noneMatcher = buildIgnored({});
-const regexpMatcher = buildIgnored({
-	ignored: /node_modules|\.git|dist|coverage/,
-});
-const stringMatcher = buildIgnored({ ignored: "**/node_modules" });
-const smallArrayMatcher = buildIgnored({
-	ignored: ["**/node_modules", "**/.git"],
-});
-const largeArrayMatcher = buildIgnored({
-	ignored: [
-		"**/node_modules",
-		"**/.git",
-		"**/dist",
-		"**/build",
-		"**/coverage",
-		"**/.cache",
-		"**/.next",
-		"**/.nuxt",
-		"**/tmp",
-		"**/*.log",
-	],
-});
-const functionMatcher = buildIgnored({
-	ignored: (p) => p.includes("node_modules") || p.includes(".git"),
-});
-
-const singletonArrayMatcher = buildIgnored({ ignored: ["**/node_modules"] });
-
-bench
-	.add("ignored=undefined (noop) unix paths", () => {
-		for (const p of UNIX_PATHS) noneMatcher(p);
-	})
-	.add("ignored=regexp unix paths", () => {
-		for (const p of UNIX_PATHS) regexpMatcher(p);
-	})
-	.add("ignored=regexp windows paths", () => {
-		for (const p of WINDOWS_PATHS) regexpMatcher(p);
-	})
-	.add("ignored=regexp mixed-separator paths", () => {
-		for (const p of MIXED_PATHS) regexpMatcher(p);
-	})
-	.add("ignored=regexp deep paths", () => {
-		for (const p of DEEP_PATHS) regexpMatcher(p);
-	})
-	.add("ignored=string unix paths", () => {
-		for (const p of UNIX_PATHS) stringMatcher(p);
-	})
-	.add("ignored=array[1] unix paths", () => {
-		for (const p of UNIX_PATHS) singletonArrayMatcher(p);
-	})
-	.add("ignored=array[2] unix paths", () => {
-		for (const p of UNIX_PATHS) smallArrayMatcher(p);
-	})
-	.add("ignored=array[10] unix paths", () => {
-		for (const p of UNIX_PATHS) largeArrayMatcher(p);
-	})
-	.add("ignored=array[10] windows paths", () => {
-		for (const p of WINDOWS_PATHS) largeArrayMatcher(p);
-	})
-	.add("ignored=array[10] deep paths", () => {
-		for (const p of DEEP_PATHS) largeArrayMatcher(p);
-	})
-	.add("ignored=function unix paths", () => {
-		for (const p of UNIX_PATHS) functionMatcher(p);
-	});
-
-export default bench;
-
-await runIfMain(import.meta.url, bench);
diff --git a/bench/index.mjs b/bench/index.mjs
deleted file mode 100644
index 9ec1a1a..0000000
--- a/bench/index.mjs
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-
-	Runs every tinybench suite shipped in this repository. Suites are split
-	by the lib/ module they exercise so CodSpeed reports them as independent
-	groups and so that running a single suite locally is cheap.
-*/
-
-import { runSuites } from "./helpers.mjs";
-import ignoredBench from "./ignored/ignored.bench.mjs";
-import reducePlanBench from "./reducePlan/reducePlan.bench.mjs";
-import linkResolverBench from "./LinkResolver/LinkResolver.bench.mjs";
-import watchpackBench from "./watchpack/normalizeOptions.bench.mjs";
-
-await runSuites([
-	ignoredBench,
-	reducePlanBench,
-	linkResolverBench,
-	watchpackBench,
-]);
diff --git a/bench/reducePlan/reducePlan.bench.mjs b/bench/reducePlan/reducePlan.bench.mjs
deleted file mode 100644
index 8b5a10a..0000000
--- a/bench/reducePlan/reducePlan.bench.mjs
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
-
-const require = moduleRequire(import.meta.url);
-const reducePlan = require("../../lib/reducePlan.js");
-
-const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
-const SEP = process.platform === "win32" ? "\\" : "/";
-
-/**
- * @param {number} count number of leaf targets
- * @param {number} width branching factor per directory
- * @returns {Map<string, string>} plan
- */
-const buildWidePlan = (count, width) => {
-	const plan = new Map();
-	let i = 0;
-	let dir = 0;
-	while (i < count) {
-		const group = `${ROOT}${SEP}group${dir}`;
-		for (let j = 0; j < width && i < count; j++, i++) {
-			plan.set(`${group}${SEP}file${i}`, `v${i}`);
-		}
-		dir++;
-	}
-	return plan;
-};
-
-/**
- * @param {number} depth directory depth
- * @param {number} leaves leaves per level
- * @returns {Map<string, string>} plan
- */
-const buildDeepPlan = (depth, leaves) => {
-	const plan = new Map();
-	let i = 0;
-	const walk = (prefix, level) => {
-		for (let l = 0; l < leaves; l++) {
-			const p = `${prefix}${SEP}file${i}`;
-			plan.set(p, `v${i++}`);
-		}
-		if (level < depth) {
-			walk(`${prefix}${SEP}sub${level}`, level + 1);
-		}
-	};
-	walk(ROOT, 0);
-	return plan;
-};
-
-/**
- * @param {number} count number of targets
- * @returns {Map<string, string>} plan
- */
-const buildFlatPlan = (count) => {
-	const plan = new Map();
-	for (let i = 0; i < count; i++) {
-		plan.set(`${ROOT}${SEP}file${i}`, `v${i}`);
-	}
-	return plan;
-};
-
-const smallPlan = buildWidePlan(50, 10);
-const mediumPlan = buildWidePlan(500, 20);
-const largePlan = buildWidePlan(2000, 25);
-const hugePlan = buildWidePlan(10000, 40);
-const deepPlan = buildDeepPlan(30, 3);
-const veryDeepPlan = buildDeepPlan(80, 2);
-const flatPlan = buildFlatPlan(500);
-const flatLargePlan = buildFlatPlan(5000);
-
-const bench = createBench("reducePlan");
-
-bench
-	.add("under limit (no-op, n=50, limit=100)", () => {
-		reducePlan(smallPlan, 100);
-	})
-	.add("small plan reduction (n=50, limit=10)", () => {
-		reducePlan(smallPlan, 10);
-	})
-	.add("medium plan reduction (n=500, limit=50)", () => {
-		reducePlan(mediumPlan, 50);
-	})
-	.add("medium plan light reduction (n=500, limit=400)", () => {
-		reducePlan(mediumPlan, 400);
-	})
-	.add("medium plan barely over (n=500, limit=499)", () => {
-		reducePlan(mediumPlan, 499);
-	})
-	.add("large plan reduction (n=2000, limit=100)", () => {
-		reducePlan(largePlan, 100);
-	})
-	.add("large plan aggressive (n=2000, limit=10)", () => {
-		reducePlan(largePlan, 10);
-	})
-	.add("huge plan reduction (n=10000, limit=500)", () => {
-		reducePlan(hugePlan, 500);
-	})
-	.add("deep plan reduction (depth=30, limit=20)", () => {
-		reducePlan(deepPlan, 20);
-	})
-	.add("very deep plan (depth=80, limit=40)", () => {
-		reducePlan(veryDeepPlan, 40);
-	})
-	.add("flat plan reduction (n=500 in one dir, limit=50)", () => {
-		reducePlan(flatPlan, 50);
-	})
-	.add("flat large plan (n=5000 in one dir, limit=100)", () => {
-		reducePlan(flatLargePlan, 100);
-	});
-
-export default bench;
-
-await runIfMain(import.meta.url, bench);
diff --git a/bench/run.mjs b/bench/run.mjs
new file mode 100644
index 0000000..d8a8f7e
--- /dev/null
+++ b/bench/run.mjs
@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/*
+ * Benchmark entry point for watchpack.
+ *
+ * Discovers every directory under ./cases/ that contains an `index.bench.mjs`
+ * file, calls its default-exported `register(bench, ctx)` function to
+ * populate tinybench tasks, then runs them all. Case selection can be
+ * restricted with `BENCH_FILTER` or a positional CLI arg — a case is kept
+ * iff its directory name contains the filter substring.
+ *
+ * The bench is wrapped with a local `withCodSpeed()` bridge so the same
+ * entry point works for:
+ *   - local development (`npm run benchmark`) -> wall-clock measurements
+ *     printed to the terminal; the wrapper detects that CodSpeed is not
+ *     active and returns the bench untouched
+ *   - CI under CodSpeedHQ/action -> the wrapper switches to instrumentation
+ *     mode automatically and results are uploaded to codspeed.io
+ *
+ * See ./README.md for the layout of individual cases.
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { Bench, hrtimeNow } from "tinybench";
+import { withCodSpeed } from "./with-codspeed.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const casesPath = path.join(__dirname, "cases");
+
+// Filter expression from CLI or env (e.g. `npm run benchmark -- ignored`).
+// A case is included if its directory name contains this substring. Empty
+// means "include everything".
+const filter = process.env.BENCH_FILTER || process.argv[2] || "";
+
+const bench = withCodSpeed(
+	new Bench({
+		name: "watchpack",
+		now: hrtimeNow,
+		throws: true,
+		warmup: true,
+		warmupIterations: 2,
+		// Kept deliberately low: each task's body already loops over many
+		// operations, and we want wall-clock runs to finish in a few seconds.
+		// CodSpeed's simulation mode ignores this and instruments exactly one
+		// iteration per task.
+		iterations: 10,
+	}),
+);
+
+const caseDirs = (await fs.readdir(casesPath, { withFileTypes: true }))
+	.filter((entry) => entry.isDirectory())
+	.map((entry) => entry.name)
+	.filter((name) => !filter || name.includes(filter))
+	.sort();
+
+if (caseDirs.length === 0) {
+	console.error(
+		filter
+			? `No benchmark cases matched filter "${filter}"`
+			: "No benchmark cases found",
+	);
+	process.exit(1);
+}
+
+for (const caseName of caseDirs) {
+	const benchFile = path.join(casesPath, caseName, "index.bench.mjs");
+	try {
+		// eslint-disable-next-line no-await-in-loop
+		await fs.access(benchFile);
+	} catch {
+		console.warn(`[skip] ${caseName}: no index.bench.mjs`);
+		continue;
+	}
+	// eslint-disable-next-line no-await-in-loop
+	const mod = await import(pathToFileURL(benchFile).href);
+	if (typeof mod.default !== "function") {
+		throw new Error(
+			`${caseName}/index.bench.mjs must export a default function`,
+		);
+	}
+	// eslint-disable-next-line no-await-in-loop
+	await mod.default(bench, {
+		caseName,
+		caseDir: path.join(casesPath, caseName),
+		fixtureDir: path.join(casesPath, caseName, "fixture"),
+	});
+	console.log(`Registered: ${caseName}`);
+}
+
+console.log(`\nRunning ${bench.tasks.length} tasks...\n`);
+await bench.run();
+
+// Pretty-print results. Kept simple on purpose — CodSpeed uploads its own
+// data in CI; this table is for humans running locally.
+const rows = bench.tasks.map((task) => {
+	const r = task.result;
+	if (!r) return { name: task.name, status: "no result" };
+	const lat = r.latency;
+	const tp = r.throughput;
+	return {
+		name: task.name,
+		"ops/s": tp?.mean?.toFixed(2) ?? "n/a",
+		"mean (ms)": lat?.mean?.toFixed(4) ?? "n/a",
+		"p99 (ms)": lat?.p99?.toFixed(4) ?? "n/a",
+		"rme (%)": lat?.rme?.toFixed(2) ?? "n/a",
+		samples: lat?.samplesCount ?? 0,
+	};
+});
+console.log();
+console.table(rows);
+
+// Exit non-zero if any task threw, so CI picks it up.
+const failed = bench.tasks.filter((t) => t.result?.error);
+if (failed.length > 0) {
+	console.error(`\n${failed.length} task(s) errored:`);
+	for (const t of failed) {
+		console.error(`  - ${t.name}: ${t.result?.error?.message}`);
+	}
+	process.exit(1);
+}
diff --git a/bench/watchpack/normalizeOptions.bench.mjs b/bench/watchpack/normalizeOptions.bench.mjs
deleted file mode 100644
index ea6bbed..0000000
--- a/bench/watchpack/normalizeOptions.bench.mjs
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-import { createBench, moduleRequire, runIfMain } from "../helpers.mjs";
-
-const require = moduleRequire(import.meta.url);
-const Watchpack = require("../../lib/index.js");
-
-// The Watchpack constructor normalizes options and installs a cache on the
-// options object. Measuring construction captures ignored compilation plus
-// option validation, which is called frequently by webpack on each rebuild.
-
-const optionsNone = {};
-const optionsWithRegExp = { ignored: /node_modules|\.git/ };
-const optionsWithString = { ignored: "**/node_modules" };
-const optionsWithSmallArray = { ignored: ["**/node_modules", "**/.git"] };
-const optionsWithLargeArray = {
-	ignored: [
-		"**/node_modules",
-		"**/.git",
-		"**/dist",
-		"**/build",
-		"**/coverage",
-		"**/.cache",
-		"**/.next",
-		"**/.nuxt",
-		"**/tmp",
-		"**/*.log",
-	],
-};
-const optionsWithFn = { ignored: (p) => p.includes("node_modules") };
-
-const bench = createBench("Watchpack construction");
-
-bench
-	.add("new Watchpack() with no ignored", () => {
-		const wp = new Watchpack(optionsNone);
-		wp.close();
-	})
-	.add("new Watchpack() with regexp ignored", () => {
-		const wp = new Watchpack(optionsWithRegExp);
-		wp.close();
-	})
-	.add("new Watchpack() with string ignored", () => {
-		const wp = new Watchpack(optionsWithString);
-		wp.close();
-	})
-	.add("new Watchpack() with array[2] ignored", () => {
-		const wp = new Watchpack(optionsWithSmallArray);
-		wp.close();
-	})
-	.add("new Watchpack() with array[10] ignored", () => {
-		const wp = new Watchpack(optionsWithLargeArray);
-		wp.close();
-	})
-	.add("new Watchpack() with function ignored", () => {
-		const wp = new Watchpack(optionsWithFn);
-		wp.close();
-	})
-	.add("new Watchpack() reusing cached options", () => {
-		// Exercises the WeakMap cache for option normalization.
-		const wp = new Watchpack(optionsWithLargeArray);
-		wp.close();
-	});
-
-export default bench;
-
-await runIfMain(import.meta.url, bench);
diff --git a/bench/with-codspeed.mjs b/bench/with-codspeed.mjs
new file mode 100644
index 0000000..16416b7
--- /dev/null
+++ b/bench/with-codspeed.mjs
@@ -0,0 +1,179 @@
+/*
+ * CodSpeed <-> tinybench bridge for watchpack benchmarks.
+ *
+ * Ported from webpack/enhanced-resolve's benchmark/with-codspeed.mjs, which
+ * itself is derived from webpack's test/BenchmarkTestCases.benchmark.mjs.
+ *
+ * Why not @codspeed/tinybench-plugin?
+ * That package accesses tinybench Task internals (task.fn, task.fnOpts)
+ * that were made private in tinybench v6, causing a TypeError in
+ * simulation mode. webpack and enhanced-resolve hit the same issue and use
+ * @codspeed/core directly — we follow their lead.
+ *
+ * Modes (via getCodspeedRunnerMode() from @codspeed/core):
+ *   "disabled"   — returns the bench untouched (local runs)
+ *   "simulation" — overrides bench.run/runSync for CodSpeed instrumentation
+ *   "walltime"   — left untouched; tinybench's built-in timing is used
+ */
+
+import path from "path";
+import { fileURLToPath } from "url";
+import {
+	InstrumentHooks,
+	getCodspeedRunnerMode,
+	setupCore,
+	teardownCore,
+} from "@codspeed/core";
+
+/** @typedef {import("tinybench").Bench} Bench */
+/** @typedef {() => unknown | Promise<unknown>} Fn */
+
+const repoRoot = path.resolve(
+	path.dirname(fileURLToPath(import.meta.url)),
+	"..",
+);
+
+/**
+ * Capture the file that invoked bench.add() so we can build a stable URI
+ * for CodSpeed to identify the benchmark.
+ * @returns {string} calling file path relative to the repo root
+ */
+function getCallingFile() {
+	const dummy = {};
+	const prev = Error.prepareStackTrace;
+	const prevLimit = Error.stackTraceLimit;
+	Error.stackTraceLimit = 10;
+	Error.prepareStackTrace = (_err, trace) => trace;
+	Error.captureStackTrace(dummy, getCallingFile);
+	const trace = /** @type {NodeJS.CallSite[]} */ (
+		/** @type {{ stack: unknown }} */ (dummy).stack
+	);
+	Error.prepareStackTrace = prev;
+	Error.stackTraceLimit = prevLimit;
+
+	let file = /** @type {string} */ (trace[1].getFileName() || "");
+	if (file.startsWith("file://")) file = fileURLToPath(file);
+	if (!file) return "<unknown>";
+	return path.relative(repoRoot, file);
+}
+
+/**
+ * @typedef {{ uri: string, fn: Fn, opts: object | undefined }} TaskMeta
+ * @type {WeakMap<Bench, Map<string, TaskMeta>>}
+ */
+const metaMap = new WeakMap();
+
+/**
+ * @param {Bench} bench
+ * @returns {Map<string, TaskMeta>}
+ */
+function getOrCreateMeta(bench) {
+	let m = metaMap.get(bench);
+	if (!m) {
+		m = new Map();
+		metaMap.set(bench, m);
+	}
+	return m;
+}
+
+/**
+ * Wrap a tinybench Bench so that CodSpeed simulation mode instruments each
+ * task. In "disabled" and "walltime" modes the bench is returned as-is.
+ *
+ * @param {Bench} bench
+ * @returns {Bench}
+ */
+export function withCodSpeed(bench) {
+	const mode = getCodspeedRunnerMode();
+	if (mode === "disabled" || mode === "walltime") return bench;
+
+	// --- simulation mode ---
+
+	const meta = getOrCreateMeta(bench);
+	const rawAdd = bench.add.bind(bench);
+
+	bench.add = (name, fn, opts) => {
+		const callingFile = getCallingFile();
+		const uri = `${callingFile}::${name}`;
+		meta.set(name, { uri, fn, opts });
+		return rawAdd(name, fn, opts);
+	};
+
+	const setup = () => {
+		setupCore();
+		console.log("[CodSpeed] running in simulation mode");
+	};
+
+	const teardown = () => {
+		teardownCore();
+		console.log(`[CodSpeed] Done running ${bench.tasks.length} benches.`);
+		return bench.tasks;
+	};
+
+	/**
+	 * @param {Fn} fn
+	 * @param {boolean} isAsync
+	 * @returns {Fn}
+	 */
+	const wrapFrame = (fn, isAsync) => {
+		if (isAsync) {
+			return async function __codspeed_root_frame__() {
+				await fn();
+			};
+		}
+		return function __codspeed_root_frame__() {
+			fn();
+		};
+	};
+
+	bench.run = async () => {
+		setup();
+		for (const task of bench.tasks) {
+			const m = /** @type {TaskMeta} */ (meta.get(task.name));
+
+			// Warm-up: run the body a few times to stabilise caches / JIT.
+			for (let i = 0; i < bench.iterations - 1; i++) {
+				// eslint-disable-next-line no-await-in-loop
+				await m.fn();
+			}
+
+			// Instrumented run.
+			global.gc?.();
+			InstrumentHooks.startBenchmark();
+			// eslint-disable-next-line no-await-in-loop
+			await wrapFrame(m.fn, true)();
+			InstrumentHooks.stopBenchmark();
+			InstrumentHooks.setExecutedBenchmark(process.pid, m.uri);
+
+			console.log(
+				`[CodSpeed] ${
+					InstrumentHooks.isInstrumented() ? "Measured" : "Checked"
+				} ${m.uri}`,
+			);
+		}
+		return teardown();
+	};
+
+	bench.runSync = () => {
+		setup();
+		for (const task of bench.tasks) {
+			const m = /** @type {TaskMeta} */ (meta.get(task.name));
+			for (let i = 0; i < bench.iterations - 1; i++) {
+				m.fn();
+			}
+			global.gc?.();
+			InstrumentHooks.startBenchmark();
+			wrapFrame(m.fn, false)();
+			InstrumentHooks.stopBenchmark();
+			InstrumentHooks.setExecutedBenchmark(process.pid, m.uri);
+			console.log(
+				`[CodSpeed] ${
+					InstrumentHooks.isInstrumented() ? "Measured" : "Checked"
+				} ${m.uri}`,
+			);
+		}
+		return teardown();
+	};
+
+	return bench;
+}
diff --git a/package-lock.json b/package-lock.json
index ff8f65e..9c748ad 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -15,7 +15,7 @@
       "devDependencies": {
         "@changesets/cli": "^2.30.0",
         "@changesets/get-github-info": "^0.8.0",
-        "@codspeed/tinybench-plugin": "^5.2.0",
+        "@codspeed/core": "^5.2.0",
         "@types/glob-to-regexp": "^0.4.4",
         "@types/graceful-fs": "^4.1.9",
         "@types/jest": "^30.0.0",
@@ -974,20 +974,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@codspeed/tinybench-plugin": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/@codspeed/tinybench-plugin/-/tinybench-plugin-5.2.0.tgz",
-      "integrity": "sha512-LCmMFON3hdIRqiHC3W8oR0783cecRgA8x7cWMTnC9DgkIuyMrreHgQexnUGV3zsHgB084EXj/iPrWxR914/8Ng==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@codspeed/core": "^5.2.0",
-        "stack-trace": "1.0.0-pre2"
-      },
-      "peerDependencies": {
-        "tinybench": ">=4.0.1"
-      }
-    },
     "node_modules/@emnapi/core": {
       "version": "1.9.1",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.1.tgz",
@@ -10149,16 +10135,6 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
-    "node_modules/stack-trace": {
-      "version": "1.0.0-pre2",
-      "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-1.0.0-pre2.tgz",
-      "integrity": "sha512-2ztBJRek8IVofG9DBJqdy2N5kulaacX30Nz7xmkYF6ale9WBVmIy6mFBchvGX7Vx/MyjBhx+Rcxqrj+dbOnQ6A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=16"
-      }
-    },
     "node_modules/stack-utils": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
diff --git a/package.json b/package.json
index a72e531..03cc369 100644
--- a/package.json
+++ b/package.json
@@ -39,11 +39,7 @@
     "test:only": "npm run test:base",
     "test:watch": "npm run test:base -- --watch",
     "test:coverage": "npm run test:base -- --collectCoverageFrom=\"lib/**/*.js\" --coverage",
-    "bench": "node bench/index.mjs",
-    "bench:ignored": "node bench/ignored/ignored.bench.mjs",
-    "bench:reducePlan": "node bench/reducePlan/reducePlan.bench.mjs",
-    "bench:LinkResolver": "node bench/LinkResolver/LinkResolver.bench.mjs",
-    "bench:watchpack": "node bench/watchpack/normalizeOptions.bench.mjs",
+    "benchmark": "node --max-old-space-size=4096 --hash-seed=1 --random-seed=1 --no-opt --predictable --predictable-gc-schedule --interpreted-frames-native-stack --allow-natives-syntax --expose-gc --no-concurrent-sweeping ./bench/run.mjs",
     "version": "changeset version",
     "release": "changeset publish"
   },
@@ -54,7 +50,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.30.0",
     "@changesets/get-github-info": "^0.8.0",
-    "@codspeed/tinybench-plugin": "^5.2.0",
+    "@codspeed/core": "^5.2.0",
     "@types/glob-to-regexp": "^0.4.4",
     "@types/graceful-fs": "^4.1.9",
     "@types/jest": "^30.0.0",

From 20e2a3ebef856bb715cd816531bf4cbe82fda1b7 Mon Sep 17 00:00:00 2001
From: alexander-akait <sheo13666q@gmail.com>
Date: Fri, 17 Apr 2026 15:42:43 +0300
Subject: [PATCH 5/7] refactor: code

---
 {bench => benchmark}/README.md                |  0
 .../ignored-cross-platform/index.bench.mjs    | 27 +++---
 .../cases/ignored-match/index.bench.mjs       | 27 +++---
 .../cases/link-resolver/index.bench.mjs       | 29 +++---
 .../cases/reduce-plan-deep/index.bench.mjs    |  7 +-
 .../reduce-plan-fast-path/index.bench.mjs     |  7 +-
 .../cases/reduce-plan-flat/index.bench.mjs    |  7 +-
 .../cases/reduce-plan-wide/index.bench.mjs    |  7 +-
 .../watchpack-construction/index.bench.mjs    |  9 +-
 {bench => benchmark}/run.mjs                  | 31 +++----
 {bench => benchmark}/with-codspeed.mjs        | 27 +++---
 eslint.config.mjs                             | 19 ++--
 lib/index.js                                  | 37 ++------
 lib/reducePlan.js                             | 91 +++++++------------
 lib/watchEventSource.js                       | 28 ++----
 15 files changed, 147 insertions(+), 206 deletions(-)
 rename {bench => benchmark}/README.md (100%)
 rename {bench => benchmark}/cases/ignored-cross-platform/index.bench.mjs (75%)
 rename {bench => benchmark}/cases/ignored-match/index.bench.mjs (75%)
 rename {bench => benchmark}/cases/link-resolver/index.bench.mjs (72%)
 rename {bench => benchmark}/cases/reduce-plan-deep/index.bench.mjs (88%)
 rename {bench => benchmark}/cases/reduce-plan-fast-path/index.bench.mjs (88%)
 rename {bench => benchmark}/cases/reduce-plan-flat/index.bench.mjs (85%)
 rename {bench => benchmark}/cases/reduce-plan-wide/index.bench.mjs (91%)
 rename {bench => benchmark}/cases/watchpack-construction/index.bench.mjs (88%)
 rename {bench => benchmark}/run.mjs (78%)
 rename {bench => benchmark}/with-codspeed.mjs (89%)

diff --git a/bench/README.md b/benchmark/README.md
similarity index 100%
rename from bench/README.md
rename to benchmark/README.md
diff --git a/bench/cases/ignored-cross-platform/index.bench.mjs b/benchmark/cases/ignored-cross-platform/index.bench.mjs
similarity index 75%
rename from bench/cases/ignored-cross-platform/index.bench.mjs
rename to benchmark/cases/ignored-cross-platform/index.bench.mjs
index 52f21b0..8a0c92d 100644
--- a/bench/cases/ignored-cross-platform/index.bench.mjs
+++ b/benchmark/cases/ignored-cross-platform/index.bench.mjs
@@ -9,10 +9,7 @@
  * has its own CodSpeed trend line.
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const Watchpack = require("../../../lib/index.js");
+import Watchpack from "../../../lib/index.js";
 
 const UNIX_PATHS = [
 	"/home/user/project/src/index.js",
@@ -27,9 +24,9 @@ const UNIX_PATHS = [
 	"/home/user/project/package.json",
 ];
 
-const WINDOWS_PATHS = UNIX_PATHS.map((p) => p.replace(/\//g, "\\"));
-const MIXED_PATHS = UNIX_PATHS.map((p, i) =>
-	i % 2 === 0 ? p : p.replace(/\//g, "\\"),
+const WINDOWS_PATHS = UNIX_PATHS.map((path) => path.replace(/\//g, "\\"));
+const MIXED_PATHS = UNIX_PATHS.map((path, i) =>
+	i % 2 === 0 ? path : path.replace(/\//g, "\\"),
 );
 
 // Simulates a monorepo deep-path batch: each path has ~17 segments so the
@@ -42,8 +39,8 @@ const DEEP_PATHS = Array.from({ length: 10 }, (_, i) => {
 });
 
 /**
- * @param {import("../../../lib/index").WatchOptions} options
- * @returns {(item: string) => boolean}
+ * @param {import("../../../lib/index").WatchOptions} options options
+ * @returns {(item: string) => boolean} true when ignored, otherwise false
  */
 const buildIgnored = (options) => new Watchpack(options).watcherOptions.ignored;
 
@@ -61,7 +58,7 @@ const LARGE_ARRAY_IGNORED = [
 ];
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	const regexpMatcher = buildIgnored({
@@ -70,21 +67,21 @@ export default function register(bench) {
 	const arrayMatcher = buildIgnored({ ignored: LARGE_ARRAY_IGNORED });
 
 	bench.add("ignored-cross-platform: regex against windows paths", () => {
-		for (const p of WINDOWS_PATHS) regexpMatcher(p);
+		for (const path of WINDOWS_PATHS) regexpMatcher(path);
 	});
 	bench.add("ignored-cross-platform: regex against mixed separators", () => {
-		for (const p of MIXED_PATHS) regexpMatcher(p);
+		for (const path of MIXED_PATHS) regexpMatcher(path);
 	});
 	bench.add("ignored-cross-platform: regex against deep posix paths", () => {
-		for (const p of DEEP_PATHS) regexpMatcher(p);
+		for (const path of DEEP_PATHS) regexpMatcher(path);
 	});
 	bench.add("ignored-cross-platform: array[10] against windows paths", () => {
-		for (const p of WINDOWS_PATHS) arrayMatcher(p);
+		for (const path of WINDOWS_PATHS) arrayMatcher(path);
 	});
 	bench.add(
 		"ignored-cross-platform: array[10] against deep posix paths",
 		() => {
-			for (const p of DEEP_PATHS) arrayMatcher(p);
+			for (const path of DEEP_PATHS) arrayMatcher(path);
 		},
 	);
 }
diff --git a/bench/cases/ignored-match/index.bench.mjs b/benchmark/cases/ignored-match/index.bench.mjs
similarity index 75%
rename from bench/cases/ignored-match/index.bench.mjs
rename to benchmark/cases/ignored-match/index.bench.mjs
index 72bf21a..c2cd3a4 100644
--- a/bench/cases/ignored-match/index.bench.mjs
+++ b/benchmark/cases/ignored-match/index.bench.mjs
@@ -8,10 +8,7 @@
  * batch dominates per-rebuild time in large projects.
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const Watchpack = require("../../../lib/index.js");
+import Watchpack from "../../../lib/index.js";
 
 const UNIX_PATHS = [
 	"/home/user/project/src/index.js",
@@ -29,13 +26,13 @@ const UNIX_PATHS = [
 /**
  * Reach into a Watchpack instance to get at the normalized matcher without
  * duplicating the option-compilation logic.
- * @param {import("../../../lib/index").WatchOptions} options
- * @returns {(item: string) => boolean}
+ * @param {import("../../../lib/index").WatchOptions} options options
+ * @returns {(item: string) => boolean} true when ignored, otherwise false
  */
 const buildIgnored = (options) => new Watchpack(options).watcherOptions.ignored;
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	const noneMatcher = buildIgnored({});
@@ -62,28 +59,28 @@ export default function register(bench) {
 		],
 	});
 	const functionMatcher = buildIgnored({
-		ignored: (p) => p.includes("node_modules") || p.includes(".git"),
+		ignored: (path) => path.includes("node_modules") || path.includes(".git"),
 	});
 
 	bench.add("ignored-match: no ignored option (noop fast path)", () => {
-		for (const p of UNIX_PATHS) noneMatcher(p);
+		for (const path of UNIX_PATHS) noneMatcher(path);
 	});
 	bench.add("ignored-match: regex matcher", () => {
-		for (const p of UNIX_PATHS) regexpMatcher(p);
+		for (const path of UNIX_PATHS) regexpMatcher(path);
 	});
 	bench.add("ignored-match: glob string matcher", () => {
-		for (const p of UNIX_PATHS) stringMatcher(p);
+		for (const path of UNIX_PATHS) stringMatcher(path);
 	});
 	bench.add("ignored-match: array[1] matcher", () => {
-		for (const p of UNIX_PATHS) singletonArrayMatcher(p);
+		for (const path of UNIX_PATHS) singletonArrayMatcher(path);
 	});
 	bench.add("ignored-match: array[2] matcher", () => {
-		for (const p of UNIX_PATHS) smallArrayMatcher(p);
+		for (const path of UNIX_PATHS) smallArrayMatcher(path);
 	});
 	bench.add("ignored-match: array[10] matcher", () => {
-		for (const p of UNIX_PATHS) largeArrayMatcher(p);
+		for (const path of UNIX_PATHS) largeArrayMatcher(path);
 	});
 	bench.add("ignored-match: function matcher", () => {
-		for (const p of UNIX_PATHS) functionMatcher(p);
+		for (const path of UNIX_PATHS) functionMatcher(path);
 	});
 }
diff --git a/bench/cases/link-resolver/index.bench.mjs b/benchmark/cases/link-resolver/index.bench.mjs
similarity index 72%
rename from bench/cases/link-resolver/index.bench.mjs
rename to benchmark/cases/link-resolver/index.bench.mjs
index 7ff5d03..96df73a 100644
--- a/bench/cases/link-resolver/index.bench.mjs
+++ b/benchmark/cases/link-resolver/index.bench.mjs
@@ -14,19 +14,16 @@
  * instrumentation noisy.
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const LinkResolver = require("../../../lib/LinkResolver.js");
+import LinkResolver from "../../../lib/LinkResolver.js";
 
 const SEP = process.platform === "win32" ? "\\" : "/";
 const ROOT =
 	process.platform === "win32" ? "C:\\nonexistent_bench" : "/nonexistent_bench";
 
 const makePath = (depth) => {
-	let p = ROOT;
-	for (let i = 0; i < depth; i++) p += `${SEP}level${i}`;
-	return p;
+	let path = ROOT;
+	for (let i = 0; i < depth; i++) path += `${SEP}level${i}`;
+	return path;
 };
 
 const shallowPaths = Array.from(
@@ -43,31 +40,31 @@ const deepPaths = Array.from(
 );
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	// Pre-populated resolver for the warm/cache-hit measurements.
 	const warmResolver = new LinkResolver();
-	for (const p of shallowPaths) warmResolver.resolve(p);
-	for (const p of mediumPaths) warmResolver.resolve(p);
-	for (const p of deepPaths) warmResolver.resolve(p);
+	for (const path of shallowPaths) warmResolver.resolve(path);
+	for (const path of mediumPaths) warmResolver.resolve(path);
+	for (const path of deepPaths) warmResolver.resolve(path);
 
 	bench.add("link-resolver: cold shallow batch (depth=1, n=100)", () => {
 		const resolver = new LinkResolver();
-		for (const p of shallowPaths) resolver.resolve(p);
+		for (const path of shallowPaths) resolver.resolve(path);
 	});
 	bench.add("link-resolver: cold medium batch (depth=5, n=100)", () => {
 		const resolver = new LinkResolver();
-		for (const p of mediumPaths) resolver.resolve(p);
+		for (const path of mediumPaths) resolver.resolve(path);
 	});
 	bench.add("link-resolver: cold deep batch (depth=15, n=50)", () => {
 		const resolver = new LinkResolver();
-		for (const p of deepPaths) resolver.resolve(p);
+		for (const path of deepPaths) resolver.resolve(path);
 	});
 	bench.add("link-resolver: warm shallow batch (cache hit, n=100)", () => {
-		for (const p of shallowPaths) warmResolver.resolve(p);
+		for (const path of shallowPaths) warmResolver.resolve(path);
 	});
 	bench.add("link-resolver: warm deep batch (cache hit, n=50)", () => {
-		for (const p of deepPaths) warmResolver.resolve(p);
+		for (const path of deepPaths) warmResolver.resolve(path);
 	});
 }
diff --git a/bench/cases/reduce-plan-deep/index.bench.mjs b/benchmark/cases/reduce-plan-deep/index.bench.mjs
similarity index 88%
rename from bench/cases/reduce-plan-deep/index.bench.mjs
rename to benchmark/cases/reduce-plan-deep/index.bench.mjs
index d212f10..187c5c3 100644
--- a/bench/cases/reduce-plan-deep/index.bench.mjs
+++ b/benchmark/cases/reduce-plan-deep/index.bench.mjs
@@ -11,10 +11,7 @@
  * spine and very few siblings per rung.
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const reducePlan = require("../../../lib/reducePlan.js");
+import reducePlan from "../../../lib/reducePlan.js";
 
 const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
 const SEP = process.platform === "win32" ? "\\" : "/";
@@ -41,7 +38,7 @@ const deepPlan = buildDeepPlan(30, 3);
 const veryDeepPlan = buildDeepPlan(80, 2);
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	bench.add("reduce-plan-deep: depth=30, leaves=3, limit=20", () => {
diff --git a/bench/cases/reduce-plan-fast-path/index.bench.mjs b/benchmark/cases/reduce-plan-fast-path/index.bench.mjs
similarity index 88%
rename from bench/cases/reduce-plan-fast-path/index.bench.mjs
rename to benchmark/cases/reduce-plan-fast-path/index.bench.mjs
index 979d2f0..0a7a393 100644
--- a/bench/cases/reduce-plan-fast-path/index.bench.mjs
+++ b/benchmark/cases/reduce-plan-fast-path/index.bench.mjs
@@ -12,10 +12,7 @@
  * own trend line instead of hiding under a 10ms huge-plan benchmark.
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const reducePlan = require("../../../lib/reducePlan.js");
+import reducePlan from "../../../lib/reducePlan.js";
 
 const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
 const SEP = process.platform === "win32" ? "\\" : "/";
@@ -43,7 +40,7 @@ const smallPlan = buildWidePlan(50, 10);
 const mediumPlan = buildWidePlan(500, 20);
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	bench.add("reduce-plan-fast-path: under limit (n=50, limit=100)", () => {
diff --git a/bench/cases/reduce-plan-flat/index.bench.mjs b/benchmark/cases/reduce-plan-flat/index.bench.mjs
similarity index 85%
rename from bench/cases/reduce-plan-flat/index.bench.mjs
rename to benchmark/cases/reduce-plan-flat/index.bench.mjs
index 2d7ab4c..10b0326 100644
--- a/bench/cases/reduce-plan-flat/index.bench.mjs
+++ b/benchmark/cases/reduce-plan-flat/index.bench.mjs
@@ -8,10 +8,7 @@
  * "pages" or "generated" directory with hundreds of entries).
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const reducePlan = require("../../../lib/reducePlan.js");
+import reducePlan from "../../../lib/reducePlan.js";
 
 const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
 const SEP = process.platform === "win32" ? "\\" : "/";
@@ -32,7 +29,7 @@ const flatMediumPlan = buildFlatPlan(500);
 const flatLargePlan = buildFlatPlan(5000);
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	bench.add("reduce-plan-flat: n=500 in one dir, limit=50", () => {
diff --git a/bench/cases/reduce-plan-wide/index.bench.mjs b/benchmark/cases/reduce-plan-wide/index.bench.mjs
similarity index 91%
rename from bench/cases/reduce-plan-wide/index.bench.mjs
rename to benchmark/cases/reduce-plan-wide/index.bench.mjs
index d943560..5e1c009 100644
--- a/bench/cases/reduce-plan-wide/index.bench.mjs
+++ b/benchmark/cases/reduce-plan-wide/index.bench.mjs
@@ -11,10 +11,7 @@
  * Three magnitudes: small (50), medium (500), large (2000), huge (10000).
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const reducePlan = require("../../../lib/reducePlan.js");
+import reducePlan from "../../../lib/reducePlan.js";
 
 const ROOT = process.platform === "win32" ? "C:\\root" : "/root";
 const SEP = process.platform === "win32" ? "\\" : "/";
@@ -44,7 +41,7 @@ const largePlan = buildWidePlan(2000, 25);
 const hugePlan = buildWidePlan(10000, 40);
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	bench.add("reduce-plan-wide: small plan (n=50, limit=10)", () => {
diff --git a/bench/cases/watchpack-construction/index.bench.mjs b/benchmark/cases/watchpack-construction/index.bench.mjs
similarity index 88%
rename from bench/cases/watchpack-construction/index.bench.mjs
rename to benchmark/cases/watchpack-construction/index.bench.mjs
index 2dc0c2b..79dc12d 100644
--- a/bench/cases/watchpack-construction/index.bench.mjs
+++ b/benchmark/cases/watchpack-construction/index.bench.mjs
@@ -12,10 +12,7 @@
  * process from leaking timers even though no watchers have been attached.
  */
 
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-const Watchpack = require("../../../lib/index.js");
+import Watchpack from "../../../lib/index.js";
 
 const optionsNone = {};
 const optionsWithRegExp = { ignored: /node_modules|\.git/ };
@@ -35,10 +32,10 @@ const optionsWithLargeArray = {
 		"**/*.log",
 	],
 };
-const optionsWithFn = { ignored: (p) => p.includes("node_modules") };
+const optionsWithFn = { ignored: (path) => path.includes("node_modules") };
 
 /**
- * @param {import('tinybench').Bench} bench
+ * @param {import("tinybench").Bench} bench bench
  */
 export default function register(bench) {
 	bench.add("watchpack-construction: no ignored option", () => {
diff --git a/bench/run.mjs b/benchmark/run.mjs
similarity index 78%
rename from bench/run.mjs
rename to benchmark/run.mjs
index d8a8f7e..2d68ecd 100644
--- a/bench/run.mjs
+++ b/benchmark/run.mjs
@@ -1,15 +1,13 @@
 #!/usr/bin/env node
 /*
- * Benchmark entry point for watchpack.
+ * Benchmark entry point for enhanced-resolve.
  *
  * Discovers every directory under ./cases/ that contains an `index.bench.mjs`
  * file, calls its default-exported `register(bench, ctx)` function to
- * populate tinybench tasks, then runs them all. Case selection can be
- * restricted with `BENCH_FILTER` or a positional CLI arg — a case is kept
- * iff its directory name contains the filter substring.
+ * populate tinybench tasks, then runs them all.
  *
- * The bench is wrapped with a local `withCodSpeed()` bridge so the same
- * entry point works for:
+ * The bench is wrapped with a local `withCodSpeed()` bridge (ported from
+ * webpack) so the same entry point works for:
  *   - local development (`npm run benchmark`) -> wall-clock measurements
  *     printed to the terminal; the wrapper detects that CodSpeed is not
  *     active and returns the bench untouched
@@ -28,22 +26,24 @@ import { withCodSpeed } from "./with-codspeed.mjs";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const casesPath = path.join(__dirname, "cases");
 
-// Filter expression from CLI or env (e.g. `npm run benchmark -- ignored`).
-// A case is included if its directory name contains this substring. Empty
-// means "include everything".
+/**
+ * Filter expression from CLI or env (e.g. `npm run benchmark -- realistic`).
+ * A case is included if its directory name contains this substring. Empty
+ * means "include everything".
+ */
 const filter = process.env.BENCH_FILTER || process.argv[2] || "";
 
 const bench = withCodSpeed(
 	new Bench({
-		name: "watchpack",
+		name: "enhanced-resolve",
 		now: hrtimeNow,
 		throws: true,
 		warmup: true,
 		warmupIterations: 2,
 		// Kept deliberately low: each task's body already loops over many
-		// operations, and we want wall-clock runs to finish in a few seconds.
-		// CodSpeed's simulation mode ignores this and instruments exactly one
-		// iteration per task.
+		// resolve calls, and we want wall-clock runs to finish in a few
+		// seconds. CodSpeed's simulation mode ignores this and instruments
+		// exactly one iteration per task.
 		iterations: 10,
 	}),
 );
@@ -66,20 +66,17 @@ if (caseDirs.length === 0) {
 for (const caseName of caseDirs) {
 	const benchFile = path.join(casesPath, caseName, "index.bench.mjs");
 	try {
-		// eslint-disable-next-line no-await-in-loop
 		await fs.access(benchFile);
 	} catch {
 		console.warn(`[skip] ${caseName}: no index.bench.mjs`);
 		continue;
 	}
-	// eslint-disable-next-line no-await-in-loop
 	const mod = await import(pathToFileURL(benchFile).href);
 	if (typeof mod.default !== "function") {
 		throw new Error(
 			`${caseName}/index.bench.mjs must export a default function`,
 		);
 	}
-	// eslint-disable-next-line no-await-in-loop
 	await mod.default(bench, {
 		caseName,
 		caseDir: path.join(casesPath, caseName),
@@ -96,6 +93,8 @@ await bench.run();
 const rows = bench.tasks.map((task) => {
 	const r = task.result;
 	if (!r) return { name: task.name, status: "no result" };
+	// tinybench v6 result shape: latency/throughput objects, no top-level
+	// hz / samples. `latency` fields are in ms already.
 	const lat = r.latency;
 	const tp = r.throughput;
 	return {
diff --git a/bench/with-codspeed.mjs b/benchmark/with-codspeed.mjs
similarity index 89%
rename from bench/with-codspeed.mjs
rename to benchmark/with-codspeed.mjs
index 16416b7..b07e400 100644
--- a/bench/with-codspeed.mjs
+++ b/benchmark/with-codspeed.mjs
@@ -57,15 +57,21 @@ function getCallingFile() {
 	return path.relative(repoRoot, file);
 }
 
+// eslint-disable-next-line jsdoc/require-property
+/** @typedef {object} EXPECTED_OBJECT */
+
+/**
+ * @typedef {{ uri: string, fn: Fn, opts: EXPECTED_OBJECT | undefined }} TaskMeta
+ */
+
 /**
- * @typedef {{ uri: string, fn: Fn, opts: object | undefined }} TaskMeta
  * @type {WeakMap<Bench, Map<string, TaskMeta>>}
  */
 const metaMap = new WeakMap();
 
 /**
- * @param {Bench} bench
- * @returns {Map<string, TaskMeta>}
+ * @param {Bench} bench bench
+ * @returns {Map<string, TaskMeta>} task meta
  */
 function getOrCreateMeta(bench) {
 	let m = metaMap.get(bench);
@@ -79,9 +85,8 @@ function getOrCreateMeta(bench) {
 /**
  * Wrap a tinybench Bench so that CodSpeed simulation mode instruments each
  * task. In "disabled" and "walltime" modes the bench is returned as-is.
- *
- * @param {Bench} bench
- * @returns {Bench}
+ * @param {Bench} bench bench
+ * @returns {Bench} bench
  */
 export function withCodSpeed(bench) {
 	const mode = getCodspeedRunnerMode();
@@ -111,16 +116,18 @@ export function withCodSpeed(bench) {
 	};
 
 	/**
-	 * @param {Fn} fn
-	 * @param {boolean} isAsync
-	 * @returns {Fn}
+	 * @param {Fn} fn function
+	 * @param {boolean} isAsync true when is async, otherwise false
+	 * @returns {Fn} wrapper function
 	 */
 	const wrapFrame = (fn, isAsync) => {
 		if (isAsync) {
+			// eslint-disable-next-line camelcase
 			return async function __codspeed_root_frame__() {
 				await fn();
 			};
 		}
+		// eslint-disable-next-line camelcase
 		return function __codspeed_root_frame__() {
 			fn();
 		};
@@ -133,14 +140,12 @@ export function withCodSpeed(bench) {
 
 			// Warm-up: run the body a few times to stabilise caches / JIT.
 			for (let i = 0; i < bench.iterations - 1; i++) {
-				// eslint-disable-next-line no-await-in-loop
 				await m.fn();
 			}
 
 			// Instrumented run.
 			global.gc?.();
 			InstrumentHooks.startBenchmark();
-			// eslint-disable-next-line no-await-in-loop
 			await wrapFrame(m.fn, true)();
 			InstrumentHooks.stopBenchmark();
 			InstrumentHooks.setExecutedBenchmark(process.pid, m.uri);
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 8c1fe99..bb980e6 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -2,12 +2,6 @@ import { defineConfig } from "eslint/config";
 import config from "eslint-config-webpack";
 
 export default defineConfig([
-	{
-		// Benchmarks are ESM-only (tinybench is ESM) and use top-level await
-		// plus import.meta which the shared CJS config does not expect. They
-		// are not shipped with the package so lint them out.
-		ignores: ["bench/**"],
-	},
 	{
 		extends: [config],
 		rules: {
@@ -47,4 +41,17 @@ export default defineConfig([
 			"n/prefer-node-protocol": "off",
 		},
 	},
+	{
+		files: ["benchmark/**/*"],
+		languageOptions: {
+			ecmaVersion: "latest",
+		},
+		rules: {
+			"no-console": "off",
+			"n/hashbang": "off",
+			"n/no-unsupported-features/node-builtins": "off",
+			"n/no-unsupported-features/es-syntax": "off",
+			"n/no-process-exit": "off",
+		},
+	},
 ]);
diff --git a/lib/index.js b/lib/index.js
index 594f88e..2cbad01 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -60,8 +60,10 @@ const watchEventSource = require("./watchEventSource");
  */
 function addWatchersToSet(watchers, set) {
 	for (const ww of watchers) {
-		// Set.add is already idempotent, so skip the redundant has() probe.
-		set.add(ww.watcher.directoryWatcher);
+		const w = ww.watcher;
+		if (!set.has(w.directoryWatcher)) {
+			set.add(w.directoryWatcher);
+		}
 	}
 }
 
@@ -77,44 +79,27 @@ const stringToRegexp = (ignored) => {
 	return `${source.slice(0, -1)}(?:$|\\/)`;
 };
 
-/**
- * Normalizes path separators for regex testing. `String.prototype.replace`
- * always allocates a new string, even when the pattern finds nothing; for
- * POSIX paths (the common case) that allocation is pure overhead. Check for
- * a backslash with `indexOf` first so we skip the copy on paths that are
- * already normalized.
- * @param {string} item item
- * @returns {string} item with backslashes normalized to forward slashes
- */
-const normalizeSeparators = (item) =>
-	item.includes("\\") ? item.replace(/\\/g, "/") : item;
-
 /**
  * @param {Ignored=} ignored ignored
  * @returns {(item: string) => boolean} ignored to function
  */
 const ignoredToFunction = (ignored) => {
 	if (Array.isArray(ignored)) {
-		const stringRegexps =
-			/** @type {string[]} */
-			(ignored.map((i) => stringToRegexp(i)).filter(Boolean));
+		const stringRegexps = ignored.map((i) => stringToRegexp(i)).filter(Boolean);
 		if (stringRegexps.length === 0) {
 			return () => false;
 		}
-		const regexp =
-			stringRegexps.length === 1
-				? new RegExp(stringRegexps[0])
-				: new RegExp(stringRegexps.join("|"));
-		return (item) => regexp.test(normalizeSeparators(item));
+		const regexp = new RegExp(stringRegexps.join("|"));
+		return (item) => regexp.test(item.replace(/\\/g, "/"));
 	} else if (typeof ignored === "string") {
 		const stringRegexp = stringToRegexp(ignored);
 		if (!stringRegexp) {
 			return () => false;
 		}
 		const regexp = new RegExp(stringRegexp);
-		return (item) => regexp.test(normalizeSeparators(item));
+		return (item) => regexp.test(item.replace(/\\/g, "/"));
 	} else if (ignored instanceof RegExp) {
-		return (item) => ignored.test(normalizeSeparators(item));
+		return (item) => ignored.test(item.replace(/\\/g, "/"));
 	} else if (typeof ignored === "function") {
 		return ignored;
 	} else if (ignored) {
@@ -478,10 +463,8 @@ class Watchpack extends EventEmitter {
 		/** @type {Record<string, number>} */
 		const obj = Object.create(null);
 		for (const w of directoryWatchers) {
-			// getTimes() returns a prototype-less object, so for...in is safe
-			// and avoids the throwaway array that Object.keys would allocate.
 			const times = w.getTimes();
-			for (const file in times) obj[file] = times[file];
+			for (const file of Object.keys(times)) obj[file] = times[file];
 		}
 		return obj;
 	}
diff --git a/lib/reducePlan.js b/lib/reducePlan.js
index 8e0d38b..a6ced7f 100644
--- a/lib/reducePlan.js
+++ b/lib/reducePlan.js
@@ -67,66 +67,45 @@ module.exports = (plan, limit) => {
 			}
 		}
 	}
-	// Reduce until limit reached. When no reduction is needed at all, skip
-	// building the candidate set entirely to avoid paying for the setup on the
-	// common fast path.
-	if (currentCount > limit) {
-		// Pre-filter candidate nodes so the inner selection loop skips structural
-		// non-candidates entirely. `children` length and parent presence are
-		// fixed after tree construction; only `entries` can change (it can only
-		// decrease), so a node that fails the `entries` check in a later round
-		// is simply skipped via `continue`. When we merge a subtree we drop the
-		// descendants from the candidate set to keep it shrinking over
-		// iterations.
-		/** @type {Set<TreeNode<T>>} */
-		const candidates = new Set();
+	// Reduce until limit reached
+	while (currentCount > limit) {
+		// Select node that helps reaching the limit most effectively without overmerging
+		const overLimit = currentCount - limit;
+		let bestNode;
+		let bestCost = Infinity;
 		for (const node of treeMap.values()) {
-			if (!node.parent || !node.children) continue;
+			if (node.entries <= 1 || !node.children || !node.parent) continue;
 			if (node.children.length === 0) continue;
 			if (node.children.length === 1 && !node.value) continue;
-			candidates.add(node);
-		}
-		const costBias = limit * 0.3;
-		while (currentCount > limit) {
-			// Select node that helps reaching the limit most effectively without overmerging
-			const overLimit = currentCount - limit;
-			let bestNode;
-			let bestCost = Infinity;
-			for (const node of candidates) {
-				if (node.entries <= 1) continue;
-				// Try to select the node with has just a bit more entries than we need to reduce
-				// When just a bit more is over 30% over the limit,
-				// also consider just a bit less entries then we need to reduce
-				const diff = node.entries - 1 - overLimit;
-				const cost = diff >= 0 ? diff : -diff + costBias;
-				if (cost < bestCost) {
-					bestNode = node;
-					bestCost = cost;
-					// A cost of 0 means the merge reduces exactly to the limit;
-					// no further candidate can improve on that, so stop scanning.
-					if (cost === 0) break;
-				}
+			// Try to select the node with has just a bit more entries than we need to reduce
+			// When just a bit more is over 30% over the limit,
+			// also consider just a bit less entries then we need to reduce
+			const cost =
+				node.entries - 1 >= overLimit
+					? node.entries - 1 - overLimit
+					: overLimit - node.entries + 1 + limit * 0.3;
+			if (cost < bestCost) {
+				bestNode = node;
+				bestCost = cost;
 			}
-			if (!bestNode) break;
-			// Merge all children
-			const reduction = bestNode.entries - 1;
-			bestNode.active = true;
-			bestNode.entries = 1;
-			candidates.delete(bestNode);
-			currentCount -= reduction;
-			let { parent } = bestNode;
-			while (parent) {
-				parent.entries -= reduction;
-				parent = parent.parent;
-			}
-			const queue = new Set(bestNode.children);
-			for (const node of queue) {
-				node.active = false;
-				node.entries = 0;
-				candidates.delete(node);
-				if (node.children) {
-					for (const child of node.children) queue.add(child);
-				}
+		}
+		if (!bestNode) break;
+		// Merge all children
+		const reduction = bestNode.entries - 1;
+		bestNode.active = true;
+		bestNode.entries = 1;
+		currentCount -= reduction;
+		let { parent } = bestNode;
+		while (parent) {
+			parent.entries -= reduction;
+			parent = parent.parent;
+		}
+		const queue = new Set(bestNode.children);
+		for (const node of queue) {
+			node.active = false;
+			node.entries = 0;
+			if (node.children) {
+				for (const child of node.children) queue.add(child);
 			}
 		}
 	}
diff --git a/lib/watchEventSource.js b/lib/watchEventSource.js
index 7d838a5..e9b3b3f 100644
--- a/lib/watchEventSource.js
+++ b/lib/watchEventSource.js
@@ -61,9 +61,6 @@ function createEPERMError(filePath) {
  * @returns {(type: "rename" | "change", filename: string) => void} handler of change event
  */
 function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
-	// path.basename(filePath) is invariant for the lifetime of the watcher,
-	// so compute it once rather than on every dispatched event.
-	const ownBasename = path.basename(filePath);
 	return (type, filename) => {
 		// TODO: After Node.js v22, fs.watch(dir) and deleting a dir will trigger the rename change event.
 		// Here we just ignore it and keep the same behavior as before v22
@@ -71,7 +68,7 @@ function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
 		if (
 			type === "rename" &&
 			path.isAbsolute(filename) &&
-			path.basename(filename) === ownBasename
+			path.basename(filename) === path.basename(filePath)
 		) {
 			if (!IS_OSX) {
 				// Before v22, windows will throw EPERM error
@@ -432,21 +429,16 @@ module.exports.watch = (filePath) => {
 		directWatcher.add(watcher);
 		return watcher;
 	}
-	// Only platforms with recursive fs.watch ever populate recursiveWatchers,
-	// so skip the entire parent walk when the map is empty (always the case
-	// on Linux and the common case before the watcher limit is reached).
-	if (recursiveWatchers.size !== 0) {
-		let current = filePath;
-		for (;;) {
-			const recursiveWatcher = recursiveWatchers.get(current);
-			if (recursiveWatcher !== undefined) {
-				recursiveWatcher.add(filePath, watcher);
-				return watcher;
-			}
-			const parent = path.dirname(current);
-			if (parent === current) break;
-			current = parent;
+	let current = filePath;
+	for (;;) {
+		const recursiveWatcher = recursiveWatchers.get(current);
+		if (recursiveWatcher !== undefined) {
+			recursiveWatcher.add(filePath, watcher);
+			return watcher;
 		}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
 	}
 	// Queue up watcher for creation
 	pendingWatchers.set(watcher, filePath);

From b909a59dc1aae24cc8e26b1526b94b6de11f5891 Mon Sep 17 00:00:00 2001
From: alexander-akait <sheo13666q@gmail.com>
Date: Fri, 17 Apr 2026 15:50:09 +0300
Subject: [PATCH 6/7] chore: fix script

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 03cc369..11c8889 100644
--- a/package.json
+++ b/package.json
@@ -39,7 +39,7 @@
     "test:only": "npm run test:base",
     "test:watch": "npm run test:base -- --watch",
     "test:coverage": "npm run test:base -- --collectCoverageFrom=\"lib/**/*.js\" --coverage",
-    "benchmark": "node --max-old-space-size=4096 --hash-seed=1 --random-seed=1 --no-opt --predictable --predictable-gc-schedule --interpreted-frames-native-stack --allow-natives-syntax --expose-gc --no-concurrent-sweeping ./bench/run.mjs",
+    "benchmark": "node --max-old-space-size=4096 --hash-seed=1 --random-seed=1 --no-opt --predictable --predictable-gc-schedule --interpreted-frames-native-stack --allow-natives-syntax --expose-gc --no-concurrent-sweeping ./benchmark/run.mjs",
     "version": "changeset version",
     "release": "changeset publish"
   },

From a17d8baa8233834e3ed8c40cdc37ed9284242078 Mon Sep 17 00:00:00 2001
From: alexander-akait <sheo13666q@gmail.com>
Date: Fri, 17 Apr 2026 16:04:45 +0300
Subject: [PATCH 7/7] chore: fix script

---
 .github/workflows/{codspeed.yml => benchmarks.yml} | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)
 rename .github/workflows/{codspeed.yml => benchmarks.yml} (76%)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/benchmarks.yml
similarity index 76%
rename from .github/workflows/codspeed.yml
rename to .github/workflows/benchmarks.yml
index 9c6ba66..e86e647 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/benchmarks.yml
@@ -13,8 +13,7 @@ concurrency:
 
 permissions:
   contents: read
-  # Required for OIDC authentication with CodSpeed.
-  id-token: write
+  id-token: write # Required for OIDC authentication with CodSpeed
 
 jobs:
   benchmark:
@@ -27,10 +26,10 @@ jobs:
           fetch-depth: 0
 
       - name: Use Node.js
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
         with:
           node-version: lts/*
-          cache: "npm"
+          cache: npm
 
       - run: npm ci
 
@@ -39,4 +38,3 @@ jobs:
         with:
           run: npm run benchmark
           mode: "simulation"
-          token: ${{ secrets.CODSPEED_TOKEN }}