@vitest-agent/plugin 2.0.16 → 2.1.0

package/index.d.ts

@@ -976,8 +976,16 @@ declare function combineClassifiers(...fns: ReadonlyArray<ClassifyFn>): Classify
  * Async file walker that returns matched absolute paths.
  *
  * Walks `dir` recursively via `node:fs/promises`. Skips `node_modules`, `.git`,
- * and `dist` directories. Matches files against the supplied glob patterns
- * relative to `dir` (e.g. `"src/**\/*.test.ts"`).
+ * and `dist` directories, and does not descend past a nested `package.json`
+ * boundary (any directory other than `dir` itself that has its own
+ * `package.json` is treated as an independent unit — its files belong to a
+ * separate discovery pass, not this one). The package-boundary rule applies
+ * to every supplied pattern, not just an unanchored `**\/` one — an anchored
+ * pattern like `"src/**\/*.test.ts"` will not match a test file under a
+ * nested package.json even though the pattern itself never reaches past
+ * `src/`, because the boundary check runs once per directory, independent of
+ * which pattern is being matched. Matches files against the supplied glob
+ * patterns relative to `dir` (e.g. `"src/**\/*.test.ts"`).
  *
  * Returns an empty array if `dir` does not exist or no files match.
  * @param dir - Absolute path to the directory to walk

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "2.0.16",
+	"version": "2.1.0",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -42,10 +42,10 @@
 		"@effect/platform-node": "4.0.0-beta.107",
 		"@effect/sql-sqlite-node": "4.0.0-beta.107",
 		"@effected/workspaces": "^0.11.1",
-		"@vitest-agent/cli": "2.0.16",
-		"@vitest-agent/mcp": "2.1.1",
-		"@vitest-agent/reporter": "2.0.16",
-		"@vitest-agent/sdk": "2.0.16",
+		"@vitest-agent/cli": "2.0.17",
+		"@vitest-agent/mcp": "2.1.2",
+		"@vitest-agent/reporter": "2.0.17",
+		"@vitest-agent/sdk": "2.1.0",
 		"effect": "4.0.0-beta.107",
 		"magic-string": "^1.1.0"
 	},

package/plugin.js

@@ -98,7 +98,7 @@ const aggregatedReporterByVitest = /* @__PURE__ */ new WeakSet();
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "2.0.16";
+const CURRENT_PLUGIN_VERSION = "2.1.0";
 const TEST_FILE_SUFFIX_RE = /\.(?:test|spec)\.(?:ts|tsx|js|jsx)$/;
 const TEST_FILE_DIR_RE = /\/(?:src|__test__)\//;
 const isTestFile = (id) => TEST_FILE_SUFFIX_RE.test(id) && TEST_FILE_DIR_RE.test(id);

package/reporter.js

@@ -7,7 +7,7 @@ import { captureSettings, hashSettings } from "./utils/capture-settings.js";
 import { processFailure } from "./utils/process-failure.js";
 import { routeRenderedOutput } from "./utils/route-rendered-output.js";
 import { stringifyFailureValue } from "./utils/stringify-failure-value.js";
-import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, FormatSelector, HistoryTracker, OutputPipelineLive, PathResolutionLive, buildAgentReport, computeTrend, ensureMigrated, formatFatalError, historyKey, isTimeoutError, probeHostMetadataFromEnv, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/sdk";
+import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, FormatSelector, HistoryTracker, OutputPipelineLive, PathResolutionLive, buildAgentReport, coerceErrorField, computeTrend, ensureMigrated, formatFatalError, historyKey, isTimeoutError, probeHostMetadataFromEnv, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/sdk";
 import { Effect, Option, PubSub } from "effect";
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
@@ -36,6 +36,21 @@ import { DefaultVitestAgentReporter } from "@vitest-agent/reporter";
 * @internal
 */
 const dbPathCache = /* @__PURE__ */ new Map();
