@isentinel/jest-roblox 0.3.0 → 0.3.1

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.1";
 //#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);
@@ -24412,6 +24417,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 +24428,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 +24569,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 +24621,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) {
@@ -30020,7 +30048,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 +30068,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 +30307,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 +30389,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 +30593,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 +30622,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 +30651,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed,
 		sourceMapper,
-		timing,
+		timing: resultTiming,
 		version
 	}) : "";
 	if (luauTiming !== void 0) printLuauTiming(luauTiming);
@@ -30527,7 +30663,7 @@ function processProjectResult(entry, options) {
 		result,
 		snapshotWriteFailures: writeCounts.failed > 0 ? writeCounts.failed : void 0,
 		sourceMapper,
-		timing
+		timing: resultTiming
 	};
 }
 /**
@@ -30535,8 +30671,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),
@@ -38915,89 +39053,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 +40527,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 = 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/multi.ts
@@ -40488,30 +40554,52 @@ 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 { allTypeTestFiles, pendingJobs } = timing.profile("collectPendingJobs", () => {
+		return collectPendingJobs({
+			cliFiles: cli.files,
+			effectivePlaceFile: effectiveConfig.placeFile,
+			filesByProject,
+			projects,
+			rootConfig
+		});
+	});
+	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 {
@@ -40599,28 +40687,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,9 +40788,14 @@ 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 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",
@@ -40712,7 +40808,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",
@@ -40729,19 +40827,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 +40855,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) node_process.default.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$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 +41609,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 +41723,7 @@ async function runWorkspaceProfiled(options, timing) {
 				};
 			}),
 			startTime,
+			timing,
 			version,
 			...dispatchSpec
 		});
@@ -42215,7 +42323,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,
@@ -42288,6 +42396,7 @@ async function runWorkspaceMode(cli, workspace) {
 			...onStreamingResult !== void 0 ? { onStreamingResult } : {},
 			packageInfos,
 			runOptions,
+			timing,
 			version: VERSION$1,
 			workspaceRoot,
 			workStealingCredentials
@@ -42390,18 +42499,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
 //#region src/utils/error-chain.ts