@isentinel/jest-roblox 0.3.0 → 0.3.1

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

@@ -6,7 +6,7 @@ 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.1";
 //#endregion
 //#region src/config/errors.ts
 var ConfigError = class extends Error {
@@ -1449,6 +1449,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 +1460,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 +1601,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 +1653,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) {
@@ -3687,7 +3710,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 +3730,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 +3969,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 +4051,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 +4255,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 +4284,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 +4313,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed,
 		sourceMapper,
-		timing,
+		timing: resultTiming,
 		version
 	}) : "";
 	if (luauTiming !== void 0) printLuauTiming(luauTiming);
@@ -4194,7 +4325,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed > 0 ? writeCounts.failed : void 0,
 		sourceMapper,
-		timing
+		timing: resultTiming
 	};
 }
 /**
@@ -4202,8 +4333,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),
@@ -6347,89 +6480,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 +7950,26 @@ 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/multi.ts
@@ -7916,30 +7977,52 @@ 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 { allTypeTestFiles, pendingJobs } = timing.profile("collectPendingJobs", () => {
+		return collectPendingJobs({
+			cliFiles: cli.files,
+			effectivePlaceFile: effectiveConfig.placeFile,
+			filesByProject,
+			projects,
+			rootConfig
+		});
 	});
-	const projectResults = await runJobs(backend, pendingJobs, parallel);
+	const projectResults = await runJobs(backend, pendingJobs, parallel, timing);
 	const uniqueTypeTestFiles = [...new Set(allTypeTestFiles)];
-	const typecheckResult = uniqueTypeTestFiles.length > 0 ? runTypecheck({
-		files: uniqueTypeTestFiles,
-		rootDir: rootConfig.rootDir,
-		tsconfig: rootConfig.typecheckTsconfig
+	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 {
@@ -8027,28 +8110,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,9 +8211,14 @@ 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 config = timing.profile("narrowConfigByFiles", () => {
+		return narrowConfigByFiles(options.config, cli.files ?? []);
+	});
+	timing.profile("resolveSetupFilePaths", () => {
+		resolveSetupFilePaths(config);
+	});
+	const discovery = timing.profile("discoverTestFiles", () => discoverTestFiles(config, cli.files));
 	if (discovery.files.length === 0) {
 		if (config.passWithNoTests) return {
 			mode: "single",
@@ -8140,7 +8231,9 @@ async function runSingleProject(options) {
 			validationExitCode: 2
 		};
 	}
-	const { runtimeFiles, typeTestFiles } = classifyTestFiles(discovery.files, config);
+	const { runtimeFiles, typeTestFiles } = timing.profile("classifyTestFiles", () => {
+		return classifyTestFiles(discovery.files, config);
+	});
 	if (typeTestFiles.length === 0 && runtimeFiles.length === 0) {
 		if (config.passWithNoTests) return {
 			mode: "single",
@@ -8157,19 +8250,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 +8278,25 @@ async function runSingleProject(options) {
 		typecheckResult
 	};
 }
-async function executeRuntimeTests(options, config, testFiles, totalFiles) {
+async function executeRuntimeTests(options) {
+	const { cli, config, testFiles, timing, totalFiles } = options;
 	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);
+	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 +9032,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 +9146,7 @@ async function runWorkspaceProfiled(options, timing) {
 				};
 			}),
 			startTime,
+			timing,
 			version,
 			...dispatchSpec
 		});
@@ -9642,7 +9745,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,
@@ -9715,6 +9818,7 @@ async function runWorkspaceMode(cli, workspace) {
 			...onStreamingResult !== void 0 ? { onStreamingResult } : {},
 			packageInfos,
 			runOptions,
+			timing,
 			version: VERSION,
 			workspaceRoot,
 			workStealingCredentials
@@ -9817,18 +9921,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 };