+/**
+* Safely read a raw Vitest error object's `stacks` array. The property
+* access itself can throw on hostile shapes (live getters — the same
+* ConfigError class of failure `coerceErrorField` guards); frames are
+* dropped rather than crashing the persistence loop.
+*/
+function readErrorStacks(source) {
+	if (source === null || typeof source !== "object") return void 0;
+	try {
+		const value = source.stacks;
+		return Array.isArray(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
 function resolveDataPathCached(projectDir) {
 	const cached = dbPathCache.get(projectDir);
 	if (cached !== void 0) return cached;
@@ -263,7 +278,9 @@ var AgentReporter = class {
 	*/
 	async onInit(vitest) {
 		this._vitest = vitest;
-		await this.ensureDbPath();
+		try {
+			await this.ensureDbPath();
+		} catch {}
 		await this.initReporters();
 	}
 	/**
@@ -801,7 +818,9 @@ var AgentReporter = class {
 				failCount: fail,
 				skipCount: skip,
 				timeoutCount: timeout,
-				durationMs: totalDuration
+				durationMs: totalDuration,
+				// @vitest-agent/ui, which both populate `collectedModules` on their
+				collectedModules: testModules.length
 			});
 		}
 		const modules = testModules;
@@ -818,11 +837,11 @@ var AgentReporter = class {
 		};
 		const wantsRunEvents = this.wantsRunEvents();
 		let dbPath;
+		let persistDisabled;
 		try {
 			dbPath = await this.ensureDbPath();
 		} catch (err) {
-			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
-			return;
+			persistDisabled = formatFatalError(err);
 		}
 		const filteredModules = opts.projectFilter ? modules.filter((m) => (m.project.name || "default") === opts.projectFilter) : modules;
 		if (filteredModules.length === 0 && opts.projectFilter) return;
@@ -886,14 +905,33 @@ var AgentReporter = class {
 			});
 			return;
 		}
-		mkdirSync(dirname(dbPath), { recursive: true });
+		if (dbPath !== void 0 && persistDisabled === void 0) try {
+			mkdirSync(dirname(dbPath), { recursive: true });
+		} catch (err) {
+			persistDisabled = formatFatalError(err);
+		}
+		let fallbackReports;
 		try {
-			await ensureMigrated(dbPath, logLevel, logFile);
+			const fallbackProjectGroups = /* @__PURE__ */ new Map();
+			for (const mod of filteredModules) {
+				const key = mod.project.name || "default";
+				const existing = fallbackProjectGroups.get(key);
+				if (existing) existing.push(mod);
+				else fallbackProjectGroups.set(key, [mod]);
+			}
+			const isMultiProjectFallback = fallbackProjectGroups.size > 1 || !!opts.projectFilter;
+			fallbackReports = [];
+			for (const [projectName, projectModules] of fallbackProjectGroups) fallbackReports.push(buildAgentReport(projectModules, errors, reason, { omitPassingTests: opts.omitPassingTests }, isMultiProjectFallback ? projectName : void 0));
 		} catch (err) {
 			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 			return;
 		}
-		const program = Effect.gen(function* () {
+		if (dbPath !== void 0 && persistDisabled === void 0) try {
+			await ensureMigrated(dbPath, logLevel, logFile);
+		} catch (err) {
+			persistDisabled = formatFatalError(err);
+		}
+		const persistProgram = Effect.gen(function* () {
 			const store = yield* DataStore;
 			const reader = yield* DataReader;
 			const analyzer = yield* CoverageAnalyzer;
@@ -977,6 +1015,7 @@ var AgentReporter = class {
 					conversationId: null
 				};
 				const hostProbe = probeHostMetadataFromEnv(process.env);
+				const projectReason = reason === "interrupted" ? "interrupted" : baseReport.summary.failed > 0 || baseReport.failedFiles.length > 0 ? "failed" : "passed";
 				const runId = yield* store.writeRun({
 					invocationId,
 					project,
@@ -984,7 +1023,7 @@ var AgentReporter = class {
 					timestamp: baseReport.timestamp,
 					commitSha: process.env.GITHUB_SHA ?? null,
 					branch: process.env.GITHUB_REF_NAME ?? null,
-					reason,
+					reason: projectReason,
 					duration: totalDuration,
 					total: baseReport.summary.total,
 					passed: baseReport.summary.passed,
@@ -1063,7 +1102,17 @@ var AgentReporter = class {
 							const inputs = [];
 							for (let ordinal = 0; ordinal < result.errors.length; ordinal++) {
 								const e = result.errors[ordinal];
-								const { frames, signatureHash } = processFailure(e);
+								const messageText = coerceErrorField(e, "message") ?? "<missing message>";
+								const nameText = coerceErrorField(e, "name");
+								const diffText = coerceErrorField(e, "diff");
+								const stackText = coerceErrorField(e, "stack");
+								const stacksValue = readErrorStacks(e);
+								const { frames, signatureHash } = processFailure({
+									message: messageText,
+									...nameText !== void 0 && { name: nameText },
+									...stackText !== void 0 && { stack: stackText },
+									...stacksValue !== void 0 && { stacks: stacksValue }
+								});
 								if (signatureHash !== null) yield* store.writeFailureSignature({
 									signatureHash,
 									runId,
@@ -1072,10 +1121,10 @@ var AgentReporter = class {
 								inputs.push({
 									testCaseId,
 									scope: "test",
-									message: e.message,
-									...e.name !== void 0 && { name: e.name },
-									...e.diff !== void 0 && { diff: e.diff },
-									...e.stack !== void 0 && { stack: e.stack },
+									message: messageText,
+									...nameText !== void 0 && { name: nameText },
+									...diffText !== void 0 && { diff: diffText },
+									...stackText !== void 0 && { stack: stackText },
 									...signatureHash !== null && { signatureHash },
 									...frames.length > 0 && { frames },
 									ordinal
@@ -1090,7 +1139,16 @@ var AgentReporter = class {
 						const inputs = [];
 						for (let ordinal = 0; ordinal < modErrors.length; ordinal++) {
 							const e = modErrors[ordinal];
-							const { frames, signatureHash } = processFailure(e);
+							const messageText = coerceErrorField(e, "message") ?? "<missing message>";
+							const nameText = coerceErrorField(e, "name");
+							const stackText = coerceErrorField(e, "stack");
+							const stacksValue = readErrorStacks(e);
+							const { frames, signatureHash } = processFailure({
+								message: messageText,
+								...nameText !== void 0 && { name: nameText },
+								...stackText !== void 0 && { stack: stackText },
+								...stacksValue !== void 0 && { stacks: stacksValue }
+							});
 							if (signatureHash !== null) yield* store.writeFailureSignature({
 								signatureHash,
 								runId,
@@ -1099,9 +1157,9 @@ var AgentReporter = class {
 							inputs.push({
 								moduleId,
 								scope: "module",
-								message: e.message,
-								...e.name !== void 0 && { name: e.name },
-								...e.stack !== void 0 && { stack: e.stack },
+								message: messageText,
+								...nameText !== void 0 && { name: nameText },
+								...stackText !== void 0 && { stack: stackText },
 								...signatureHash !== null && { signatureHash },
 								...frames.length > 0 && { frames },
 								ordinal
@@ -1114,7 +1172,16 @@ var AgentReporter = class {
 					const inputs = [];
 					for (let ordinal = 0; ordinal < errors.length; ordinal++) {
 						const e = errors[ordinal];
-						const { frames, signatureHash } = processFailure(e);
+						const messageText = coerceErrorField(e, "message") ?? "<missing message>";
+						const nameText = coerceErrorField(e, "name");
+						const stackText = coerceErrorField(e, "stack");
+						const stacksValue = readErrorStacks(e);
+						const { frames, signatureHash } = processFailure({
+							message: messageText,
+							...nameText !== void 0 && { name: nameText },
+							...stackText !== void 0 && { stack: stackText },
+							...stacksValue !== void 0 && { stacks: stacksValue }
+						});
 						if (signatureHash !== null) yield* store.writeFailureSignature({
 							signatureHash,
 							runId,
@@ -1122,9 +1189,9 @@ var AgentReporter = class {
 						});
 						inputs.push({
 							scope: "unhandled",
-							message: e.message,
-							...e.name !== void 0 && { name: e.name },
-							...e.stack !== void 0 && { stack: e.stack },
+							message: messageText,
+							...nameText !== void 0 && { name: nameText },
+							...stackText !== void 0 && { stack: stackText },
 							...signatureHash !== null && { signatureHash },
 							...frames.length > 0 && { frames },
 							ordinal
@@ -1155,7 +1222,7 @@ var AgentReporter = class {
 						const tcResult = tc.result();
 						if (tcResult?.state === "failed") {
 							const errors = tcResult.errors;
-							errorMap.set(key, errors?.[0]?.message ?? null);
+							errorMap.set(key, coerceErrorField(errors?.[0], "message") ?? null);
 						}
 					}
 				}
@@ -1291,10 +1358,29 @@ var AgentReporter = class {
 				direction: trendSummary.direction,
 				runCount: trendSummary.runCount
 			});
+			const classifications = /* @__PURE__ */ new Map();
+			for (const report of reports) for (const mod of report.failed) for (const test of mod.tests) if (test.classification) classifications.set(test.fullName, test.classification);
 			yield* Effect.logInfo("reports built").pipe(Effect.annotateLogs({
 				count: reports.length,
 				projects: Array.from(projectGroups.keys()).join(", ")
 			}));
+			return {
+				reports,
+				classifications,
+				...trendSummary !== void 0 && { trendSummary }
+			};
+		});
+		let persistFailure;
+		let persistResult;
+		if (persistDisabled === void 0 && dbPath !== void 0) persistResult = await Effect.runPromise(persistProgram.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(ReporterLive(dbPath, logLevel, logFile)))).catch((err) => {
+			persistFailure = formatFatalError(err);
+		});
+		const renderInputData = persistResult ?? {
+			reports: fallbackReports,
+			classifications: /* @__PURE__ */ new Map()
+		};
+		const renderProgram = Effect.gen(function* () {
+			const { reports, classifications, trendSummary } = renderInputData;
 			const detector = yield* EnvironmentDetector;
 			const executorResolver = yield* ExecutorResolver;
 			const formatSelector = yield* FormatSelector;
@@ -1316,8 +1402,6 @@ var AgentReporter = class {
 				format,
 				detail
 			}));
-			const classifications = /* @__PURE__ */ new Map();
-			for (const report of reports) for (const mod of report.failed) for (const test of mod.tests) if (test.classification) classifications.set(test.fullName, test.classification);
 			const githubSummaryFile = process.env.GITHUB_STEP_SUMMARY;
 			const kit = buildReporterKit({
 				env,
@@ -1350,9 +1434,11 @@ var AgentReporter = class {
 			}));
 			for (const output of allOutputs) routeRenderedOutput(output, { ...githubSummaryFile !== void 0 && { githubSummaryFile } });
 		});
-		await Effect.runPromise(program.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(ReporterLive(dbPath, logLevel, logFile)))).catch((err) => {
+		await Effect.runPromise(renderProgram.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(OutputPipelineLive), Effect.provide(NodeServices.layer))).catch((err) => {
 			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 		});
+		const persistError = persistDisabled ?? persistFailure;
+		if (persistError !== void 0) process.stderr.write(`vitest-agent: persistence failed — results above were rendered but NOT recorded: ${persistError}\n`);
 	}
 };
 

package/utils/discover-projects.js

@@ -11,53 +11,113 @@ function recordDiscoveryScanTimestamp() {
 	globalThis[DISCOVERY_LAST_SCAN_SYMBOL] = (/* @__PURE__ */ new Date()).toISOString();
 }
 const _cache = /* @__PURE__ */ new Map();
+const SIGNATURE_SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist"
+]);
+/**
+* Recursively finds every directory named `__test__` under `root` (issue
+* #184: nested `__test__` dirs like `lib/scripts/__test__/` must invalidate
+* the cache too, not just a package-root `__test__/`) and records every
+* nested `package.json` (path + mtime) as a traversal-boundary marker. Skips
+* `node_modules`, `.git`, and `dist` — see `SIGNATURE_SKIP_DIRS`. Stat-only:
+* entries and mtimes are read, never file content. The root's own
+* `package.json` is excluded — it is not a boundary for its own walk, and
+* version bumps would otherwise churn the signature.
+*/
+async function findNestedTestDirs(root) {
+	const testDirs = [];
+	const boundaries = [];
+	await walkForTestDirs(root, root, testDirs, boundaries);
+	return {
+		testDirs: testDirs.sort(),
+		boundaries: boundaries.sort()
+	};
+}
+async function walkForTestDirs(root, dir, testDirs, boundaries) {
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const ent of entries) {
+		const fullPath = join(dir, ent.name);
+		if (ent.isDirectory()) {
+			if (SIGNATURE_SKIP_DIRS.has(ent.name)) continue;
+			if (ent.name === "__test__") testDirs.push(fullPath);
+			await walkForTestDirs(root, fullPath, testDirs, boundaries);
+		} else if (ent.isFile() && ent.name === "package.json" && dir !== root) try {
+			const mtimeMs = (await stat(fullPath)).mtimeMs;
+			boundaries.push(`${toPosixPath(relative(root, fullPath))}:${mtimeMs}`);
+		} catch {}
+	}
+}
 /**
 * Computes a cheap signature (relative path + mtimeMs pairs, sorted) for every
 * file nested under `dirPath`. Used to detect added/removed/moved/renamed test
 * files between `discoverProjects` calls without re-walking test-file globs.
 * Returns an empty string when `dirPath` does not exist — this still produces
 * a stable, comparable signature contribution.
+*
+* Manual per-directory walk (not a single `readdir({ recursive: true })`
+* call) pruning `SIGNATURE_SKIP_DIRS` *before* recursing — same reasoning as
+* `findNestedTestDirs`: a found `__test__` dir can itself contain a fixture
+* `node_modules` (e.g. a subprocess-e2e fixture that installs deps), and
+* Node's recursive `readdir` follows symlinked directories, so an unguarded
+* call would walk into it.
 */
 async function computeDirSignature(dirPath) {
+	const parts = [];
+	await walkDirSignature(dirPath, dirPath, parts);
+	parts.sort();
+	return parts.join("|");
+}
+async function walkDirSignature(root, dir, parts) {
 	let entries;
 	try {
-		entries = await readdir(dirPath, {
-			withFileTypes: true,
-			recursive: true
-		});
+		entries = await readdir(dir, { withFileTypes: true });
 	} catch {
-		return "";
+		return;
 	}
-	const parts = [];
 	for (const ent of entries) {
-		if (!ent.isFile()) continue;
-		const parentPath = ent.parentPath ?? dirPath;
-		const fullPath = join(parentPath, ent.name);
-		let mtimeMs;
-		try {
-			mtimeMs = (await stat(fullPath)).mtimeMs;
-		} catch {
-			continue;
+		const fullPath = join(dir, ent.name);
+		if (ent.isDirectory()) {
+			if (SIGNATURE_SKIP_DIRS.has(ent.name)) continue;
+			await walkDirSignature(root, fullPath, parts);
+		} else if (ent.isFile()) {
+			let mtimeMs;
+			try {
+				mtimeMs = (await stat(fullPath)).mtimeMs;
+			} catch {
+				continue;
+			}
+			const relPath = toPosixPath(relative(root, fullPath));
+			parts.push(`${relPath}:${mtimeMs}`);
 		}
-		const relPath = toPosixPath(relative(dirPath, fullPath));
-		parts.push(`${relPath}:${mtimeMs}`);
 	}
-	parts.sort();
-	return parts.join("|");
 }
 /**
 * Computes a cheap whole-workspace directory signature by combining each
-* package's `src/` and `__test__/` signatures (issue #100). Only entries +
-* mtimes are read — no file content — so this stays fast even for large
-* monorepos. A changed signature means a test file was added, removed,
-* moved, or renamed since the cached result was computed.
+* package's `src/` signature with every nested `__test__/` dir's signature
+* (issue #100, extended by issue #184 to see `__test__` dirs at any depth,
+* not just a package-root `__test__/`). Only entries + mtimes are read — no
+* file content — so this stays fast even for large monorepos. A changed
+* signature means a test file was added, removed, moved, or renamed since
+* the cached result was computed.
 */
 async function computeWorkspaceSignature(packages) {
 	const parts = [];
 	for (const pkg of packages) {
 		const srcSig = await computeDirSignature(join(pkg.path, "src"));
-		const testDirSig = await computeDirSignature(join(pkg.path, "__test__"));
-		parts.push(`${pkg.path}::src=${srcSig}::__test__=${testDirSig}`);
+		const { testDirs, boundaries } = await findNestedTestDirs(pkg.path);
+		const testDirParts = [];
+		for (const dir of testDirs) {
+			const sig = await computeDirSignature(dir);
+			testDirParts.push(`${toPosixPath(relative(pkg.path, dir))}=${sig}`);
+		}
+		parts.push(`${pkg.path}::src=${srcSig}::__test__=${testDirParts.join(";")}::boundaries=${boundaries.join(";")}`);
 	}
 	return parts.join("\n");
 }

package/utils/discover-strategy.js

@@ -16,13 +16,6 @@ const TEST_DIR_HELPER_DIRS = [
 	"fixtures",
 	"snapshots"
 ];
-async function isDir(p) {
-	try {
-		return (await stat(p)).isDirectory();
-	} catch {
-		return false;
-	}
-}
 async function isFile(p) {
 	try {
 		return (await stat(p)).isFile();
@@ -123,17 +116,19 @@ var DefaultDiscoverStrategy = class extends DiscoverStrategy {
 		return ["unit"];
 	}
 	async buildProject(input) {
-		const hasTestDir = await isDir(join(input.path, "__test__"));
 		const srcPrefix = join(input.path, "src");
-		const testPrefix = join(input.path, "__test__");
-		const allFiles = await findTestFiles(input.path, ["src/**/*.{test,spec}.{ts,tsx,js,jsx}", "__test__/**/*.{test,spec}.{ts,tsx,js,jsx}"]);
+		const allFiles = await findTestFiles(input.path, ["src/**/*.{test,spec}.{ts,tsx,js,jsx}", "**/__test__/**/*.{test,spec}.{ts,tsx,js,jsx}"]);
 		if (allFiles.length === 0) return null;
 		const hasSrcTests = allFiles.some((f) => f.startsWith(`${srcPrefix}${sep}`) || f === srcPrefix);
-		const hasTestDirTests = allFiles.some((f) => f.startsWith(`${testPrefix}${sep}`) || f === testPrefix);
+		const hasTestDirTests = allFiles.some((f) => !(f.startsWith(`${srcPrefix}${sep}`) || f === srcPrefix));
 		const include = [];
 		if (hasSrcTests) include.push(join(input.path, "src/**/*.{test,spec}.{ts,tsx,js,jsx}"));
-		if (hasTestDirTests) include.push(join(input.path, "__test__/**/*.{test,spec}.{ts,tsx,js,jsx}"));
-		const exclude = hasTestDir ? [...configDefaults.exclude, ...TEST_DIR_HELPER_DIRS.map((d) => join(input.path, `__test__/${d}/**`))] : void 0;
+		if (hasTestDirTests) include.push(join(input.path, "**/__test__/**/*.{test,spec}.{ts,tsx,js,jsx}"));
+		const exclude = hasTestDirTests ? [
+			...configDefaults.exclude,
+			join(input.path, "**/dist/**"),
+			...TEST_DIR_HELPER_DIRS.map((d) => join(input.path, `**/__test__/${d}/**`))
+		] : void 0;
 		const setupFile = await detectSetupFile(input.path);
 		return {
 			extends: true,

package/utils/find-test-files.js

@@ -57,8 +57,16 @@ function toRegexFragment(glob) {
 * Async file walker that returns matched absolute paths.
 *
 * Walks `dir` recursively via `node:fs/promises`. Skips `node_modules`, `.git`,
-* and `dist` directories. Matches files against the supplied glob patterns
-* relative to `dir` (e.g. `"src/**\/*.test.ts"`).
+* and `dist` directories, and does not descend past a nested `package.json`
+* boundary (any directory other than `dir` itself that has its own
+* `package.json` is treated as an independent unit — its files belong to a
+* separate discovery pass, not this one). The package-boundary rule applies
+* to every supplied pattern, not just an unanchored `**\/` one — an anchored
+* pattern like `"src/**\/*.test.ts"` will not match a test file under a
+* nested package.json even though the pattern itself never reaches past
+* `src/`, because the boundary check runs once per directory, independent of
+* which pattern is being matched. Matches files against the supplied glob
+* patterns relative to `dir` (e.g. `"src/**\/*.test.ts"`).
 *
 * Returns an empty array if `dir` does not exist or no files match.
 * @param dir - Absolute path to the directory to walk
@@ -80,6 +88,7 @@ async function walkDir(root, dir, matchers, results) {
 	} catch {
 		return;
 	}
+	if (dir !== root && entries.some((ent) => ent.isFile() && ent.name === "package.json")) return;
 	for (const ent of entries) {
 		if (SKIP_DIRS.has(ent.name)) continue;
 		const fullPath = join(dir, ent.name);

package/utils/stringify-failure-value.js

@@ -28,7 +28,11 @@ const stringifyFailureValue = (value) => {
 	try {
 		return JSON.stringify(value);
 	} catch {
-		return String(value);
+		try {
+			return String(value);
+		} catch {
+			return "<unserializable value>";
+		}
 	}
 };