@isentinel/jest-roblox 0.3.0 → 0.3.2

package/dist/sea-entry.cjs

@@ -686,7 +686,7 @@ function C$4({ force: e } = {}) {
 var y$3 = C$4();
 //#endregion
 //#region package.json
-var version = "0.3.0";
+var version = "0.3.2";
 //#endregion
 //#region src/config/errors.ts
 var ConfigError = class extends Error {
@@ -5332,6 +5332,11 @@ async function findWorkspaceDir(id = process.cwd(), options = {}) {
 	throw new Error(`Cannot detect workspace root from ${id}`);
 }
 //#endregion
+//#region \0sea-stub:giget
+var require__sea_stub_giget = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+//#endregion
 //#region node_modules/.pnpm/c12@4.0.0-beta.5_jiti@2.7.0_magicast@0.5.3/node_modules/c12/dist/_chunks/libs/ohash.mjs
 var ohash_exports = /* @__PURE__ */ __exportAll$1({
 	n: () => dist_exports,
@@ -11261,7 +11266,7 @@ async function resolveConfig$1(source, options, sourceOptions = {}) {
 	const customProviderKeys = Object.keys(sourceOptions.giget?.providers || {}).map((key) => `${key}:`);
 	const gigetPrefixes = customProviderKeys.length > 0 ? [...new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
 	if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
-		const { downloadTemplate } = await import("giget").catch((error) => {
+		const { downloadTemplate } = await Promise.resolve().then(() => /* @__PURE__ */ __toESM(require__sea_stub_giget(), 1)).catch((error) => {
 			throw new Error(`Extending config from \`${source}\` requires \`giget\` peer dependency to be installed.\n\nInstall it with: \`npx nypm i giget\``, { cause: error });
 		});
 		const { digest } = await Promise.resolve().then(() => (init_ohash(), ohash_exports)).then((n) => n.n);
@@ -20145,12 +20150,35 @@ function mapBranchArmLocations(traceMap, locations, sourceMapDirectory) {
 		tsPath
 	};
 }
+/**
+* Detects a phantom branch arm produced by a source-less synthetic statement
+* `if` (e.g. a roblox-ts Array polyfill like `.filter`/`.includes`). The
+* synthetic `if` has no source map entry, so trace-mapping's greatest-lower-
+* bound bias snaps both arms onto the nearest preceding segment — the then-
+* arm's own start — yielding a zero-width arm that coincides with another
+* arm's start and can never be covered.
+*
+* A genuine statement `if` is safe: roblox-ts always renders it multi-line, so
+* the then-body (generated line `if+1`) and the implicit-else arm (generated
+* line `if`) carry distinct source-map segments and never collapse. This is
+* gated to `type === "if"` by the caller: a single-line `expr-if` (ternary)
+* legitimately collapses to one column-0 segment and must NOT be dropped.
+*/
+function hasCollapsedPhantomArm(locations) {
+	return locations.some((arm, index) => {
+		if (!(arm.start.line === arm.end.line && arm.start.column === arm.end.column)) return false;
+		return locations.some((other, otherIndex) => {
+			return otherIndex !== index && other.start.line === arm.start.line && other.start.column === arm.start.column;
+		});
+	});
+}
 function mapFileBranches(resources, fileCoverage, pendingBranches) {
 	if (resources.coverageMap.branchMap === void 0) return;
 	for (const [branchId, entry] of Object.entries(resources.coverageMap.branchMap)) {
 		const armHitCounts = fileCoverage.b?.[branchId] ?? [];
 		const result = mapBranchArmLocations(resources.traceMap, entry.locations, resources.sourceMapDirectory);
 		if (result === void 0) continue;
+		if (entry.type === "if" && hasCollapsedPhantomArm(result.locations)) continue;
 		let fileBranches = pendingBranches.get(result.tsPath);
 		if (fileBranches === void 0) {
 			fileBranches = [];
@@ -24412,6 +24440,7 @@ function convertToLuau(filePath) {
 const RbxPathParent = Symbol("Parent");
 var RojoResolver = class RojoResolver {
 	rbxPath = new Array();
+	realpathCache = /* @__PURE__ */ new Map();
 	walkedConfigFilesInternal = /* @__PURE__ */ new Set();
 	walkedDirectoriesInternal = /* @__PURE__ */ new Set();
 	filePathToRbxPathMap = /* @__PURE__ */ new Map();
@@ -24422,12 +24451,12 @@ var RojoResolver = class RojoResolver {
 	static findRojoConfigFilePath(projectPath) {
 		const warnings = new Array();
 		const defaultPath = node_path.default.join(projectPath, ROJO_DEFAULT_NAME);
-		if ((0, node_fs.existsSync)(defaultPath)) return {
+		if (node_fs.existsSync(defaultPath)) return {
 			path: defaultPath,
 			warnings
 		};
 		const candidates = new Array();
-		for (const fileName of (0, node_fs.readdirSync)(projectPath)) if (fileName !== ROJO_DEFAULT_NAME && (fileName === ROJO_OLD_NAME || ROJO_FILE_REGEX.test(fileName))) candidates.push(node_path.default.join(projectPath, fileName));
+		for (const fileName of node_fs.readdirSync(projectPath)) if (fileName !== ROJO_DEFAULT_NAME && (fileName === ROJO_OLD_NAME || ROJO_FILE_REGEX.test(fileName))) candidates.push(node_path.default.join(projectPath, fileName));
 		if (candidates.length > 1) warnings.push(`Multiple *.project.json files found, using ${candidates[0]}`);
 		return {
 			path: candidates[0],
@@ -24563,34 +24592,42 @@ var RojoResolver = class RojoResolver {
 	get walkedDirectories() {
 		return this.walkedDirectoriesInternal;
 	}
+	cachedRealpath(targetPath) {
+		let resolved = this.realpathCache.get(targetPath);
+		if (resolved === void 0) {
+			resolved = node_fs.realpathSync(targetPath);
+			this.realpathCache.set(targetPath, resolved);
+		}
+		return resolved;
+	}
 	getContainer(from, rbxPath) {
 		if (this.isGame && rbxPath) {
 			for (const container of from) if (arrayStartsWith(rbxPath, container)) return container;
 		}
 	}
 	parseConfig(rojoConfigFilePath, doNotPush = false) {
-		if (!(0, node_fs.existsSync)(rojoConfigFilePath)) {
+		if (!node_fs.existsSync(rojoConfigFilePath)) {
 			this.warn(`RojoResolver: Path does not exist "${rojoConfigFilePath}"`);
 			return;
 		}
-		const realPath = (0, node_fs.realpathSync)(rojoConfigFilePath);
+		const realPath = this.cachedRealpath(rojoConfigFilePath);
 		this.walkedConfigFilesInternal.add(realPath);
 		let configJson;
 		try {
-			configJson = JSON.parse((0, node_fs.readFileSync)(realPath, "utf8"));
+			configJson = JSON.parse(node_fs.readFileSync(realPath, "utf8"));
 		} catch {}
 		if (isValidRojoConfig(configJson)) this.parseTree(node_path.default.dirname(rojoConfigFilePath), configJson.name, configJson.tree, doNotPush);
 		else this.warn("RojoResolver: Invalid configuration!");
 	}
 	parsePath(itemPath) {
 		const luauPath = convertToLuau(itemPath);
-		const realPath = (0, node_fs.existsSync)(luauPath) ? (0, node_fs.realpathSync)(luauPath) : luauPath;
+		const realPath = node_fs.existsSync(luauPath) ? this.cachedRealpath(luauPath) : luauPath;
 		const extension = node_path.default.extname(luauPath);
 		if (ROJO_MODULE_EXTS.has(extension)) this.filePathToRbxPathMap.set(luauPath, [...this.rbxPath]);
 		else {
-			const isDirectory = (0, node_fs.existsSync)(realPath) && (0, node_fs.statSync)(realPath).isDirectory();
+			const isDirectory = node_fs.existsSync(realPath) && node_fs.statSync(realPath).isDirectory();
 			if (isDirectory) this.walkedDirectoriesInternal.add(realPath);
-			if (isDirectory && (0, node_fs.readdirSync)(realPath).includes(ROJO_DEFAULT_NAME)) this.parseConfig(node_path.default.join(luauPath, ROJO_DEFAULT_NAME), true);
+			if (isDirectory && node_fs.readdirSync(realPath).includes(ROJO_DEFAULT_NAME)) this.parseConfig(node_path.default.join(luauPath, ROJO_DEFAULT_NAME), true);
 			else {
 				this.partitions.unshift({
 					fsPath: luauPath,
@@ -24607,26 +24644,40 @@ var RojoResolver = class RojoResolver {
 		for (const childName of Object.keys(tree).filter((value) => !value.startsWith("$"))) this.parseTree(basePath, childName, tree[childName]);
 		if (!doNotPush) this.rbxPath.pop();
 	}
-	searchChildren(directory, children) {
-		for (const child of children) {
-			const childPath = node_path.default.join(directory, child);
-			if ((0, node_fs.statSync)((0, node_fs.realpathSync)(childPath)).isFile() && child !== ROJO_DEFAULT_NAME && ROJO_FILE_REGEX.test(child)) this.parseConfig(childPath);
-		}
-		for (const child of children) {
-			const childPath = node_path.default.join(directory, child);
-			if ((0, node_fs.statSync)((0, node_fs.realpathSync)(childPath)).isDirectory()) this.searchDirectory(childPath, child);
+	searchChildren(directory, directoryEntries) {
+		const projectFiles = new Array();
+		const subDirectories = new Array();
+		for (const entry of directoryEntries) {
+			const childPath = node_path.default.join(directory, entry.name);
+			let isFile = entry.isFile();
+			let isDirectory = entry.isDirectory();
+			if (!isFile && !isDirectory) try {
+				const stat = node_fs.statSync(this.cachedRealpath(childPath));
+				isFile = stat.isFile();
+				isDirectory = stat.isDirectory();
+			} catch (err) {
+				this.warn(`RojoResolver: Failed to resolve "${childPath}" (${err.message})`);
+				continue;
+			}
+			if (isFile && ROJO_FILE_REGEX.test(entry.name)) projectFiles.push(childPath);
+			else if (isDirectory) subDirectories.push({
+				name: entry.name,
+				path: childPath
+			});
 		}
+		for (const childPath of projectFiles) this.parseConfig(childPath);
+		for (const { name, path: childPath } of subDirectories) this.searchDirectory(childPath, name);
 	}
 	searchDirectory(directory, item) {
-		const realPath = (0, node_fs.realpathSync)(directory);
+		const realPath = this.cachedRealpath(directory);
 		this.walkedDirectoriesInternal.add(realPath);
-		const children = (0, node_fs.readdirSync)(realPath);
-		if (children.includes(ROJO_DEFAULT_NAME)) {
+		const directoryEntries = node_fs.readdirSync(directory, { withFileTypes: true });
+		if (directoryEntries.some((entry) => entry.name === ROJO_DEFAULT_NAME)) {
 			this.parseConfig(node_path.default.join(directory, ROJO_DEFAULT_NAME));
 			return;
 		}
 		if (item !== void 0) this.rbxPath.push(item);
-		this.searchChildren(directory, children);
+		this.searchChildren(directory, directoryEntries);
 		if (item !== void 0) this.rbxPath.pop();
 	}
 	warn(str) {
@@ -25891,6 +25942,7 @@ function findMapping(filePath, mappings, key = "outDir") {
 }
 function replacePrefix(filePath, from, to) {
 	if (filePath === from) return to;
+	if (from === ".") return `${to}/${filePath.startsWith("./") ? filePath.slice(2) : filePath}`;
 	if (filePath.startsWith(`${from}/`)) return `${to}${filePath.slice(from.length)}`;
 	return filePath;
 }
@@ -26730,7 +26782,7 @@ var core_default = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 			}
 		});
 	};
-	var MODES = /* @__PURE__ */ Object.freeze({
+	var MODES = /*#__PURE__*/ Object.freeze({
 		__proto__: null,
 		APOS_STRING_MODE,
 		BACKSLASH_ESCAPE,
@@ -29027,7 +29079,7 @@ function formatTestSummary(result, timing, styles, options) {
 }
 function formatResult(result, timing, options) {
 	const styles = createStyles(options.color, options.slowTestThreshold);
-	const lines = [formatRunHeader(options, styles)];
+	const lines = [""];
 	for (const file of result.testResults) {
 		if (options.failuresOnly === true && file.numFailingTests === 0 && !hasExecError(file)) continue;
 		lines.push(formatFileSummary(file, options, styles));
@@ -29201,7 +29253,7 @@ function formatMultiProjectResult(projects, timing, options) {
 		result,
 		styles
 	}));
-	const lines = [formatRunHeader(options, styles), sections.join("\n\n")];
+	const lines = ["", sections.join("\n\n")];
 	const mergedResult = mergeJestResults(projects.map((project) => project.result));
 	lines.push("", formatTestSummary(mergedResult, timing, styles, {
 		snapshotWriteFailures: options.snapshotWriteFailures,
@@ -30008,6 +30060,15 @@ function hasFormatter(formatters, name) {
 function usesAgentFormatter(formatters, verbose = false) {
 	return hasFormatter(formatters, "agent") && !verbose;
 }
+/**
+* Whether human-facing progress output (the run header, the "Running X of Y"
+* notice, the workspace streaming lines) should be written: not silent and not
+* a machine-readable formatter (json, or non-verbose agent). The single source
+* of truth so these sinks can't drift apart.
+*/
+function isDefaultHumanFormatter(options) {
+	return options.silent !== true && !usesAgentFormatter(options.formatters, options.verbose) && !hasFormatter(options.formatters, "json");
+}
 //#endregion
 //#region src/snapshot/path-resolver.ts
 function createSnapshotPathResolver(config) {
@@ -30020,7 +30081,7 @@ function createSnapshotPathResolver(config) {
 			const result = `${basePath}/${normalized.slice(prefix.length + 1)}`;
 			const mapping = findMapping(result, tsconfigMappings);
 			if (mapping !== void 0) return {
-				filePath: replacePrefix(result, mapping.outDir, mapping.rootDir).replace(/^\.\//, ""),
+				filePath: replacePrefix(result, mapping.outDir, mapping.rootDir),
 				mapping
 			};
 			return { filePath: result };
@@ -30040,6 +30101,96 @@ function buildMappings(tree, prefix) {
 	return mappings;
 }
 //#endregion
+//#region src/timing/orchestration-collector.ts
+/**
+* A buffered span-tree profiler for a single, sequential host run. Nesting is
+* tracked with one shared stack, so spans must open and close in LIFO order:
+* profile a phase, and any spans it opens nest under it. It is NOT safe to run
+* two `profile` / `profileAsync` calls concurrently on the same collector (e.g.
+* `Promise.all`) — interleaved opens/closes would corrupt the stack. Create one
+* collector per run; `flushTimingReport` empties it so a second flush is a
+* no-op.
+*/
+function createTimingCollector(options = {}) {
+	const clock = options.clock ?? { now: () => node_perf_hooks.performance.now() };
+	const sink = options.sink ?? ((line) => void node_process.default.stderr.write(`${line}\n`));
+	const enabled = options.enabled ?? node_process.default.env["TIMING"] !== void 0;
+	const roots = /* @__PURE__ */ new Map();
+	const stack = [];
+	function open(name) {
+		const top = stack.at(-1);
+		const node = childOf(top === void 0 ? roots : top.children, name);
+		stack.push(node);
+		const start = clock.now();
+		return () => {
+			node.elapsedMs += clock.now() - start;
+			stack.pop();
+		};
+	}
+	function profile(name, func) {
+		if (!enabled) return func();
+		const close = open(name);
+		try {
+			return func();
+		} finally {
+			close();
+		}
+	}
+	async function profileAsync(name, func) {
+		if (!enabled) return func();
+		const close = open(name);
+		try {
+			return await func();
+		} finally {
+			close();
+		}
+	}
+	function record(name, elapsedMs) {
+		if (!enabled) return;
+		const top = stack.at(-1);
+		const node = childOf(top === void 0 ? roots : top.children, name);
+		node.elapsedMs += elapsedMs;
+	}
+	function emit(node, depth) {
+		sink(`[TIMING] ${"  ".repeat(depth)}${node.name}: ${String(Math.round(node.elapsedMs))}ms`);
+		for (const child of node.children.values()) emit(child, depth + 1);
+	}
+	function flushTimingReport() {
+		if (!enabled || roots.size === 0) return;
+		let total = 0;
+		for (const node of roots.values()) {
+			emit(node, 0);
+			total += Math.round(node.elapsedMs);
+		}
+		sink(`[TIMING] TOTAL (host): ${String(total)}ms`);
+		roots.clear();
+	}
+	return {
+		flushTimingReport,
+		profile,
+		profileAsync,
+		record
+	};
+}
+/**
+* Shared disabled collector for callers that thread a profiler through their
+* signatures but are invoked outside a profiled workspace run (single-mode
+* coverage, the `instrument` subcommand, tests). Every method is a no-op.
+*/
+const NOOP_TIMING_COLLECTOR = createTimingCollector({ enabled: false });
+function childOf(parent, name) {
+	let node = parent.get(name);
+	if (node === void 0) {
+		node = {
+			name,
+			children: /* @__PURE__ */ new Map(),
+			elapsedMs: 0
+		};
+		parent.set(name, node);
+	}
+	return node;
+}
+//#endregion
 //#region src/types/rojo.ts
 const rojoProjectSchema = type({
 	"name": "string",
@@ -30189,38 +30340,48 @@ function formatExecuteOutput(options) {
 * config.
 */
 async function runProjects(options) {
-	const jobs = options.projects.map((project) => buildProjectJob(project));
-	const { rawResults, timing: backendTiming } = await options.backend.runTests({
-		jobs,
-		parallel: options.parallel,
-		scriptOverride: options.scriptOverride,
-		streaming: options.streaming,
-		workStealing: options.workStealing
+	const timing = options.timing ?? NOOP_TIMING_COLLECTOR;
+	const jobs = timing.profile("buildJobs", () => {
+		return options.projects.map((project) => buildProjectJob(project, timing));
+	});
+	const { rawResults, timing: backendTiming } = await timing.profileAsync("backend.runTests", async () => {
+		const result = await options.backend.runTests({
+			jobs,
+			parallel: options.parallel,
+			scriptOverride: options.scriptOverride,
+			streaming: options.streaming,
+			workStealing: options.workStealing
+		});
+		recordBackendTimingSpans(timing, result.timing);
+		return result;
 	});
 	if (rawResults.length !== jobs.length) throw new Error(`Backend returned ${rawResults.length.toString()} results for ${jobs.length.toString()} jobs — rawResults must be parallel to jobs`);
 	return {
 		backendTiming,
-		results: rawResults.map((raw, index) => {
-			const job = jobs[index];
-			try {
-				return processProjectResult(buildProjectResult(raw.entry, job, raw.fallbackGameOutput), {
-					backendTiming,
-					config: job.config,
-					deferFormatting: options.deferFormatting,
-					startTime: options.startTime,
-					version: options.version
-				});
-			} catch (err) {
-				if (!(err instanceof LuauScriptError)) throw err;
-				return buildExecutionErrorResult({
-					backendTiming,
-					config: job.config,
-					deferFormatting: options.deferFormatting,
-					error: err,
-					startTime: options.startTime,
-					version: options.version
-				});
-			}
+		results: timing.profile("processResults", () => {
+			return rawResults.map((raw, index) => {
+				const job = jobs[index];
+				try {
+					return processProjectResult(buildProjectResult(raw.entry, job, raw.fallbackGameOutput), {
+						backendTiming,
+						config: job.config,
+						deferFormatting: options.deferFormatting,
+						startTime: options.startTime,
+						timing,
+						version: options.version
+					});
+				} catch (err) {
+					if (!(err instanceof LuauScriptError)) throw err;
+					return buildExecutionErrorResult({
+						backendTiming,
+						config: job.config,
+						deferFormatting: options.deferFormatting,
+						error: err,
+						startTime: options.startTime,
+						version: options.version
+					});
+				}
+			});
 		})
 	};
 }
@@ -30261,6 +30422,10 @@ function parseTsconfigMappings(options) {
 		rootDir: normalizeDirectoryPath(options.rootDir ?? "src")
 	}];
 }
+function recordBackendTimingSpans(timing, backendTiming) {
+	if (backendTiming.uploadMs !== void 0) timing.record("uploadMs", backendTiming.uploadMs);
+	timing.record("executionMs", backendTiming.executionMs);
+}
 const EXIT_CODE_MESSAGE$1 = /^Exited with code: \d+$/;
 /**
 * Compose the human-readable failure message for an exec-error file
@@ -30461,7 +30626,7 @@ function writeSnapshots(snapshotWrites, config, tsconfigMappings) {
 			node_fs.writeFileSync(absolutePath, content);
 			const { filePath, mapping } = resolved;
 			if (mapping !== void 0) {
-				const outPath = mapping.outDir + filePath.slice(mapping.rootDir.length);
+				const outPath = replacePrefix(filePath, mapping.rootDir, mapping.outDir);
 				const absoluteOutPath = node_path.resolve(config.rootDir, outPath);
 				node_fs.mkdirSync(node_path.dirname(absoluteOutPath), { recursive: true });
 				node_fs.writeFileSync(absoluteOutPath, content);
@@ -30490,19 +30655,23 @@ function writeSnapshots(snapshotWrites, config, tsconfigMappings) {
 * formatter output. Called once per job.
 */
 function processProjectResult(entry, options) {
-	const { backendTiming, config, deferFormatting, startTime, version } = options;
+	const { backendTiming, config, deferFormatting, startTime, timing, version } = options;
 	const { coverageData, gameOutput, luauTiming, result, setupMs, snapshotWrites } = entry;
-	const tsconfigMappings = resolveAllTsconfigMappings(config.rootDir);
-	const writeCounts = snapshotWrites !== void 0 ? writeSnapshots(snapshotWrites, config, tsconfigMappings) : {
+	const tsconfigMappings = timing.profile("resolveTsconfigMappings", () => {
+		return resolveAllTsconfigMappings(config.rootDir);
+	});
+	const writeCounts = snapshotWrites !== void 0 ? timing.profile("writeSnapshots", () => {
+		return writeSnapshots(snapshotWrites, config, tsconfigMappings);
+	}) : {
 		attempted: 0,
 		failed: 0,
 		written: 0
 	};
 	const testsMs = calculateTestsMs(result.testResults);
-	const sourceMapper = config.sourceMap ? buildSourceMapper(config, tsconfigMappings) : void 0;
+	const sourceMapper = config.sourceMap ? timing.profile("buildSourceMapper", () => buildSourceMapper(config, tsconfigMappings)) : void 0;
 	resolveTestFilePaths(result, sourceMapper);
 	const totalMs = Date.now() - startTime;
-	const timing = {
+	const resultTiming = {
 		executionMs: backendTiming.executionMs,
 		setupMs,
 		startTime,
@@ -30515,7 +30684,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed,
 		sourceMapper,
-		timing,
+		timing: resultTiming,
 		version
 	}) : "";
 	if (luauTiming !== void 0) printLuauTiming(luauTiming);
@@ -30527,7 +30696,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed > 0 ? writeCounts.failed : void 0,
 		sourceMapper,
-		timing
+		timing: resultTiming
 	};
 }
 /**
@@ -30535,8 +30704,10 @@ function processProjectResult(entry, options) {
 * carries its own config so the Luau runner never re-resolves or shares format
 * state across projects (fixes the spike's snapshot-diff regression — C1).
 */
-function buildProjectJob(parameters) {
-	const tsconfigMappings = resolveAllTsconfigMappings(parameters.config.rootDir);
+function buildProjectJob(parameters, timing) {
+	const tsconfigMappings = timing.profile("resolveTsconfigMappings", () => {
+		return resolveAllTsconfigMappings(parameters.config.rootDir);
+	});
 	const luauProject = isLuauProject(parameters.testFiles, tsconfigMappings);
 	return {
 		config: applySnapshotFormatDefaults(parameters.config, luauProject),
@@ -37331,7 +37502,10 @@ var OcaleRunner = class {
 			script,
 			timeoutSeconds,
 			universeId: this.credentials.universeId
-		}, { timeoutMs: timeout });
+		}, {
+			retryableTransportCodes: TRANSIENT_TRANSPORT_CODES,
+			timeoutMs: timeout
+		});
 		if (!result.success) {
 			if (result.err instanceof PollTimeoutError) throw new Error("Execution timed out", { cause: result.err });
 			throw new Error(result.err.message, { cause: result.err });
@@ -37353,7 +37527,7 @@ var OcaleRunner = class {
 			placeId: this.credentials.placeId,
 			universeId: this.credentials.universeId
 		};
-		const result = await this.places.save(parameters);
+		const result = await this.places.save(parameters, { retryableTransportCodes: TRANSIENT_TRANSPORT_CODES });
 		if (!result.success) throw new Error(`Failed to upload place: ${result.err.message}`, { cause: result.err });
 		return {
 			uploadMs: Date.now() - uploadStart,
@@ -37471,6 +37645,35 @@ function generateTestScript(options) {
 	return test_runner_bundled_default.replace("__CONFIG_JSON__", () => JSON.stringify({ configs }));
 }
 //#endregion
+//#region src/utils/error-chain.ts
+const MAX_DEPTH = 5;
+function walkErrorChain(err) {
+	const entries = [];
+	let current = err;
+	while (current instanceof Error && entries.length < MAX_DEPTH) {
+		entries.push({
+			name: current.constructor.name,
+			code: readStringProperty(current, "code"),
+			errno: readStringProperty(current, "errno"),
+			message: current.message,
+			requiredScopes: current instanceof PermissionError ? current.requiredScopes : void 0,
+			syscall: readStringProperty(current, "syscall")
+		});
+		current = current.cause;
+	}
+	return entries;
+}
+function formatMissingScopes(scopes) {
+	if (scopes.length === 0) return "API key has insufficient scopes. Add via Creator Dashboard.";
+	const joined = scopes.join(", ");
+	return `API key missing scope${scopes.length === 1 ? "" : "s"} ${joined}. Add via Creator Dashboard.`;
+}
+function readStringProperty(err, key) {
+	const value = Reflect.get(err, key);
+	if (value === void 0 || value === null) return;
+	return String(value);
+}
+//#endregion
 //#region src/backends/open-cloud.ts
 const PARALLEL_AUTO_CAP = 3;
 const BASE_URL_ENV = "JEST_ROBLOX_OPEN_CLOUD_BASE_URL";
@@ -37606,10 +37809,7 @@ function createOpenCloudBackend(credentials) {
 }
 function describeError(err) {
 	const cause = err instanceof Error ? err.cause : void 0;
-	if (cause instanceof PermissionError) {
-		const scopes = cause.requiredScopes.join(", ");
-		return `API key missing scope${cause.requiredScopes.length === 1 ? "" : "s"} ${scopes}. Add via Creator Dashboard.`;
-	}
+	if (cause instanceof PermissionError) return formatMissingScopes(cause.requiredScopes);
 	return err instanceof Error ? err.message : String(err);
 }
 function warnStreamingDisabled(err, state) {
@@ -38382,6 +38582,27 @@ function narrowConfigByFiles(config, files) {
 		testPathPattern: `(${branches.join("|")})`
 	};
 }
+/**
+* Forward an Instance-namespace `testPathPattern` to the Luau runner.
+*
+* Node-side discovery is the source of truth: the FS-namespace filter
+* (positional args or `--testPathPattern`) has already resolved to a concrete
+* file set against real paths. Drop the raw FS-shaped pattern and re-narrow by
+* the discovered files so Jest-on-Roblox matches the same files — its paths are
+* Roblox Instance names (e.g. `ServerScriptService/...`) with no `src/` prefix,
+* so a raw FS pattern like `src/server/foo.spec` matches zero files there.
+*
+* `filterActive` gates the rewrite: a bare run (no positionals, no
+* `testPathPattern`) leaves the config untouched so the Luau side runs every
+* `testMatch` file rather than a giant basename alternation.
+*/
+function narrowForLuauRun(config, runtimeFiles, filterActive) {
+	if (!filterActive) return config;
+	return narrowConfigByFiles({
+		...config,
+		testPathPattern: void 0
+	}, runtimeFiles);
+}
 function toBasenamePattern(file) {
 	const posix = file.replaceAll("\\", "/");
 	const lastSlash = posix.lastIndexOf("/");
@@ -38915,89 +39136,6 @@ function buildWithRojo(projectPath, outputPath) {
 	}
 }
 //#endregion
-//#region src/timing/orchestration-collector.ts
-/**
-* A buffered span-tree profiler for a single, sequential host run. Nesting is
-* tracked with one shared stack, so spans must open and close in LIFO order:
-* profile a phase, and any spans it opens nest under it. It is NOT safe to run
-* two `profile` / `profileAsync` calls concurrently on the same collector (e.g.
-* `Promise.all`) — interleaved opens/closes would corrupt the stack. Create one
-* collector per run; `flushTimingReport` empties it so a second flush is a
-* no-op.
-*/
-function createTimingCollector(options = {}) {
-	const clock = options.clock ?? { now: () => node_perf_hooks.performance.now() };
-	const sink = options.sink ?? ((line) => void node_process.default.stderr.write(`${line}\n`));
-	const enabled = options.enabled ?? node_process.default.env["TIMING"] !== void 0;
-	const roots = /* @__PURE__ */ new Map();
-	const stack = [];
-	function open(name) {
-		const top = stack.at(-1);
-		const node = childOf(top === void 0 ? roots : top.children, name);
-		stack.push(node);
-		const start = clock.now();
-		return () => {
-			node.elapsedMs += clock.now() - start;
-			stack.pop();
-		};
-	}
-	function profile(name, func) {
-		if (!enabled) return func();
-		const close = open(name);
-		try {
-			return func();
-		} finally {
-			close();
-		}
-	}
-	async function profileAsync(name, func) {
-		if (!enabled) return func();
-		const close = open(name);
-		try {
-			return await func();
-		} finally {
-			close();
-		}
-	}
-	function emit(node, depth) {
-		sink(`[TIMING] ${"  ".repeat(depth)}${node.name}: ${String(Math.round(node.elapsedMs))}ms`);
-		for (const child of node.children.values()) emit(child, depth + 1);
-	}
-	function flushTimingReport() {
-		if (!enabled || roots.size === 0) return;
-		let total = 0;
-		for (const node of roots.values()) {
-			emit(node, 0);
-			total += Math.round(node.elapsedMs);
-		}
-		sink(`[TIMING] TOTAL (host): ${String(total)}ms`);
-		roots.clear();
-	}
-	return {
-		flushTimingReport,
-		profile,
-		profileAsync
-	};
-}
-/**
-* Shared disabled collector for callers that thread a profiler through their
-* signatures but are invoked outside a profiled workspace run (single-mode
-* coverage, the `instrument` subcommand, tests). Every method is a no-op.
-*/
-const NOOP_TIMING_COLLECTOR = createTimingCollector({ enabled: false });
-function childOf(parent, name) {
-	let node = parent.get(name);
-	if (node === void 0) {
-		node = {
-			name,
-			children: /* @__PURE__ */ new Map(),
-			elapsedMs: 0
-		};
-		parent.set(name, node);
-	}
-	return node;
-}
-//#endregion
 //#region src/utils/hash.ts
 function hashBuffer(data) {
 	return (0, node_crypto.createHash)("sha256").update(data).digest("hex");
@@ -40472,15 +40610,47 @@ function classifyTestFiles(files, config) {
 		typeTestFiles
 	};
 }
+function resolveAllSetupFilePaths(configs) {
+	const resolvers = /* @__PURE__ */ new Map();
+	for (const config of configs) {
+		if (config.setupFiles === void 0 && config.setupFilesAfterEnv === void 0) continue;
+		const rojoConfigPath = node_path.resolve(config.rootDir, config.rojoProject ?? DEFAULT_ROJO_PROJECT$1);
+		const key = JSON.stringify([config.rootDir, rojoConfigPath]);
+		let resolve = resolvers.get(key);
+		if (resolve === void 0) {
+			resolve = createSetupResolver({
+				configDirectory: config.rootDir,
+				rojoConfigPath
+			});
+			resolvers.set(key, resolve);
+		}
+		if (config.setupFiles !== void 0) config.setupFiles = config.setupFiles.map(resolve);
+		if (config.setupFilesAfterEnv !== void 0) config.setupFilesAfterEnv = config.setupFilesAfterEnv.map(resolve);
+	}
+}
 function resolveSetupFilePaths(config) {
-	if (config.setupFiles === void 0 && config.setupFilesAfterEnv === void 0) return;
-	const rojoConfigPath = node_path.resolve(config.rootDir, config.rojoProject ?? DEFAULT_ROJO_PROJECT$1);
-	const resolve = createSetupResolver({
-		configDirectory: config.rootDir,
-		rojoConfigPath
-	});
-	if (config.setupFiles !== void 0) config.setupFiles = config.setupFiles.map(resolve);
-	if (config.setupFilesAfterEnv !== void 0) config.setupFilesAfterEnv = config.setupFilesAfterEnv.map(resolve);
+	resolveAllSetupFilePaths([config]);
+}
+//#endregion
+//#region src/run/run-header.ts
+/**
+* Print the ` RUN  vX.Y  <rootDir>` header to stdout at the moment a run begins
+* (right before the backend uploads), so the CLI doesn't look stalled while it
+* waits for remote results. The end-of-run formatters no longer emit it.
+*
+* Self-gates to the default human formatter: nothing is written under
+* `--silent`, `--formatters json`, or `--formatters agent` (without
+* `--verbose`), which produce machine-readable output that must stay clean.
+*/
+function emitRunHeader(input) {
+	if (!isDefaultHumanFormatter(input)) return;
+	node_process.default.stdout.write(formatRunHeader({
+		collectCoverage: input.collectCoverage,
+		color: input.color,
+		rootDir: input.rootDir,
+		verbose: input.verbose ?? false,
+		version: input.version
+	}));
 }
 //#endregion
 //#region src/run/multi.ts
@@ -40488,30 +40658,61 @@ const DEFAULT_ROJO_PROJECT = "default.project.json";
 const VERSION$3 = version;
 async function runMultiProject(options) {
 	const { cli, config: rootConfig, rawProjects } = options;
-	const allProjects = await resolveAllProjects(rawProjects, rootConfig, loadRojoTree(rootConfig), rootConfig.rootDir);
-	for (const project of allProjects) resolveSetupFilePaths(project.config);
-	const { filesByProject, projects } = selectProjects(allProjects, cli.project, cli.files, rootConfig.rootDir);
+	const timing = options.timing ?? NOOP_TIMING_COLLECTOR;
+	const rojoTree = timing.profile("loadRojoTree", () => loadRojoTree(rootConfig));
+	const allProjects = await timing.profileAsync("resolveAllProjects", async () => {
+		return resolveAllProjects(rawProjects, rootConfig, rojoTree, rootConfig.rootDir);
+	});
+	timing.profile("resolveSetupFilePaths", () => {
+		resolveAllSetupFilePaths(allProjects.map((project) => project.config));
+	});
+	const { filesByProject, projects } = timing.profile("selectProjects", () => {
+		return selectProjects(allProjects, cli.project, cli.files, rootConfig.rootDir);
+	});
 	const cacheRoot = node_path.resolve(rootConfig.rootDir, ".jest-roblox", "cache");
-	const cleaned = cleanLeftoverStubs(projects, rootConfig.rootDir);
+	const cleaned = timing.profile("cleanLeftoverStubs", () => {
+		return cleanLeftoverStubs(projects, rootConfig.rootDir);
+	});
 	if (cleaned.length > 0) node_process.default.stderr.write(`jest-roblox: cleaned ${String(cleaned.length)} leftover stub(s):\n${cleaned.map((stubPath) => `  ${stubPath}\n`).join("")}`);
-	generateProjectStubs(projects, rootConfig.rootDir, cacheRoot);
-	const { effectiveConfig, preCoverageMs } = prepareMultiProjectCoverage(rootConfig, projects, cacheRoot);
-	const backend = await resolveBackend(cli, effectiveConfig);
+	timing.profile("generateProjectStubs", () => {
+		generateProjectStubs(projects, rootConfig.rootDir, cacheRoot);
+	});
+	const { effectiveConfig, preCoverageMs } = timing.profile("prepareCoverage", () => {
+		return prepareMultiProjectCoverage(rootConfig, projects, cacheRoot);
+	});
+	const backend = await timing.profileAsync("resolveBackend", async () => {
+		return resolveBackend(cli, effectiveConfig);
+	});
 	const parallel = effectiveParallelForBackend(effectiveConfig.parallel, backend);
-	if (!rootConfig.collectCoverage && backend.kind === "open-cloud") buildOpenCloudPlace(rootConfig, projects, cacheRoot);
-	const { allTypeTestFiles, pendingJobs } = collectPendingJobs({
-		cliFiles: cli.files,
-		effectivePlaceFile: effectiveConfig.placeFile,
-		filesByProject,
-		projects,
-		rootConfig
+	if (!rootConfig.collectCoverage && backend.kind === "open-cloud") timing.profile("buildOpenCloudPlace", () => {
+		buildOpenCloudPlace(rootConfig, projects, cacheRoot);
 	});
-	const projectResults = await runJobs(backend, pendingJobs, parallel);
-	const uniqueTypeTestFiles = [...new Set(allTypeTestFiles)];
-	const typecheckResult = uniqueTypeTestFiles.length > 0 ? runTypecheck({
-		files: uniqueTypeTestFiles,
+	const { allTypeTestFiles, pendingJobs } = timing.profile("collectPendingJobs", () => {
+		return collectPendingJobs({
+			cliFiles: cli.files,
+			effectivePlaceFile: effectiveConfig.placeFile,
+			filesByProject,
+			projects,
+			rootConfig
+		});
+	});
+	if (pendingJobs.length > 0) emitRunHeader({
+		collectCoverage: rootConfig.collectCoverage,
+		color: rootConfig.color,
+		formatters: rootConfig.formatters,
 		rootDir: rootConfig.rootDir,
-		tsconfig: rootConfig.typecheckTsconfig
+		silent: rootConfig.silent,
+		verbose: rootConfig.verbose,
+		version: VERSION$3
+	});
+	const projectResults = await runJobs(backend, pendingJobs, parallel, timing);
+	const uniqueTypeTestFiles = [...new Set(allTypeTestFiles)];
+	const typecheckResult = uniqueTypeTestFiles.length > 0 ? timing.profile("runTypecheck", () => {
+		return runTypecheck({
+			files: uniqueTypeTestFiles,
+			rootDir: rootConfig.rootDir,
+			tsconfig: rootConfig.typecheckTsconfig
+		});
 	}) : void 0;
 	if (projectResults.length === 0 && typecheckResult === void 0) {
 		if (rootConfig.passWithNoTests) return {
@@ -40575,10 +40776,11 @@ function collectPendingJobs(arguments_) {
 			testMatch: project.include
 		};
 		const { runtimeFiles, typeTestFiles } = classifyTestFiles(discoverTestFiles(discoveryConfig, projectCliFiles).files, rootConfig);
-		const projConfig = narrowConfigByFiles({
+		const filterActive = (projectCliFiles?.length ?? 0) > 0 || discoveryConfig.testPathPattern !== void 0;
+		const projConfig = narrowForLuauRun({
 			...discoveryConfig,
 			testMatch: project.testMatch
-		}, projectCliFiles ?? []);
+		}, runtimeFiles, filterActive);
 		allTypeTestFiles.push(...typeTestFiles);
 		if (runtimeFiles.length === 0) continue;
 		const runtimeInjectionPaths = [];
@@ -40599,28 +40801,31 @@ function collectPendingJobs(arguments_) {
 		pendingJobs
 	};
 }
-async function runJobs(backend, pendingJobs, parallel) {
+async function runJobs(backend, pendingJobs, parallel, timing) {
 	if (pendingJobs.length === 0) {
 		await backend.close?.();
 		return [];
 	}
 	let runResult;
 	try {
-		runResult = await runProjects({
-			backend,
-			deferFormatting: true,
-			parallel,
-			projects: pendingJobs.map((pending) => {
-				return {
-					config: pending.config,
-					displayColor: pending.displayColor,
-					displayName: pending.displayName,
-					runtimeInjectionPaths: pending.runtimeInjectionPaths,
-					testFiles: pending.runtimeFiles
-				};
-			}),
-			startTime: Date.now(),
-			version: VERSION$3
+		runResult = await timing.profileAsync("runProjects", async () => {
+			return runProjects({
+				backend,
+				deferFormatting: true,
+				parallel,
+				projects: pendingJobs.map((pending) => {
+					return {
+						config: pending.config,
+						displayColor: pending.displayColor,
+						displayName: pending.displayName,
+						runtimeInjectionPaths: pending.runtimeInjectionPaths,
+						testFiles: pending.runtimeFiles
+					};
+				}),
+				startTime: Date.now(),
+				timing,
+				version: VERSION$3
+			});
 		});
 	} finally {
 		await backend.close?.();
@@ -40697,11 +40902,16 @@ function selectProjects(allProjects, projectNames, cliFiles, rootDirectory) {
 const VERSION$2 = version;
 async function runSingleProject(options) {
 	const { cli } = options;
-	const config = narrowConfigByFiles(options.config, cli.files ?? []);
-	resolveSetupFilePaths(config);
-	const discovery = discoverTestFiles(config, cli.files);
+	const timing = options.timing ?? NOOP_TIMING_COLLECTOR;
+	const baseConfig = { ...options.config };
+	timing.profile("resolveSetupFilePaths", () => {
+		resolveSetupFilePaths(baseConfig);
+	});
+	const discovery = timing.profile("discoverTestFiles", () => {
+		return discoverTestFiles(baseConfig, cli.files);
+	});
 	if (discovery.files.length === 0) {
-		if (config.passWithNoTests) return {
+		if (baseConfig.passWithNoTests) return {
 			mode: "single",
 			preCoverageMs: 0
 		};
@@ -40712,7 +40922,13 @@ async function runSingleProject(options) {
 			validationExitCode: 2
 		};
 	}
-	const { runtimeFiles, typeTestFiles } = classifyTestFiles(discovery.files, config);
+	const { runtimeFiles, typeTestFiles } = timing.profile("classifyTestFiles", () => {
+		return classifyTestFiles(discovery.files, baseConfig);
+	});
+	const filterActive = (cli.files?.length ?? 0) > 0 || baseConfig.testPathPattern !== void 0;
+	const config = timing.profile("narrowForLuauRun", () => {
+		return narrowForLuauRun(baseConfig, runtimeFiles, filterActive);
+	});
 	if (typeTestFiles.length === 0 && runtimeFiles.length === 0) {
 		if (config.passWithNoTests) return {
 			mode: "single",
@@ -40729,19 +40945,27 @@ async function runSingleProject(options) {
 	let effectiveConfig = config;
 	if (config.collectCoverage && !config.typecheckOnly && runtimeFiles.length > 0) {
 		const preCoverageStart = Date.now();
-		const { placeFile } = prepareCoverage(config);
+		const { placeFile } = timing.profile("prepareCoverage", () => prepareCoverage(config));
 		preCoverageMs = Date.now() - preCoverageStart;
 		effectiveConfig = {
 			...config,
 			placeFile
 		};
 	}
-	const typecheckResult = typeTestFiles.length > 0 ? runTypecheck({
-		files: typeTestFiles,
-		rootDir: effectiveConfig.rootDir,
-		tsconfig: effectiveConfig.typecheckTsconfig
+	const typecheckResult = typeTestFiles.length > 0 ? timing.profile("runTypecheck", () => {
+		return runTypecheck({
+			files: typeTestFiles,
+			rootDir: effectiveConfig.rootDir,
+			tsconfig: effectiveConfig.typecheckTsconfig
+		});
+	}) : void 0;
+	const runtimeResult = runtimeFiles.length > 0 ? await executeRuntimeTests({
+		cli,
+		config: effectiveConfig,
+		testFiles: runtimeFiles,
+		timing,
+		totalFiles: discovery.totalFiles
 	}) : void 0;
-	const runtimeResult = runtimeFiles.length > 0 ? await executeRuntimeTests(options, effectiveConfig, runtimeFiles, discovery.totalFiles) : void 0;
 	return {
 		mode: "single",
 		preCoverageMs,
@@ -40749,19 +40973,35 @@ async function runSingleProject(options) {
 		typecheckResult
 	};
 }
-async function executeRuntimeTests(options, config, testFiles, totalFiles) {
-	if (!config.silent && !usesAgentFormatter(config.formatters, config.verbose) && !hasFormatter(config.formatters, "json") && testFiles.length !== totalFiles) node_process.default.stderr.write(`Running ${String(testFiles.length)} of ${String(totalFiles)} test files\n`);
-	const backend = await resolveBackend(options.cli, config);
+async function executeRuntimeTests(options) {
+	const { cli, config, testFiles, timing, totalFiles } = options;
+	const useDefaultFormatter = isDefaultHumanFormatter(config);
+	emitRunHeader({
+		collectCoverage: config.collectCoverage,
+		color: config.color,
+		formatters: config.formatters,
+		rootDir: config.rootDir,
+		silent: config.silent,
+		verbose: config.verbose,
+		version: VERSION$2
+	});
+	if (useDefaultFormatter && testFiles.length !== totalFiles) node_process.default.stderr.write(`Running ${String(testFiles.length)} of ${String(totalFiles)} test files\n`);
+	const backend = await timing.profileAsync("resolveBackend", async () => {
+		return resolveBackend(cli, config);
+	});
 	try {
-		const { results } = await runProjects({
-			backend,
-			deferFormatting: true,
-			projects: [{
-				config,
-				testFiles
-			}],
-			startTime: Date.now(),
-			version: VERSION$2
+		const { results } = await timing.profileAsync("runProjects", async () => {
+			return runProjects({
+				backend,
+				deferFormatting: true,
+				projects: [{
+					config,
+					testFiles
+				}],
+				startTime: Date.now(),
+				timing,
+				version: VERSION$2
+			});
 		});
 		return results[0];
 	} finally {
@@ -41497,12 +41737,7 @@ const SYNTHESIZED_PLACE_FILE = "synthesized.rbxl";
 const WORKSPACE_CACHE_DIRECTORY = node_path.join(".jest-roblox", "workspace");
 const ROJO_PROJECT_DEFAULT = "test.project.json";
 async function runWorkspace(options) {
-	const timing = createTimingCollector();
-	try {
-		return await runWorkspaceProfiled(options, timing);
-	} finally {
-		timing.flushTimingReport();
-	}
+	return runWorkspaceProfiled(options, options.timing ?? NOOP_TIMING_COLLECTOR);
 }
 function buildCoverageMap(entries) {
 	const map = /* @__PURE__ */ new Map();
@@ -41616,6 +41851,7 @@ async function runWorkspaceProfiled(options, timing) {
 				};
 			}),
 			startTime,
+			timing,
 			version,
 			...dispatchSpec
 		});
@@ -41682,13 +41918,33 @@ async function prepareWorkspaceDispatch(input) {
 	}
 	return { scriptOverride: generateMaterializerScript(inputs) };
 }
+/**
+* Resolve a `--testPathPattern` against this package's files Node-side, then
+* forward an Instance-namespace basename pattern (see {@link narrowForLuauRun}).
+*
+* A pattern that matches no file in this package simply targets a different
+* package: keep the (zero-matching) raw pattern so Jest-on-Roblox runs nothing,
+* and set `passWithNoTests` so it doesn't `exit(1)`. The raw pattern is
+* load-bearing here — clearing it would drop the filter entirely and make the
+* Luau side fall back to `testMatch`, running the whole package.
+*/
+function narrowPackageTestPathPattern(packageConfig) {
+	if (packageConfig.testPathPattern === void 0) return packageConfig;
+	const { files } = discoverTestFiles(packageConfig);
+	const { runtimeFiles } = classifyTestFiles(files, packageConfig);
+	if (runtimeFiles.length === 0) return {
+		...packageConfig,
+		passWithNoTests: true
+	};
+	return narrowForLuauRun(packageConfig, runtimeFiles, true);
+}
 async function loadPackages(input) {
 	const { cli, packageInfos, timing } = input;
 	const loaded = [];
 	for (const info of packageInfos) {
-		const packageConfig = mergeCliWithConfig(cli, await timing.profileAsync(`load-config:${info.name}`, async () => {
+		const packageConfig = narrowPackageTestPathPattern(mergeCliWithConfig(cli, await timing.profileAsync(`load-config:${info.name}`, async () => {
 			return loadConfig(void 0, info.packageDirectory);
-		}));
+		})));
 		const rojoProject = packageConfig.rojoProject ?? ROJO_PROJECT_DEFAULT;
 		const hasExplicitIgnore = packageConfig.coveragePathIgnorePatterns !== DEFAULT_CONFIG.coveragePathIgnorePatterns;
 		const hasExplicitCoverageCache = packageConfig.coverageCache !== DEFAULT_CONFIG.coverageCache;
@@ -42215,7 +42471,7 @@ const EMPTY_RESULT = {
 	preCoverageMs: 0,
 	projectResults: []
 };
-async function runWorkspaceMode(cli, workspace) {
+async function runWorkspaceMode(cli, workspace, timing) {
 	const basicValidation = validateBasicWorkspaceFlags(cli);
 	if (!basicValidation.ok) return {
 		...EMPTY_RESULT,
@@ -42281,6 +42537,14 @@ async function runWorkspaceMode(cli, workspace) {
 	}
 	let runtimeResults;
 	try {
+		emitRunHeader({
+			color: runOptions.color,
+			formatters: runOptions.formatters,
+			rootDir: workspaceRoot,
+			silent: runOptions.silent,
+			verbose: cli.verbose,
+			version: VERSION$1
+		});
 		const onStreamingResult = resolveStreamingProgressSink(runOptions, cli);
 		runtimeResults = await runWorkspace({
 			backend,
@@ -42288,6 +42552,7 @@ async function runWorkspaceMode(cli, workspace) {
 			...onStreamingResult !== void 0 ? { onStreamingResult } : {},
 			packageInfos,
 			runOptions,
+			timing,
 			version: VERSION$1,
 			workspaceRoot,
 			workStealingCredentials
@@ -42377,8 +42642,11 @@ function composeWorkspaceDisplayName(package_, project) {
 * either break the structured output or be silenced anyway.
 */
 function resolveStreamingProgressSink(runOptions, cli) {
-	if (runOptions.silent) return;
-	if (hasFormatter(runOptions.formatters, "json") || usesAgentFormatter(runOptions.formatters, cli.verbose)) return;
+	if (!isDefaultHumanFormatter({
+		formatters: runOptions.formatters,
+		silent: runOptions.silent,
+		verbose: cli.verbose
+	})) return;
 	return (entry) => {
 		const line = formatStreamingProgressLine(entry, { color: runOptions.color });
 		node_process.default.stdout.write(`${line}\n`);
@@ -42390,41 +42658,25 @@ function isWorkspaceInvocation(cli) {
 	return cli.workspace === true || cli.packages !== void 0 || cli.affectedSince !== void 0;
 }
 async function runJestRoblox(cli, config) {
-	if (isWorkspaceInvocation(cli)) return runWorkspaceMode(cli, config.workspace);
-	const merged = mergeCliWithConfig(cli, config);
-	const rawProjects = merged.projects;
-	if (rawProjects !== void 0 && rawProjects.length > 0) return runMultiProject({
-		cli,
-		config: merged,
-		rawProjects
-	});
-	return runSingleProject({
-		cli,
-		config: merged
-	});
-}
-//#endregion
-//#region src/utils/error-chain.ts
-const MAX_DEPTH = 5;
-function walkErrorChain(err) {
-	const entries = [];
-	let current = err;
-	while (current instanceof Error && entries.length < MAX_DEPTH) {
-		entries.push({
-			name: current.constructor.name,
-			code: readStringProperty(current, "code"),
-			errno: readStringProperty(current, "errno"),
-			message: current.message,
-			syscall: readStringProperty(current, "syscall")
+	const timing = createTimingCollector();
+	try {
+		if (isWorkspaceInvocation(cli)) return await runWorkspaceMode(cli, config.workspace, timing);
+		const merged = mergeCliWithConfig(cli, config);
+		const rawProjects = merged.projects;
+		if (rawProjects !== void 0 && rawProjects.length > 0) return await runMultiProject({
+			cli,
+			config: merged,
+			rawProjects,
+			timing
 		});
-		current = current.cause;
+		return await runSingleProject({
+			cli,
+			config: merged,
+			timing
+		});
+	} finally {
+		timing.flushTimingReport();
 	}
-	return entries;
-}
-function readStringProperty(err, key) {
-	const value = Reflect.get(err, key);
-	if (value === void 0 || value === null) return;
-	return String(value);
 }
 //#endregion
 //#region src/cli.ts
@@ -42448,6 +42700,7 @@ Options:
   --no-color                        Disable colored output
   -u, --updateSnapshot              Update snapshot files
   --coverage                        Enable coverage collection
+  --no-coverage                     Disable coverage for this run (overrides config)
   --collectCoverageFrom <glob>      Globs for files to include in coverage (repeatable)
   --coverageDirectory <path>        Directory for coverage output (default: coverage)
   --coverageReporters <r...>        Coverage reporters (default: text, lcov)
@@ -42491,6 +42744,7 @@ Examples:
   jest-roblox -t "should spawn"       Run tests matching pattern
   jest-roblox --formatters json       Output JSON to file
   jest-roblox --coverage              Run tests with coverage instrumentation
+  jest-roblox --no-coverage           Skip coverage instrumentation for this run
 `;
 function parseArgs(args) {
 	const { positionals, values } = (0, node_util.parseArgs)({
@@ -42523,6 +42777,7 @@ function parseArgs(args) {
 				type: "boolean"
 			},
 			"no-color": { type: "boolean" },
+			"no-coverage": { type: "boolean" },
 			"no-coverage-cache": { type: "boolean" },
 			"no-show-luau": { type: "boolean" },
 			"outputFile": { type: "string" },
@@ -42577,7 +42832,7 @@ function parseArgs(args) {
 		affectedSince: values["affected-since"],
 		apiKey: values.apiKey,
 		backend: validateBackend(values.backend),
-		collectCoverage: values.coverage,
+		collectCoverage: values["no-coverage"] === true ? false : values.coverage,
 		collectCoverageFrom: values.collectCoverageFrom,
 		color: values["no-color"] === true ? false : values.color,
 		config: values.config,
@@ -42689,6 +42944,7 @@ function formatBackendErrorBanner(err) {
 		const extras = formatChainExtras(entry);
 		const label = y$3.dim(`[${index.toString()}]`);
 		body.push(`    ${label} ${entry.name}: ${entry.message}${extras}`);
+		if (entry.requiredScopes !== void 0) body.push(`        ${y$3.yellow(formatMissingScopes(entry.requiredScopes))}`);
 	}
 	return formatBanner({
 		body,