@isentinel/jest-roblox 0.3.0 → 0.3.2

package/dist/{run-BEUPi80L.mjs → run-CyHhajiY.mjs}

@@ -1,12 +1,12 @@
 import { createRequire } from "node:module";
-import { PermissionError, PollTimeoutError } from "@bedrock-rbx/ocale";
+import { PermissionError, PollTimeoutError, TRANSIENT_TRANSPORT_CODES } from "@bedrock-rbx/ocale";
 import process from "node:process";
 import { isDeepStrictEqual } from "node:util";
 import color from "tinyrainbow";
 import { createDefineConfig, loadConfig } from "c12";
 import { defuFn } from "defu";
 import * as fs$1 from "node:fs";
-import fs, { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import fs, { existsSync, readFileSync } from "node:fs";
 import * as path$1 from "node:path";
 import path, { dirname, join, relative, resolve } from "node:path";
 import { type } from "arktype";
@@ -20,6 +20,7 @@ import picomatch from "picomatch";
 import { getTsconfig } from "get-tsconfig";
 import hljs from "highlight.js/lib/core";
 import typescript from "highlight.js/lib/languages/typescript";
+import { performance } from "node:perf_hooks";
 import { LuauExecutionClient } from "@bedrock-rbx/ocale/luau-execution";
 import { PlacesClient } from "@bedrock-rbx/ocale/places";
 import { createHash, randomUUID } from "node:crypto";
@@ -29,11 +30,10 @@ import * as cp from "node:child_process";
 import { execFileSync } from "node:child_process";
 import * as os from "node:os";
 import { Buffer } from "node:buffer";
-import { performance } from "node:perf_hooks";
 import { parseJSONC, parseYAML } from "confbox";
 import { Visitor, parseSync } from "oxc-parser";
 //#region package.json
-var version = "0.3.0";
+var version = "0.3.2";
 //#endregion
 //#region src/config/errors.ts
 var ConfigError = class extends Error {
@@ -933,12 +933,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 = [];
@@ -1449,6 +1472,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();
@@ -1459,12 +1483,12 @@ var RojoResolver = class RojoResolver {
 	static findRojoConfigFilePath(projectPath) {
 		const warnings = new Array();
 		const defaultPath = path.join(projectPath, ROJO_DEFAULT_NAME);
-		if (existsSync(defaultPath)) return {
+		if (fs$1.existsSync(defaultPath)) return {
 			path: defaultPath,
 			warnings
 		};
 		const candidates = new Array();
-		for (const fileName of readdirSync(projectPath)) if (fileName !== ROJO_DEFAULT_NAME && (fileName === ROJO_OLD_NAME || ROJO_FILE_REGEX.test(fileName))) candidates.push(path.join(projectPath, fileName));
+		for (const fileName of fs$1.readdirSync(projectPath)) if (fileName !== ROJO_DEFAULT_NAME && (fileName === ROJO_OLD_NAME || ROJO_FILE_REGEX.test(fileName))) candidates.push(path.join(projectPath, fileName));
 		if (candidates.length > 1) warnings.push(`Multiple *.project.json files found, using ${candidates[0]}`);
 		return {
 			path: candidates[0],
@@ -1600,34 +1624,42 @@ var RojoResolver = class RojoResolver {
 	get walkedDirectories() {
 		return this.walkedDirectoriesInternal;
 	}
+	cachedRealpath(targetPath) {
+		let resolved = this.realpathCache.get(targetPath);
+		if (resolved === void 0) {
+			resolved = fs$1.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 (!existsSync(rojoConfigFilePath)) {
+		if (!fs$1.existsSync(rojoConfigFilePath)) {
 			this.warn(`RojoResolver: Path does not exist "${rojoConfigFilePath}"`);
 			return;
 		}
-		const realPath = realpathSync(rojoConfigFilePath);
+		const realPath = this.cachedRealpath(rojoConfigFilePath);
 		this.walkedConfigFilesInternal.add(realPath);
 		let configJson;
 		try {
-			configJson = JSON.parse(readFileSync(realPath, "utf8"));
+			configJson = JSON.parse(fs$1.readFileSync(realPath, "utf8"));
 		} catch {}
 		if (isValidRojoConfig(configJson)) this.parseTree(path.dirname(rojoConfigFilePath), configJson.name, configJson.tree, doNotPush);
 		else this.warn("RojoResolver: Invalid configuration!");
 	}
 	parsePath(itemPath) {
 		const luauPath = convertToLuau(itemPath);
-		const realPath = existsSync(luauPath) ? realpathSync(luauPath) : luauPath;
+		const realPath = fs$1.existsSync(luauPath) ? this.cachedRealpath(luauPath) : luauPath;
 		const extension = path.extname(luauPath);
 		if (ROJO_MODULE_EXTS.has(extension)) this.filePathToRbxPathMap.set(luauPath, [...this.rbxPath]);
 		else {
-			const isDirectory = existsSync(realPath) && statSync(realPath).isDirectory();
+			const isDirectory = fs$1.existsSync(realPath) && fs$1.statSync(realPath).isDirectory();
 			if (isDirectory) this.walkedDirectoriesInternal.add(realPath);
-			if (isDirectory && readdirSync(realPath).includes(ROJO_DEFAULT_NAME)) this.parseConfig(path.join(luauPath, ROJO_DEFAULT_NAME), true);
+			if (isDirectory && fs$1.readdirSync(realPath).includes(ROJO_DEFAULT_NAME)) this.parseConfig(path.join(luauPath, ROJO_DEFAULT_NAME), true);
 			else {
 				this.partitions.unshift({
 					fsPath: luauPath,
@@ -1644,26 +1676,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 = path.join(directory, child);
-			if (statSync(realpathSync(childPath)).isFile() && child !== ROJO_DEFAULT_NAME && ROJO_FILE_REGEX.test(child)) this.parseConfig(childPath);
-		}
-		for (const child of children) {
-			const childPath = path.join(directory, child);
-			if (statSync(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 = path.join(directory, entry.name);
+			let isFile = entry.isFile();
+			let isDirectory = entry.isDirectory();
+			if (!isFile && !isDirectory) try {
+				const stat = fs$1.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 = realpathSync(directory);
+		const realPath = this.cachedRealpath(directory);
 		this.walkedDirectoriesInternal.add(realPath);
-		const children = readdirSync(realPath);
-		if (children.includes(ROJO_DEFAULT_NAME)) {
+		const directoryEntries = fs$1.readdirSync(directory, { withFileTypes: true });
+		if (directoryEntries.some((entry) => entry.name === ROJO_DEFAULT_NAME)) {
 			this.parseConfig(path.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) {
@@ -2058,6 +2104,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;
 }
@@ -2694,7 +2741,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));
@@ -2868,7 +2915,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,
@@ -3675,6 +3722,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) {
@@ -3687,7 +3743,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 };
@@ -3707,6 +3763,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: () => performance.now() };
+	const sink = options.sink ?? ((line) => void process.stderr.write(`${line}\n`));
+	const enabled = options.enabled ?? process.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",
@@ -3856,38 +4002,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
+					});
+				}
+			});
 		})
 	};
 }
@@ -3928,6 +4084,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 = /^Exited with code: \d+$/;
 /**
 * Compose the human-readable failure message for an exec-error file
@@ -4128,7 +4288,7 @@ function writeSnapshots(snapshotWrites, config, tsconfigMappings) {
 			fs$1.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 = path$1.resolve(config.rootDir, outPath);
 				fs$1.mkdirSync(path$1.dirname(absoluteOutPath), { recursive: true });
 				fs$1.writeFileSync(absoluteOutPath, content);
@@ -4157,19 +4317,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,
@@ -4182,7 +4346,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed,
 		sourceMapper,
-		timing,
+		timing: resultTiming,
 		version
 	}) : "";
 	if (luauTiming !== void 0) printLuauTiming(luauTiming);
@@ -4194,7 +4358,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed > 0 ? writeCounts.failed : void 0,
 		sourceMapper,
-		timing
+		timing: resultTiming
 	};
 }
 /**
@@ -4202,8 +4366,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),
@@ -4763,7 +4929,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 });
@@ -4785,7 +4954,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,
@@ -4903,6 +5072,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";
@@ -5038,10 +5236,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) {
@@ -5814,6 +6009,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("/");
@@ -6347,89 +6563,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: () => performance.now() };
-	const sink = options.sink ?? ((line) => void process.stderr.write(`${line}\n`));
-	const enabled = options.enabled ?? process.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 createHash("sha256").update(data).digest("hex");
@@ -7900,15 +8033,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 = path$1.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 = path$1.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;
+	process.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
@@ -7916,30 +8081,61 @@ const DEFAULT_ROJO_PROJECT = "default.project.json";
 const VERSION$2 = 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 = path$1.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) process.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$2
+	});
+	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 {
@@ -8003,10 +8199,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 = [];
@@ -8027,28 +8224,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$2
+		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$2
+			});
 		});
 	} finally {
 		await backend.close?.();
@@ -8125,11 +8325,16 @@ function selectProjects(allProjects, projectNames, cliFiles, rootDirectory) {
 const VERSION$1 = 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
 		};
@@ -8140,7 +8345,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",
@@ -8157,19 +8368,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,
@@ -8177,19 +8396,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) process.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$1
+	});
+	if (useDefaultFormatter && testFiles.length !== totalFiles) process.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$1
+		const { results } = await timing.profileAsync("runProjects", async () => {
+			return runProjects({
+				backend,
+				deferFormatting: true,
+				projects: [{
+					config,
+					testFiles
+				}],
+				startTime: Date.now(),
+				timing,
+				version: VERSION$1
+			});
 		});
 		return results[0];
 	} finally {
@@ -8925,12 +9160,7 @@ const SYNTHESIZED_PLACE_FILE = "synthesized.rbxl";
 const WORKSPACE_CACHE_DIRECTORY = path$1.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();
@@ -9044,6 +9274,7 @@ async function runWorkspaceProfiled(options, timing) {
 				};
 			}),
 			startTime,
+			timing,
 			version,
 			...dispatchSpec
 		});
@@ -9110,13 +9341,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$1(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;
@@ -9642,7 +9893,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,
@@ -9708,6 +9959,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
+		});
 		const onStreamingResult = resolveStreamingProgressSink(runOptions, cli);
 		runtimeResults = await runWorkspace({
 			backend,
@@ -9715,6 +9974,7 @@ async function runWorkspaceMode(cli, workspace) {
 			...onStreamingResult !== void 0 ? { onStreamingResult } : {},
 			packageInfos,
 			runOptions,
+			timing,
 			version: VERSION,
 			workspaceRoot,
 			workStealingCredentials
@@ -9804,8 +10064,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 });
 		process.stdout.write(`${line}\n`);
@@ -9817,18 +10080,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
-	});
+	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
+		});
+		return await runSingleProject({
+			cli,
+			config: merged,
+			timing
+		});
+	} finally {
+		timing.flushTimingReport();
+	}
 }
 //#endregion
-export { mergeCliWithConfig as A, defineProject as B, formatFailure as C, LuauScriptError as D, formatBanner as E, JEST_ARGV_EXCLUDED_KEYS as F, ConfigError as H, ROOT_CLI_KEYS as I, SHARED_TEST_KEYS as L, resolveConfig as M, DEFAULT_CONFIG as N, extractJsonFromOutput as O, GLOBAL_TEST_KEYS as P, VALID_BACKENDS as R, writeJsonFile$1 as S, formatTestSummary as T, version as U, isValidBackend as V, runProjects as _, visitStatement as a, writeGameOutput as b, OpenCloudBackend as c, generateTestScript as d, outputMultiResult as f, formatExecuteOutput as g, formatJobSummary as h, visitExpression as i, loadConfig$1 as j, parseJestOutput as k, createOpenCloudBackend as l, formatAnnotations as m, runTypecheck as n, StudioBackend as o, outputSingleResult as p, visitBlock as r, createStudioBackend as s, runJestRoblox as t, buildJestArgv as u, formatGameOutputNotice as v, formatResult as w, formatJson as x, parseGameOutput as y, defineConfig as z };
+export { extractJsonFromOutput as A, VALID_BACKENDS as B, formatJson as C, formatTestSummary as D, formatResult as E, DEFAULT_CONFIG as F, version as G, defineProject as H, GLOBAL_TEST_KEYS as I, JEST_ARGV_EXCLUDED_KEYS as L, mergeCliWithConfig as M, loadConfig$1 as N, formatBanner as O, resolveConfig as P, ROOT_CLI_KEYS as R, writeGameOutput as S, formatFailure as T, isValidBackend as U, defineConfig as V, ConfigError as W, formatJobSummary as _, visitStatement as a, formatGameOutputNotice as b, OpenCloudBackend as c, walkErrorChain as d, buildJestArgv as f, formatAnnotations as g, outputSingleResult as h, visitExpression as i, parseJestOutput as j, LuauScriptError as k, createOpenCloudBackend as l, outputMultiResult as m, runTypecheck as n, StudioBackend as o, generateTestScript as p, visitBlock as r, createStudioBackend as s, runJestRoblox as t, formatMissingScopes as u, formatExecuteOutput as v, writeJsonFile$1 as w, parseGameOutput as x, runProjects as y, SHARED_TEST_KEYS as z };