test: added stack perf case

Author: alexander-akait

benchmark/README.md

@@ -79,6 +79,7 @@ export default function register(bench, { caseName, caseDir, fixtureDir }) {
 | ------------------------- | ------------------------------------------------------------------------------------------------------------ |
 | `realistic-midsize`       | Mixed batch of relative/bare/scoped/exports/nested-`node_modules` requests against a synthetic mid-size tree |
 | `pathological-deep-stack` | 50-deep alias chain, specifically stresses the `doResolve` recursion-check path                              |
+| `stack-churn`             | Several independent depth-60 alias chains — stresses `doResolve`'s per-level stack-allocation pressure       |
 | `alias-realistic`         | Webpack-style `@/components`, `@utils`, `~` aliases — AliasPlugin with a realistic number of entries         |
 | `alias-field`             | `browser` field remapping (AliasFieldPlugin), including the `false`/ignored branch                           |
 | `exports-field`           | Package with nested condition maps and wildcard subpath exports, run under both `require` and `import`       |

benchmark/cases/stack-churn/fixture/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "stack-churn-fixture",
+  "version": "1.0.0"
+}

benchmark/cases/stack-churn/fixture/target.js

@@ -0,0 +1 @@
+module.exports = "target";

benchmark/cases/stack-churn/index.bench.mjs

@@ -0,0 +1,88 @@
+/*
+ * stack-churn
+ *
+ * Measures the allocation pressure of `doResolve`'s recursion-tracking
+ * stack across many moderately-deep alias rewrites.
+ *
+ * Every level of alias rewriting re-enters the resolver pipeline via
+ * `doResolve`, which has to extend the stack used to detect cycles.
+ * On the `Set<string>`-clone baseline this means `new Set(parent)` per
+ * level — a fresh hash-table allocation and an O(n) copy on every hook
+ * re-entry. Under a long-running async workload the resulting GC churn
+ * is what actually shows up in the numbers (look at p99 / rme when
+ * running this case: the Set-clone baseline has markedly higher
+ * variance from GC pauses).
+ *
+ * Unlike `pathological-deep-stack` (one very long chain), this case
+ * fans out across several independent chains so the stacks don't all
+ * share a common long prefix — closer in shape to large real-world
+ * alias configs where the resolver sees many unrelated but non-trivial
+ * stacks.
+ */
+
+import fs from "fs";
+import enhanced from "../../../lib/index.js";
+
+const { ResolverFactory, CachedInputFileSystem } = enhanced;
+
+const CHAIN_COUNT = 4;
+const CHAIN_DEPTH = 60;
+const RESOLVES_PER_ITER = 20;
+
+/**
+ * Build CHAIN_COUNT independent alias chains, each of length CHAIN_DEPTH:
+ *   c0-0 -> c0-1 -> ... -> c0-(n-1) -> ./target
+ *   c1-0 -> c1-1 -> ... -> c1-(n-1) -> ./target
+ *   ...
+ * so every top-level resolve forces CHAIN_DEPTH `doResolve` re-entries.
+ * @returns {Array<{name: string, alias: string}>} alias list
+ */
+function buildChains() {
+	const aliases = [];
+	for (let c = 0; c < CHAIN_COUNT; c++) {
+		for (let i = 0; i < CHAIN_DEPTH - 1; i++) {
+			aliases.push({ name: `c${c}-${i}`, alias: `c${c}-${i + 1}` });
+		}
+		aliases.push({ name: `c${c}-${CHAIN_DEPTH - 1}`, alias: "./target" });
+	}
+	return aliases;
+}
+
+/**
+ * @param {import('tinybench').Bench} bench
+ * @param {{ fixtureDir: string }} ctx
+ */
+export default function register(bench, { fixtureDir }) {
+	const fileSystem = new CachedInputFileSystem(fs, 4000);
+	const aliases = buildChains();
+
+	const resolver = ResolverFactory.createResolver({
+		fileSystem,
+		extensions: [".js"],
+		alias: aliases,
+	});
+
+	// Fixed request list (no randomness — CodSpeed requires deterministic work).
+	const requests = [];
+	for (let i = 0; i < RESOLVES_PER_ITER; i++) {
+		requests.push(`c${i % CHAIN_COUNT}-0`);
+	}
+
+	const resolve = (req) =>
+		new Promise((resolve, reject) => {
+			resolver.resolve({}, fixtureDir, req, {}, (err, result) => {
+				if (err) return reject(err);
+				if (!result) return reject(new Error(`no result for ${req}`));
+				resolve(result);
+			});
+		});
+
+	bench.add(
+		`stack-churn: ${CHAIN_COUNT}x${CHAIN_DEPTH} alias chains, ${RESOLVES_PER_ITER} resolves`,
+		async () => {
+			for (const req of requests) {
+				await resolve(req);
+			}
+		},
+	);
+}

test/resolve-context-stack.test.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { CachedInputFileSystem, ResolverFactory } = require("../");
+
+const nodeFileSystem = new CachedInputFileSystem(fs, 4000);
+
+const fixture = path.resolve(__dirname, "fixtures", "extensions");
+
+describe("resolveContext.stack", () => {
+	const resolver = ResolverFactory.createResolver({
+		extensions: [".ts", ".js"],
+		fileSystem: nodeFileSystem,
+	});
+
+	it("should resolve when no stack is supplied", (done) => {
+		resolver.resolve({}, fixture, "./foo", {}, (err, result) => {
+			if (err) return done(err);
+			expect(result).toBeTruthy();
+			done();
+		});
+	});
+
+	it("should resolve when an empty Set is supplied as stack", (done) => {
+		resolver.resolve(
+			{},
+			fixture,
+			"./foo",
+			{ stack: new Set() },
+			(err, result) => {
+				if (err) return done(err);
+				expect(result).toBeTruthy();
+				done();
+			},
+		);
+	});
+
+	it("should resolve when a non-empty Set is supplied as stack", (done) => {
+		// The values below are arbitrary tokens that must not collide with any
+		// real `resolve` step. Providing them exercises the code path where a
+		// caller pre-seeds the recursion-tracking stack.
+		resolver.resolve(
+			{},
+			fixture,
+			"./foo",
+			{ stack: new Set(["custom-entry-1", "custom-entry-2"]) },
+			(err, result) => {
+				if (err) return done(err);
+				expect(result).toBeTruthy();
+				done();
+			},
+		);
+	});
+
+	it("should detect recursion against entries pre-seeded in the stack", (done) => {
+		// The first stack entry that `resolve` pushes for this request is
+		// `resolve: (…fixture…) ./foo`. Pre-seeding an identical string in
+		// the context must trigger the recursion guard and abort the resolve.
+		const preSeededEntry = `resolve: (${fixture}) ./foo`;
+		resolver.resolve(
+			{},
+			fixture,
+			"./foo",
+			{ stack: new Set([preSeededEntry]) },
+			(err) => {
+				expect(err).toBeTruthy();
+				expect(
+					/** @type {Error & { recursion?: boolean }} */ (err).recursion,
+				).toBe(true);
+				done();
+			},
+		);
+	});
+});