@isentinel/jest-roblox 0.0.8 → 0.1.1

package/dist/cli.mjs

@@ -1,14 +1,20 @@
-import { C as createStudioBackend, O as LuauScriptError, T as createOpenCloudBackend, a as formatAnnotations, c as execute, d as writeJsonFile, g as loadConfig, h as rojoProjectSchema, i as runTypecheck, l as loadCoverageManifest, n as parseGameOutput, o as formatJobSummary, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, x as isValidBackend, y as VALID_BACKENDS } from "./game-output-M8du29nj.mjs";
+import { D as createOpenCloudBackend, I as isValidBackend, L as LuauScriptError, M as ROOT_ONLY_KEYS, N as VALID_BACKENDS, O as hashBuffer, S as loadConfig$1, T as createStudioBackend, _ as formatResult, a as formatAnnotations, b as formatBanner, c as execute, d as findFormatterOptions, g as formatMultiProjectResult, i as runTypecheck, l as formatExecuteOutput, m as formatCompactMultiProject, n as parseGameOutput, o as formatJobSummary, p as writeJsonFile, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, u as loadCoverageManifest, x as rojoProjectSchema, y as formatTypecheckSummary } from "./game-output-C0_-YIAY.mjs";
+import { createRequire } from "node:module";
+import { type } from "arktype";
 import assert from "node:assert";
-import * as fs from "node:fs";
+import * as fs$1 from "node:fs";
+import fs from "node:fs";
 import * as path$1 from "node:path";
+import path from "node:path";
 import process from "node:process";
 import { parseArgs as parseArgs$1 } from "node:util";
+import { isAgent } from "std-env";
 import color from "tinyrainbow";
 import { WebSocketServer } from "ws";
-import { type } from "arktype";
+import { loadConfig } from "c12";
 import * as os from "node:os";
 import { Buffer } from "node:buffer";
+import { RojoResolver } from "@roblox-ts/rojo-resolver";
 import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import { getTsconfig } from "get-tsconfig";
 import picomatch from "picomatch";
@@ -16,10 +22,8 @@ import * as cp from "node:child_process";
 import istanbulCoverage from "istanbul-lib-coverage";
 import istanbulReport from "istanbul-lib-report";
 import istanbulReports from "istanbul-reports";
-
 //#region package.json
-var version = "0.0.8";
-
+var version = "0.1.1";
 //#endregion
 //#region src/backends/auto.ts
 var StudioWithFallback = class {
@@ -96,7 +100,311 @@ async function resolveBackend(config, probe = probeStudioPlugin) {
 function hasOpenCloudCredentials() {
 	return process.env["ROBLOX_OPEN_CLOUD_API_KEY"] !== void 0 && process.env["ROBLOX_UNIVERSE_ID"] !== void 0 && process.env["ROBLOX_PLACE_ID"] !== void 0;
 }
-
+//#endregion
+//#region src/config/errors.ts
+var ConfigError = class extends Error {
+	hint;
+	constructor(message, hint) {
+		super(message);
+		this.hint = hint;
+	}
+};
+//#endregion
+//#region src/utils/extensions.ts
+function stripTsExtension(pattern) {
+	return pattern.replace(/\.(tsx?|luau?)$/, "");
+}
+//#endregion
+//#region src/utils/rojo-tree.ts
+function collectPaths(node, result) {
+	for (const [key, value] of Object.entries(node)) if (key === "$path" && typeof value === "string") result.push(value.replaceAll("\\", "/"));
+	else if (typeof value === "object" && !Array.isArray(value) && !key.startsWith("$")) collectPaths(value, result);
+}
+//#endregion
+//#region src/config/projects.ts
+function extractStaticRoot(pattern) {
+	const globChars = new Set([
+		"*",
+		"?",
+		"[",
+		"{"
+	]);
+	let firstGlobIndex = -1;
+	for (const [index, char] of [...pattern].entries()) if (globChars.has(char)) {
+		firstGlobIndex = index;
+		break;
+	}
+	if (firstGlobIndex === -1) {
+		const directory = path$1.posix.dirname(pattern);
+		return {
+			glob: path$1.posix.basename(pattern),
+			root: directory
+		};
+	}
+	const lastSlash = pattern.slice(0, firstGlobIndex).lastIndexOf("/");
+	if (lastSlash === -1) throw new Error("Include pattern must have a static directory prefix");
+	return {
+		glob: pattern.slice(lastSlash + 1),
+		root: pattern.slice(0, lastSlash)
+	};
+}
+function extractProjectRoots(include) {
+	const rootMap = /* @__PURE__ */ new Map();
+	for (const pattern of include) {
+		const { glob, root } = extractStaticRoot(pattern);
+		const stripped = stripTsExtension(glob);
+		const qualified = stripped.includes("/") ? stripped : `**/${stripped}`;
+		let patterns = rootMap.get(root);
+		if (patterns === void 0) {
+			patterns = [];
+			rootMap.set(root, patterns);
+		}
+		patterns.push(qualified);
+	}
+	return [...rootMap.entries()].map(([root, testMatch]) => ({
+		root,
+		testMatch
+	}));
+}
+function mapFsRootToDataModel(outDirectory, rojoTree) {
+	const normalized = outDirectory.replace(/\/$/, "");
+	const result = findInTree(rojoTree, normalized, "");
+	if (result === void 0) {
+		const available = [];
+		collectPaths(rojoTree, available);
+		let message = `No Rojo tree mapping found for path: ${normalized}`;
+		if (available.length > 0) message += `\n\nAvailable $path entries: ${available.join(", ")}`;
+		const hint = normalized.startsWith("src/") ? "Path starts with \"src/\" — if using roblox-ts, set \"outDir\" in your project config to the compiled output directory (e.g. \"out/client\")" : void 0;
+		throw new ConfigError(message, hint);
+	}
+	return result;
+}
+function validateProjects(projects) {
+	const names = /* @__PURE__ */ new Set();
+	for (const project of projects) {
+		const name = typeof project.displayName === "string" ? project.displayName : project.displayName.name;
+		if (name === "") throw new Error("Project must have a non-empty displayName");
+		if (names.has(name)) throw new Error(`Duplicate project displayName: ${name}`);
+		names.add(name);
+		if (project.include.length === 0) throw new Error(`Project "${name}" must have at least one include pattern`);
+	}
+}
+const PROJECT_ONLY_KEYS = new Set([
+	"displayName",
+	"exclude",
+	"include",
+	"outDir",
+	"root"
+]);
+function resolveProjectConfig(project, rootConfig, rojoTree) {
+	const roots = extractProjectRoots(project.include);
+	const testMatch = roots.flatMap((entry) => entry.testMatch);
+	const projectRoot = project.root;
+	if (roots.length > 1 && project.outDir === void 0) {
+		const name = typeof project.displayName === "string" ? project.displayName : project.displayName.name;
+		throw new Error(`Project "${name}" has multiple include roots but no outDir. Set outDir or split into separate projects.`);
+	}
+	const resolvedOutDirectory = resolveOutDirectory(project.outDir, projectRoot, roots[0]?.root);
+	const dataModelPath = resolvedOutDirectory !== void 0 ? mapFsRootToDataModel(resolvedOutDirectory, rojoTree) : void 0;
+	const resolvedInclude = projectRoot === void 0 ? project.include : project.include.map((pattern) => path$1.posix.join(projectRoot, pattern));
+	const config = mergeProjectConfig(rootConfig, project);
+	const displayName = typeof project.displayName === "string" ? project.displayName : project.displayName.name;
+	return {
+		config,
+		displayColor: typeof project.displayName === "string" ? void 0 : project.displayName.color,
+		displayName,
+		include: resolvedInclude,
+		outDir: resolvedOutDirectory,
+		projects: dataModelPath !== void 0 ? [dataModelPath] : [],
+		testMatch
+	};
+}
+async function loadProjectConfigFile(filePath, cwd) {
+	let result;
+	try {
+		result = await loadConfig({
+			name: "jest-project",
+			configFile: filePath,
+			configFileRequired: true,
+			cwd,
+			dotenv: false,
+			globalRc: false,
+			omit$Keys: true,
+			packageJson: false,
+			rcFile: false
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to load project config file ${filePath}: ${message}`, { cause: err });
+	}
+	const { config } = result;
+	if ((typeof config.displayName === "string" ? config.displayName : config.displayName.name) === "") throw new Error(`Project config file "${filePath}" must have a displayName`);
+	return config;
+}
+async function resolveAllProjects(entries, rootConfig, rojoTree, cwd) {
+	const projects = [];
+	for (const entry of entries) if (typeof entry === "string") {
+		const loaded = await loadProjectConfigFile(entry, cwd);
+		projects.push(loaded);
+	} else projects.push(entry.test);
+	validateProjects(projects);
+	return projects.map((project) => resolveProjectConfig(project, rootConfig, rojoTree));
+}
+/** When outDir is omitted (pure Luau), falls back to include pattern's static root. */
+function resolveOutDirectory(projectOutDirectory, projectRoot, fallbackRoot) {
+	const base = projectOutDirectory ?? fallbackRoot;
+	if (base === void 0) return;
+	return projectRoot !== void 0 ? path$1.posix.join(projectRoot, base) : base;
+}
+function mergeProjectConfig(rootConfig, project) {
+	const merged = { ...rootConfig };
+	for (const [key, value] of Object.entries(project)) if (!PROJECT_ONLY_KEYS.has(key) && value !== void 0) merged[key] = value;
+	return merged;
+}
+function matchNodePath(childNode, targetPath, childDataModelPath) {
+	const nodePath = childNode.$path;
+	if (typeof nodePath !== "string") return;
+	const normalizedNodePath = nodePath.replace(/\/$/, "");
+	if (normalizedNodePath === targetPath) return childDataModelPath;
+	if (targetPath.startsWith(`${normalizedNodePath}/`)) return `${childDataModelPath}/${targetPath.slice(normalizedNodePath.length + 1)}`;
+}
+function findInTree(node, targetPath, currentDataModelPath) {
+	for (const [key, value] of Object.entries(node)) {
+		if (key.startsWith("$") || typeof value !== "object") continue;
+		const childNode = value;
+		const childDataModelPath = currentDataModelPath === "" ? key : `${currentDataModelPath}/${key}`;
+		const pathMatch = matchNodePath(childNode, targetPath, childDataModelPath);
+		if (pathMatch !== void 0) return pathMatch;
+		const found = findInTree(childNode, targetPath, childDataModelPath);
+		if (found !== void 0) return found;
+	}
+}
+//#endregion
+//#region src/config/setup-resolver.ts
+const PROBE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".lua",
+	".luau"
+];
+function createSetupResolver(options) {
+	const { configDirectory, resolveModule, rojoConfigPath } = options;
+	const resolve = resolveModule ?? createRequire(path$1.join(configDirectory, "noop.js")).resolve;
+	const rojoResolver = RojoResolver.fromPath(rojoConfigPath);
+	return (input) => {
+		let absolutePath;
+		if (isRelativePath(input)) absolutePath = path$1.resolve(configDirectory, input);
+		else {
+			resolvePackageSpecifier(resolve, input);
+			absolutePath = path$1.resolve(configDirectory, "node_modules", input);
+		}
+		const rbxPath = rojoResolver.getRbxPathFromFilePath(absolutePath);
+		if (rbxPath === void 0) throw new Error(`No matching path found in rojo project tree for "${input}" (resolved to: ${absolutePath})`);
+		return rbxPath.join("/");
+	};
+}
+function isRelativePath(input) {
+	return input.startsWith("./") || input.startsWith("../");
+}
+function resolvePackageSpecifier(resolve, input) {
+	try {
+		resolve(input);
+		return;
+	} catch {}
+	for (const extension of PROBE_EXTENSIONS) try {
+		resolve(`${input}${extension}`);
+		return;
+	} catch {}
+	throw new Error(`Could not resolve module "${input}". Ensure the package is installed.`);
+}
+//#endregion
+//#region src/config/stubs.ts
+const HEADER = "-- Auto-generated by jest-roblox (do not edit)\n";
+const SKIP_FIELDS = new Set(["exclude", "include"]);
+function serializeToLuau(config) {
+	let output = `${HEADER}return {\n`;
+	for (const [key, value] of Object.entries(config)) {
+		if (SKIP_FIELDS.has(key)) continue;
+		if (value === void 0) continue;
+		let serialized;
+		if (key === "testMatch" && Array.isArray(value)) serialized = serializeLuauValue(value.map((pattern) => stripTsExtension(pattern)), "	");
+		else serialized = serializeLuauValue(value, "	");
+		output += `\t${key} = ${serialized},\n`;
+	}
+	output += "}\n";
+	return output;
+}
+function generateProjectConfigs(projects) {
+	for (const project of projects) {
+		const content = serializeToLuau(project.config);
+		const directory = path.dirname(project.outputPath);
+		fs.mkdirSync(directory, { recursive: true });
+		fs.writeFileSync(project.outputPath, content, "utf8");
+	}
+}
+function syncStubsToShadowDirectory(projects, rootDirectory, shadowDirectory) {
+	let changed = false;
+	const expectedPaths = /* @__PURE__ */ new Set();
+	for (const project of projects) {
+		if (project.outDir === void 0) continue;
+		if (path.isAbsolute(project.outDir)) throw new Error(`Project "${project.displayName}" outDir must be a relative path, got: ${project.outDir}`);
+		const stubName = "jest.config.lua";
+		const sourcePath = path.resolve(rootDirectory, project.outDir, stubName);
+		if (!fs.existsSync(sourcePath)) continue;
+		const targetPath = path.resolve(shadowDirectory, project.outDir, stubName);
+		expectedPaths.add(targetPath);
+		const sourceContent = fs.readFileSync(sourcePath);
+		if (fs.existsSync(targetPath)) {
+			const targetContent = fs.readFileSync(targetPath);
+			if (Buffer.compare(sourceContent, targetContent) === 0) continue;
+		}
+		fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+		fs.copyFileSync(sourcePath, targetPath);
+		changed = true;
+	}
+	for (const existing of findShadowStubs(shadowDirectory)) if (!expectedPaths.has(existing)) {
+		fs.unlinkSync(existing);
+		removeEmptyParents(path.dirname(existing), shadowDirectory);
+		changed = true;
+	}
+	return changed;
+}
+function escapeString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function serializeLuauValue(value, indent) {
+	if (typeof value === "string") return `"${escapeString(value)}"`;
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") return String(value);
+	if (Array.isArray(value)) return `{ ${value.map((item) => serializeLuauValue(item, indent)).join(", ")} }`;
+	if (typeof value === "object" && value !== null) {
+		const nextIndent = `${indent}\t`;
+		return `{ ${Object.entries(value).filter(([, value_]) => value_ !== void 0).map(([key, value_]) => `${key} = ${serializeLuauValue(value_, nextIndent)}`).join(", ")} }`;
+	}
+	return String(value);
+}
+function removeEmptyParents(directory, stopAt) {
+	const resolved = path.resolve(directory);
+	const resolvedStop = path.resolve(stopAt);
+	if (resolved === resolvedStop || !resolved.startsWith(resolvedStop)) return;
+	try {
+		if (fs.readdirSync(resolved).length === 0) {
+			fs.rmdirSync(resolved);
+			removeEmptyParents(path.dirname(resolved), stopAt);
+		}
+	} catch {}
+}
+function findShadowStubs(directory) {
+	const results = [];
+	if (!fs.existsSync(directory)) return results;
+	const entries = fs.readdirSync(directory, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path.resolve(directory, entry.name);
+		if (entry.isDirectory()) results.push(...findShadowStubs(fullPath));
+		else if (entry.name === "jest.config.lua") results.push(fullPath);
+	}
+	return results;
+}
 //#endregion
 //#region src/coverage/mapper.ts
 const positionSchema = type({
@@ -142,8 +450,8 @@ function loadFileResources(record) {
 	let coverageMapRaw;
 	let sourceMapRaw;
 	try {
-		coverageMapRaw = fs.readFileSync(record.coverageMapPath, "utf-8");
-		sourceMapRaw = fs.readFileSync(record.sourceMapPath, "utf-8");
+		coverageMapRaw = fs$1.readFileSync(record.coverageMapPath, "utf-8");
+		sourceMapRaw = fs$1.readFileSync(record.sourceMapPath, "utf-8");
 	} catch {
 		return;
 	}
@@ -393,7 +701,6 @@ function buildResult(pending, pendingFunctions, pendingBranches) {
 	}
 	return { files };
 }
-
 //#endregion
 //#region src/types/luau-ast.ts
 const INSTRUMENTABLE_STATEMENT_TAGS = new Set([
@@ -413,7 +720,6 @@ const INSTRUMENTABLE_STATEMENT_TAGS = new Set([
 	"return",
 	"while"
 ]);
-
 //#endregion
 //#region src/coverage/luau-visitor.ts
 function visitExpression(expression, visitor) {
@@ -684,7 +990,6 @@ function visitExprInstantiate(node, visitor) {
 	if (visitor.visitExprInstantiate?.(node) === false) return;
 	visitExpression(node.expr, visitor);
 }
-
 //#endregion
 //#region src/coverage/coverage-collector.ts
 const END_KEYWORD_LENGTH = 3;
@@ -875,7 +1180,6 @@ function extractExprName(expr) {
 function extractFunctionName(node) {
 	return extractExprName(node.name);
 }
-
 //#endregion
 //#region src/coverage/coverage-map-builder.ts
 function buildCoverageMap$1(result) {
@@ -926,11 +1230,9 @@ function buildCoverageMap$1(result) {
 		statementMap
 	};
 }
-
 //#endregion
 //#region src/coverage/parse-ast.luau
-var parse_ast_default = "local fs = require(\"@std/fs\")\nlocal json = require(\"@std/json\")\nlocal process = require(\"@std/process\")\nlocal syntax = require(\"@std/syntax\")\n\nlocal rawArgs = process.args\nlocal userArgs: { string } = {}\nlocal pastSeparator = false\n\nfor _, arg in rawArgs do\n	if pastSeparator then\n		table.insert(userArgs, arg)\n	elseif arg == \"--\" then\n		pastSeparator = true\n	end\nend\n\nlocal luauRoot = userArgs[1]\nlocal outputDir = userArgs[2]\nif not luauRoot or not outputDir then\n	error(\"Usage: lute run parse-ast.luau -- <luau-root> <output-dir>\")\nend\n\nluauRoot = string.gsub(luauRoot, \"\\\\\", \"/\")\noutputDir = string.gsub(outputDir, \"\\\\\", \"/\")\n\n-- Fields to keep per AST tag (beyond tag/kind/location which are always kept).\n-- Tags shared by stat/expr variants are merged — nil fields are harmless.\nlocal KEEP: { [string]: { string } } = {\n	assign = { \"values\", \"variables\" },\n	binary = { \"lhsoperand\", \"rhsoperand\" },\n	block = { \"statements\" },\n	call = { \"arguments\", \"func\" },\n	cast = { \"operand\" },\n	compoundassign = { \"value\", \"variable\" },\n	conditional = { \"condition\", \"thenblock\", \"elseifs\", \"elseblock\", \"thenexpr\", \"elseexpr\" },\n	[\"do\"] = { \"body\" },\n	expression = { \"expression\" },\n	[\"for\"] = { \"body\", \"from\", \"to\", \"step\" },\n	forin = { \"body\", \"values\" },\n	[\"function\"] = { \"body\", \"name\", \"func\" },\n	global = { \"name\" },\n	group = { \"expression\" },\n	index = { \"expression\", \"index\" },\n	indexname = { \"expression\", \"accessor\", \"index\" },\n	instantiate = { \"expr\" },\n	interpolatedstring = { \"expressions\" },\n	[\"local\"] = { \"values\", \"variables\" },\n	localfunction = { \"name\", \"func\" },\n	[\"repeat\"] = { \"body\", \"condition\" },\n	[\"return\"] = { \"expressions\" },\n	table = { \"entries\" },\n	unary = { \"operand\" },\n	[\"while\"] = { \"body\", \"condition\" },\n}\n\nlocal function strip(value: any): any\n	if type(value) ~= \"table\" then\n		return value\n	end\n\n	-- LuauSpan — has beginline, no tag\n	if value.beginline ~= nil then\n		return value\n	end\n\n	-- Token — has text but no tag, reduce to {text}\n	if value.text ~= nil and value.tag == nil then\n		return { text = value.text }\n	end\n\n	-- AST node — has tag, keep only allowlisted fields\n	if value.tag ~= nil then\n		local result = { tag = value.tag, kind = value.kind, location = value.location }\n		local fields = KEEP[value.tag :: string]\n		if fields then\n			for _, field in fields do\n				if value[field] ~= nil then\n					result[field] = strip(value[field])\n				end\n			end\n		end\n\n		return result\n	end\n\n	-- Other tables (arrays, Pairs, ElseIf structs) — recurse all fields\n	local result: any = {}\n	for k, v in value do\n		result[k] = strip(v)\n	end\n\n	return result\nend\n\n-- Discover .luau files recursively, skipping node_modules, dot dirs, spec/test files\nlocal function discoverFiles(directory: string, relativeTo: string, results: { string })\n	local entries = fs.listdirectory(directory)\n	for _, entry in entries do\n		local fullPath = directory .. \"/\" .. entry.name\n		if entry.type == \"dir\" then\n			if entry.name == \"node_modules\" or entry.name == \".jest-roblox-coverage\" then\n				continue\n			end\n\n			if string.sub(entry.name, 1, 1) == \".\" then\n				continue\n			end\n\n			discoverFiles(fullPath, relativeTo, results)\n		elseif\n			entry.type == \"file\"\n			and (string.sub(entry.name, -5) == \".luau\" or string.sub(entry.name, -4) == \".lua\")\n		then\n			if\n				string.sub(entry.name, -10) == \".spec.luau\"\n				or string.sub(entry.name, -10) == \".test.luau\"\n				or string.sub(entry.name, -9) == \".spec.lua\"\n				or string.sub(entry.name, -9) == \".test.lua\"\n			then\n				continue\n			end\n\n			-- Compute relative path\n			local relative = string.sub(fullPath, #relativeTo + 2)\n			table.insert(results, relative)\n		end\n	end\nend\n\nlocal function dirname(filepath: string): string\n	local pos = string.find(filepath, \"/[^/]*$\")\n	if pos then\n		return string.sub(filepath, 1, pos - 1)\n	end\n\n	return \"\"\nend\n\nlocal files: { string } = {}\ndiscoverFiles(luauRoot, luauRoot, files)\n\n-- Parse, strip, and write per-file AST JSON\nfor _, relativePath in files do\n	local fullPath = luauRoot .. \"/\" .. relativePath\n	local source = fs.readfiletostring(fullPath)\n	local parseResult = syntax.parse(source)\n	local stripped = strip(parseResult.root)\n\n	local outPath = outputDir .. \"/\" .. relativePath .. \".json\"\n	local dir = dirname(outPath)\n	if dir ~= \"\" then\n		fs.createdirectory(dir, { makeparents = true })\n	end\n\n	fs.writestringtofile(outPath, json.serialize(stripped))\nend\n\n-- Print file list to stdout (tiny — just paths)\nprint(json.serialize(files :: json.array))\n";
-
+var parse_ast_default = "local fs = require(\"@std/fs\")\nlocal json = require(\"@std/json\")\nlocal process = require(\"@std/process\")\nlocal syntax = require(\"@std/syntax\")\n\nlocal rawArgs = process.args\nlocal userArgs: { string } = {}\nlocal pastSeparator = false\n\nfor _, arg in rawArgs do\n	if pastSeparator then\n		table.insert(userArgs, arg)\n	elseif arg == \"--\" then\n		pastSeparator = true\n	end\nend\n\nlocal luauRoot = userArgs[1]\nlocal outputDir = userArgs[2]\nif not luauRoot or not outputDir then\n	error(\"Usage: lute run parse-ast.luau -- <luau-root> <output-dir>\")\nend\n\nluauRoot = string.gsub(luauRoot, \"\\\\\", \"/\")\noutputDir = string.gsub(outputDir, \"\\\\\", \"/\")\n\n-- Fields to keep per AST tag (beyond tag/kind/location which are always kept).\n-- Tags shared by stat/expr variants are merged — nil fields are harmless.\nlocal KEEP: { [string]: { string } } = {\n	assign = { \"values\", \"variables\" },\n	binary = { \"lhsoperand\", \"rhsoperand\" },\n	block = { \"statements\" },\n	call = { \"arguments\", \"func\" },\n	cast = { \"operand\" },\n	compoundassign = { \"value\", \"variable\" },\n	conditional = { \"condition\", \"thenblock\", \"elseifs\", \"elseblock\", \"thenexpr\", \"elseexpr\" },\n	[\"do\"] = { \"body\" },\n	expression = { \"expression\" },\n	[\"for\"] = { \"body\", \"from\", \"to\", \"step\" },\n	forin = { \"body\", \"values\" },\n	[\"function\"] = { \"body\", \"name\", \"func\" },\n	global = { \"name\" },\n	group = { \"expression\" },\n	index = { \"expression\", \"index\" },\n	indexname = { \"expression\", \"accessor\", \"index\" },\n	instantiate = { \"expr\" },\n	interpolatedstring = { \"expressions\" },\n	[\"local\"] = { \"values\", \"variables\" },\n	localfunction = { \"name\", \"func\" },\n	[\"repeat\"] = { \"body\", \"condition\" },\n	[\"return\"] = { \"expressions\" },\n	table = { \"entries\" },\n	unary = { \"operand\" },\n	[\"while\"] = { \"body\", \"condition\" },\n}\n\nlocal function strip(value: any): any\n	if type(value) ~= \"table\" then\n		return value\n	end\n\n	-- LuauSpan — has beginline, no tag\n	if value.beginline ~= nil then\n		return value\n	end\n\n	-- Token — has text but no tag, reduce to {text}\n	if value.text ~= nil and value.tag == nil then\n		return { text = value.text }\n	end\n\n	-- AST node — has tag, keep only allowlisted fields\n	if value.tag ~= nil then\n		local result = { tag = value.tag, kind = value.kind, location = value.location }\n		local fields = KEEP[value.tag :: string]\n		if fields then\n			for _, field in fields do\n				if value[field] ~= nil then\n					result[field] = strip(value[field])\n				end\n			end\n		end\n\n		return result\n	end\n\n	-- Other tables (arrays, Pairs, ElseIf structs) — recurse all fields\n	local result: any = {}\n	for k, v in value do\n		result[k] = strip(v)\n	end\n\n	return result\nend\n\n-- Discover .luau files recursively, skipping node_modules, dot dirs, spec/test files\nlocal function discoverFiles(directory: string, relativeTo: string, results: { string })\n	local entries = fs.listdirectory(directory)\n	for _, entry in entries do\n		local fullPath = directory .. \"/\" .. entry.name\n		if entry.type == \"dir\" then\n			if entry.name == \"node_modules\" or entry.name == \".jest-roblox-coverage\" then\n				continue\n			end\n\n			if string.sub(entry.name, 1, 1) == \".\" then\n				continue\n			end\n\n			discoverFiles(fullPath, relativeTo, results)\n		elseif\n			entry.type == \"file\"\n			and (string.sub(entry.name, -5) == \".luau\" or string.sub(entry.name, -4) == \".lua\")\n		then\n			if\n				string.sub(entry.name, -10) == \".spec.luau\"\n				or string.sub(entry.name, -10) == \".test.luau\"\n				or string.sub(entry.name, -9) == \".spec.lua\"\n				or string.sub(entry.name, -9) == \".test.lua\"\n				or string.sub(entry.name, -10) == \".snap.luau\"\n				or string.sub(entry.name, -9) == \".snap.lua\"\n			then\n				continue\n			end\n\n			-- Compute relative path\n			local relative = string.sub(fullPath, #relativeTo + 2)\n			table.insert(results, relative)\n		end\n	end\nend\n\nlocal function dirname(filepath: string): string\n	local pos = string.find(filepath, \"/[^/]*$\")\n	if pos then\n		return string.sub(filepath, 1, pos - 1)\n	end\n\n	return \"\"\nend\n\nlocal files: { string } = {}\ndiscoverFiles(luauRoot, luauRoot, files)\n\n-- Parse, strip, and write per-file AST JSON\nfor _, relativePath in files do\n	local fullPath = luauRoot .. \"/\" .. relativePath\n	local source = fs.readfiletostring(fullPath)\n	local parseResult = syntax.parse(source)\n	local stripped = strip(parseResult.root)\n\n	local outPath = outputDir .. \"/\" .. relativePath .. \".json\"\n	local dir = dirname(outPath)\n	if dir ~= \"\" then\n		fs.createdirectory(dir, { makeparents = true })\n	end\n\n	fs.writestringtofile(outPath, json.serialize(stripped))\nend\n\n-- Print file list to stdout (tiny — just paths)\nprint(json.serialize(files :: json.array))\n";
 //#endregion
 //#region src/coverage/probe-inserter.ts
 function insertProbes(source, result, fileKey) {
@@ -1040,7 +1342,6 @@ function buildPreamble(modeDirective, fileKey, result) {
 	}
 	return preamble;
 }
-
 //#endregion
 //#region src/coverage/instrumenter.ts
 let cachedTemporaryDirectory;
@@ -1049,12 +1350,12 @@ let cachedTemporaryDirectory;
 * writing a manifest — used by `prepareCoverage()` to merge multiple roots.
 */
 function instrumentRoot(options) {
-	const { luauRoot, parseScript, shadowDir } = options;
-	const lazyTemporaryDirectory = parseScript === void 0 || options.astOutputDirectory === void 0 ? getTemporaryDirectory() : "";
+	const { astOutputDirectory: astOutputDirectoryOption, luauRoot, parseScript, shadowDir, skipFiles } = options;
+	const lazyTemporaryDirectory = parseScript === void 0 || astOutputDirectoryOption === void 0 ? getTemporaryDirectory() : "";
 	const scriptPath = parseScript ?? path$1.join(lazyTemporaryDirectory, "parse-ast.luau");
-	const astOutputDirectory = options.astOutputDirectory ?? path$1.join(lazyTemporaryDirectory, "asts");
-	if (parseScript === void 0) fs.writeFileSync(scriptPath, parse_ast_default);
-	fs.mkdirSync(astOutputDirectory, { recursive: true });
+	const astOutputDirectory = astOutputDirectoryOption ?? path$1.join(lazyTemporaryDirectory, "asts");
+	if (parseScript === void 0) fs$1.writeFileSync(scriptPath, parse_ast_default);
+	fs$1.mkdirSync(astOutputDirectory, { recursive: true });
 	let fileListJson;
 	try {
 		fileListJson = cp.execFileSync("lute", [
@@ -1081,10 +1382,11 @@ function instrumentRoot(options) {
 	const files = {};
 	const posixLuauRoot = toPosix(luauRoot);
 	for (const relativePath of fileList) {
+		if (shouldSkipFile(relativePath, skipFiles)) continue;
 		const astJsonPath = path$1.join(astOutputDirectory, `${relativePath}.json`);
 		let astJson;
 		try {
-			astJson = fs.readFileSync(astJsonPath, "utf-8");
+			astJson = fs$1.readFileSync(astJsonPath, "utf-8");
 		} catch (err) {
 			throw new Error(`Failed to read AST for ${relativePath}`, { cause: err });
 		}
@@ -1095,13 +1397,14 @@ function instrumentRoot(options) {
 		const coverageMapOutputPath = path$1.join(shadowDir, relativePath.replace(/\.luau$/, ".cov-map.json"));
 		const sourceMapPath = `${originalLuauPath}.map`;
 		const outputDirectory = path$1.dirname(path$1.join(shadowDir, relativePath));
-		fs.mkdirSync(outputDirectory, { recursive: true });
-		const source = fs.readFileSync(path$1.resolve(originalLuauPath), "utf-8");
+		fs$1.mkdirSync(outputDirectory, { recursive: true });
+		const sourceBuffer = fs$1.readFileSync(path$1.resolve(originalLuauPath));
+		const source = sourceBuffer.toString("utf-8");
 		const collectorResult = collectCoverage(ast);
 		const instrumentedSource = insertProbes(source, collectorResult, fileKey);
 		const coverageMap = buildCoverageMap$1(collectorResult);
-		fs.writeFileSync(path$1.join(shadowDir, relativePath), instrumentedSource);
-		fs.writeFileSync(coverageMapOutputPath, JSON.stringify(coverageMap, void 0, "	"));
+		fs$1.writeFileSync(path$1.join(shadowDir, relativePath), instrumentedSource);
+		fs$1.writeFileSync(coverageMapOutputPath, JSON.stringify(coverageMap, void 0, "	"));
 		files[fileKey] = {
 			key: fileKey,
 			branchCount: collectorResult.branches.length,
@@ -1109,21 +1412,25 @@ function instrumentRoot(options) {
 			functionCount: collectorResult.functions.length,
 			instrumentedLuauPath,
 			originalLuauPath,
+			sourceHash: hashBuffer(sourceBuffer),
 			sourceMapPath,
 			statementCount: collectorResult.statements.length
 		};
 	}
 	return files;
 }
+function shouldSkipFile(relativePath, skipFiles) {
+	if (relativePath.endsWith(".snap.luau") || relativePath.endsWith(".snap.lua")) return true;
+	return skipFiles?.has(relativePath) === true;
+}
 function getTemporaryDirectory() {
-	if (cachedTemporaryDirectory !== void 0 && fs.existsSync(cachedTemporaryDirectory)) return cachedTemporaryDirectory;
-	cachedTemporaryDirectory = fs.mkdtempSync(path$1.join(os.tmpdir(), "jest-roblox-instrument-"));
+	if (cachedTemporaryDirectory !== void 0 && fs$1.existsSync(cachedTemporaryDirectory)) return cachedTemporaryDirectory;
+	cachedTemporaryDirectory = fs$1.mkdtempSync(path$1.join(os.tmpdir(), "jest-roblox-instrument-"));
 	return cachedTemporaryDirectory;
 }
 function toPosix(value) {
 	return value.replaceAll("\\", "/");
 }
-
 //#endregion
 //#region src/coverage/rojo-builder.ts
 function buildWithRojo(projectPath, outputPath) {
@@ -1141,7 +1448,6 @@ function buildWithRojo(projectPath, outputPath) {
 		throw new Error(message, { cause: err });
 	}
 }
-
 //#endregion
 //#region src/coverage/rojo-rewriter.ts
 function rewriteRojoProject(project, options) {
@@ -1182,76 +1488,68 @@ function walkTree(node, context) {
 	else result[key] = value;
 	return result;
 }
-
 //#endregion
 //#region src/coverage/prepare.ts
 const COVERAGE_DIR = ".jest-roblox-coverage";
+const previousManifestSchema = type({
+	"files": type({ "[string]": { sourceHash: "string" } }),
+	"instrumenterVersion": "number",
+	"luauRoots": "string[]",
+	"placeFilePath?": "string",
+	"shadowDir": "string",
+	"version": "number"
+}).as();
 function collectLuauRootsFromRojo(project, config) {
 	const paths = [];
 	collectPaths(project.tree, paths);
 	const ignorePatterns = config.coveragePathIgnorePatterns;
 	const isIgnored = picomatch(ignorePatterns, { contains: true });
 	return paths.filter((directoryPath) => {
-		if (!fs.existsSync(directoryPath)) return false;
-		if (!fs.statSync(directoryPath).isDirectory()) return false;
+		if (!fs$1.existsSync(directoryPath)) return false;
+		if (!fs$1.statSync(directoryPath).isDirectory()) return false;
 		if (isIgnored(directoryPath)) return false;
 		return containsLuauFiles(directoryPath);
 	});
 }
-function prepareCoverage(config) {
+function prepareCoverage(config, beforeBuild) {
 	const rojoProjectPath = findRojoProject(config);
 	const luauRoots = resolveLuauRootsWithRojo(config, rojoProjectPath);
-	for (const root of luauRoots) if (path$1.isAbsolute(root)) throw new Error("luauRoots must be relative paths, got absolute path. Set a relative outDir in tsconfig or relative luauRoots in config.");
+	validateRelativeRoots(luauRoots);
 	const manifestPath = path$1.join(COVERAGE_DIR, "manifest.json");
-	if (fs.existsSync(COVERAGE_DIR)) fs.rmSync(COVERAGE_DIR, { recursive: true });
+	const previousManifest = loadPreviousManifest(manifestPath);
+	const useIncremental = canUseIncremental(previousManifest, config);
+	if (!useIncremental && fs$1.existsSync(COVERAGE_DIR)) fs$1.rmSync(COVERAGE_DIR, { recursive: true });
 	const allFiles = {};
 	const roots = [];
+	let hasChanges = !useIncremental;
 	for (const luauRoot of luauRoots) {
-		const shadowDirectory = path$1.join(COVERAGE_DIR, luauRoot).replaceAll("\\", "/");
-		fs.mkdirSync(shadowDirectory, { recursive: true });
-		fs.cpSync(luauRoot, shadowDirectory, { recursive: true });
-		const files = instrumentRoot({
-			luauRoot,
-			shadowDir: shadowDirectory
-		});
-		Object.assign(allFiles, files);
-		const relocatedShadowDirectory = path$1.relative(COVERAGE_DIR, shadowDirectory).replaceAll("\\", "/");
-		roots.push({
-			luauRoot,
-			relocatedShadowDirectory,
-			shadowDir: shadowDirectory
-		});
+		const rootResult = instrumentRootWithCache(luauRoot, useIncremental, previousManifest);
+		if (rootResult.changed) hasChanges = true;
+		Object.assign(allFiles, rootResult.files);
+		roots.push(rootResult.rootEntry);
+	}
+	if (useIncremental && previousManifest !== void 0) {
+		const deleted = detectDeletedFiles(previousManifest, allFiles);
+		cleanupDeletedFiles(deleted);
+		if (deleted.length > 0) hasChanges = true;
+	}
+	if (beforeBuild !== void 0) {
+		if (beforeBuild(COVERAGE_DIR)) hasChanges = true;
 	}
-	const manifest = {
-		files: allFiles,
-		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		luauRoots,
-		shadowDir: COVERAGE_DIR,
-		version: 1
-	};
-	fs.mkdirSync(path$1.dirname(manifestPath), { recursive: true });
-	fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, "	"));
-	const rojoProjectRaw = rojoProjectSchema(JSON.parse(fs.readFileSync(rojoProjectPath, "utf-8")));
-	if (rojoProjectRaw instanceof type.errors) throw new Error(`Malformed Rojo project JSON: ${rojoProjectRaw.toString()}`);
-	const rewritten = rewriteRojoProject(rojoProjectRaw, {
-		projectRelocation: path$1.relative(COVERAGE_DIR, path$1.dirname(rojoProjectPath)).replaceAll("\\", "/"),
-		roots
-	});
-	const rewrittenProjectPath = path$1.join(COVERAGE_DIR, path$1.basename(rojoProjectPath));
-	fs.writeFileSync(rewrittenProjectPath, JSON.stringify(rewritten, void 0, "	"));
 	const placeFile = path$1.join(COVERAGE_DIR, "game.rbxl");
-	buildWithRojo(rewrittenProjectPath, placeFile);
+	const manifest = writeManifest(manifestPath, allFiles, luauRoots, placeFile);
+	if (!hasChanges && previousManifest?.placeFilePath !== void 0) return {
+		manifest,
+		placeFile: previousManifest.placeFilePath
+	};
+	buildRojoProject(rojoProjectPath, roots, placeFile);
 	return {
 		manifest,
 		placeFile
 	};
 }
-function collectPaths(node, result) {
-	for (const [key, value] of Object.entries(node)) if (key === "$path" && typeof value === "string") result.push(value.replaceAll("\\", "/"));
-	else if (typeof value === "object" && !Array.isArray(value) && !key.startsWith("$")) collectPaths(value, result);
-}
 function containsLuauFiles(directoryPath) {
-	return fs.readdirSync(directoryPath, { withFileTypes: true }).some((entry) => {
+	return fs$1.readdirSync(directoryPath, { withFileTypes: true }).some((entry) => {
 		if (entry.isFile() && entry.name.endsWith(".luau")) return true;
 		if (entry.isDirectory()) return containsLuauFiles(path$1.join(directoryPath, entry.name));
 		return false;
@@ -1260,8 +1558,8 @@ function containsLuauFiles(directoryPath) {
 function findRojoProject(config) {
 	if (config.rojoProject !== void 0) return config.rojoProject;
 	const defaultPath = path$1.join(config.rootDir, "default.project.json");
-	if (fs.existsSync(defaultPath)) return defaultPath;
-	const projectFile = fs.readdirSync(config.rootDir, "utf-8").find((file) => file.endsWith(".project.json"));
+	if (fs$1.existsSync(defaultPath)) return defaultPath;
+	const projectFile = fs$1.readdirSync(config.rootDir, "utf-8").find((file) => file.endsWith(".project.json"));
 	if (projectFile !== void 0) return path$1.join(config.rootDir, projectFile);
 	throw new Error("No Rojo project found. Set rojoProject in config or add a .project.json file.");
 }
@@ -1269,7 +1567,7 @@ function resolveLuauRootsWithRojo(config, rojoProjectPath) {
 	if (config.luauRoots !== void 0 && config.luauRoots.length > 0) return config.luauRoots;
 	try {
 		const resolvedPath = rojoProjectPath ?? findRojoProject(config);
-		const roots = collectLuauRootsFromRojo(JSON.parse(fs.readFileSync(resolvedPath, "utf-8")), config);
+		const roots = collectLuauRootsFromRojo(JSON.parse(fs$1.readFileSync(resolvedPath, "utf-8")), config);
 		if (roots.length > 0) return roots;
 	} catch (err) {
 		if (err instanceof SyntaxError) throw new Error(`Malformed Rojo project JSON: ${err.message}`, { cause: err });
@@ -1278,7 +1576,118 @@ function resolveLuauRootsWithRojo(config, rojoProjectPath) {
 	if (outDirectory !== void 0) return [outDirectory];
 	throw new Error("Could not determine luauRoots. Set luauRoots in config or ensure tsconfig has outDir.");
 }
-
+function validateRelativeRoots(luauRoots) {
+	for (const root of luauRoots) if (path$1.isAbsolute(root)) throw new Error("luauRoots must be relative paths, got absolute path. Set a relative outDir in tsconfig or relative luauRoots in config.");
+}
+function computeSkipFiles(luauRoot, previousManifest) {
+	const skipFiles = /* @__PURE__ */ new Set();
+	const posixRoot = luauRoot.replaceAll("\\", "/");
+	for (const [fileKey, record] of Object.entries(previousManifest.files)) {
+		if (!fileKey.startsWith(`${posixRoot}/`)) continue;
+		const relativePath = fileKey.slice(posixRoot.length + 1);
+		const sourcePath = path$1.resolve(record.originalLuauPath);
+		if (!fs$1.existsSync(sourcePath)) continue;
+		if (hashBuffer(fs$1.readFileSync(sourcePath)) === record.sourceHash) skipFiles.add(relativePath);
+	}
+	return skipFiles;
+}
+function countPreviousFilesForRoot(luauRoot, previousManifest) {
+	const posixRoot = luauRoot.replaceAll("\\", "/");
+	let count = 0;
+	for (const fileKey of Object.keys(previousManifest.files)) if (fileKey.startsWith(`${posixRoot}/`)) count++;
+	return count;
+}
+function carryForwardRecords(luauRoot, previousManifest, allFiles, skipFiles) {
+	const posixRoot = luauRoot.replaceAll("\\", "/");
+	for (const relativePath of skipFiles) {
+		const fileKey = `${posixRoot}/${relativePath}`;
+		Object.assign(allFiles, { [fileKey]: previousManifest.files[fileKey] });
+	}
+}
+function instrumentRootWithCache(luauRoot, useIncremental, previousManifest) {
+	const shadowDirectory = path$1.join(COVERAGE_DIR, luauRoot).replaceAll("\\", "/");
+	let changed = false;
+	if (!useIncremental) {
+		fs$1.mkdirSync(shadowDirectory, { recursive: true });
+		fs$1.cpSync(luauRoot, shadowDirectory, { recursive: true });
+	}
+	let skipFiles;
+	if (useIncremental && previousManifest !== void 0) {
+		skipFiles = computeSkipFiles(luauRoot, previousManifest);
+		const previousCount = countPreviousFilesForRoot(luauRoot, previousManifest);
+		if (skipFiles.size !== previousCount) changed = true;
+	}
+	const files = instrumentRoot({
+		luauRoot,
+		shadowDir: shadowDirectory,
+		skipFiles
+	});
+	if (Object.keys(files).length > 0) changed = true;
+	const allFiles = { ...files };
+	if (useIncremental && previousManifest !== void 0 && skipFiles !== void 0) carryForwardRecords(luauRoot, previousManifest, allFiles, skipFiles);
+	const relocatedShadowDirectory = path$1.relative(COVERAGE_DIR, shadowDirectory).replaceAll("\\", "/");
+	return {
+		changed,
+		files: allFiles,
+		rootEntry: {
+			luauRoot,
+			relocatedShadowDirectory,
+			shadowDir: shadowDirectory
+		}
+	};
+}
+function writeManifest(manifestPath, allFiles, luauRoots, placeFile) {
+	const manifest = {
+		files: allFiles,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		instrumenterVersion: 2,
+		luauRoots,
+		placeFilePath: placeFile,
+		shadowDir: COVERAGE_DIR,
+		version: 1
+	};
+	fs$1.mkdirSync(path$1.dirname(manifestPath), { recursive: true });
+	fs$1.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, "	"));
+	return manifest;
+}
+function buildRojoProject(rojoProjectPath, roots, placeFile) {
+	const rojoProjectRaw = rojoProjectSchema(JSON.parse(fs$1.readFileSync(rojoProjectPath, "utf-8")));
+	if (rojoProjectRaw instanceof type.errors) throw new Error(`Malformed Rojo project JSON: ${rojoProjectRaw.toString()}`);
+	const rewritten = rewriteRojoProject(rojoProjectRaw, {
+		projectRelocation: path$1.relative(COVERAGE_DIR, path$1.dirname(rojoProjectPath)).replaceAll("\\", "/"),
+		roots
+	});
+	const rewrittenProjectPath = path$1.join(COVERAGE_DIR, path$1.basename(rojoProjectPath));
+	fs$1.writeFileSync(rewrittenProjectPath, JSON.stringify(rewritten, void 0, "	"));
+	buildWithRojo(rewrittenProjectPath, placeFile);
+}
+function loadPreviousManifest(manifestPath) {
+	if (!fs$1.existsSync(manifestPath)) return;
+	try {
+		const result = previousManifestSchema(JSON.parse(fs$1.readFileSync(manifestPath, "utf-8")));
+		if (result instanceof type.errors) return;
+		return result;
+	} catch {
+		return;
+	}
+}
+function canUseIncremental(previousManifest, config) {
+	if (!config.cache) return false;
+	if (previousManifest === void 0) return false;
+	if (previousManifest.instrumenterVersion !== 2) return false;
+	return true;
+}
+function detectDeletedFiles(previousManifest, currentFiles) {
+	const deleted = [];
+	for (const [fileKey, record] of Object.entries(previousManifest.files)) if (!(fileKey in currentFiles)) deleted.push(record);
+	return deleted;
+}
+function cleanupDeletedFiles(records) {
+	for (const record of records) try {
+		if (fs$1.existsSync(record.instrumentedLuauPath)) fs$1.unlinkSync(record.instrumentedLuauPath);
+		if (fs$1.existsSync(record.coverageMapPath)) fs$1.unlinkSync(record.coverageMapPath);
+	} catch {}
+}
 //#endregion
 //#region src/coverage/reporter.ts
 const VALID_REPORTERS = new Set([
@@ -1382,7 +1791,6 @@ function buildCoverageMap(mapped) {
 function isValidReporter(name) {
 	return VALID_REPORTERS.has(name);
 }
-
 //#endregion
 //#region src/utils/glob.ts
 function globSync(pattern, options = {}) {
@@ -1396,7 +1804,7 @@ function matchesGlobPattern(filePath, pattern) {
 function walkDirectory(directoryPath, baseDirectory) {
 	const results = [];
 	try {
-		const entries = fs.readdirSync(directoryPath, { withFileTypes: true });
+		const entries = fs$1.readdirSync(directoryPath, { withFileTypes: true });
 		for (const entry of entries) {
 			const fullPath = path$1.join(directoryPath, entry.name);
 			const relativePath = path$1.relative(baseDirectory, fullPath).replace(/\\/g, "/");
@@ -1407,45 +1815,43 @@ function walkDirectory(directoryPath, baseDirectory) {
 	} catch {}
 	return results;
 }
-
 //#endregion
 //#region src/cli.ts
+const VERSION = version;
+const DEFAULT_ROJO_PROJECT = "default.project.json";
 const TYPE_TEST_PATTERN = /\.(test-d|spec-d)\.ts$/;
 const HELP_TEXT = `
 Usage: jest-roblox [options] [files...]
 
 Options:
-  --backend <type>          Backend: "auto", "open-cloud", or "studio" (default: auto)
-  --port <number>           WebSocket port for studio backend (default: 3001)
-  --config <path>           Path to config file
-  --testPathPattern <regex> Filter test files by path pattern
-  -t, --testNamePattern <regex>  Filter tests by name pattern
-  --json                    Output results as JSON
-  --compact                 Token-efficient output for AI consumption
-  --compactMaxFailures <n>  Max failures in compact mode (default: 10)
-  --outputFile <path>       Write results to file
-  --gameOutput <path>       Write game output (print/warn/error) to file
-  --sourceMap               Map Luau stack traces to TypeScript source
-  --rojoProject <path>      Path to rojo project file (auto-detected if not set)
-  --verbose                 Show individual test results
-  --silent                  Suppress output
-  --no-color                Disable colored output
-  -u, --updateSnapshot      Update snapshot files
-  --coverage                Enable coverage collection
-  --coverageDirectory <path>  Directory for coverage output (default: coverage)
-  --coverageReporters <r...>  Coverage reporters (default: text, lcov)
-  --formatters <name...>    Output formatters (default: default; auto: github-actions)
-  --no-cache                Force re-upload place file (skip cache)
-  --pollInterval <ms>       Open Cloud poll interval in ms (default: 500)
-  --projects <path...>      DataModel paths to search for tests
-  --setupFiles <path...>    DataModel paths to setup scripts
-  --setupFilesAfterEnv <path...>  DataModel paths to post-env setup scripts
-  --no-show-luau            Hide Luau code in failure output
-  --typecheck               Enable type testing (*.test-d.ts, *.spec-d.ts)
-  --typecheckOnly           Run only type tests, skip runtime tests
-  --typecheckTsconfig <path>  tsconfig for type testing
-  --help                    Show this help message
-  --version                 Show version number
+  --backend <type>                  Backend: "auto", "open-cloud", or "studio" (default: auto)
+  --port <number>                   WebSocket port for studio backend (default: 3001)
+  --config <path>                   Path to config file
+  --testPathPattern <regex>         Filter test files by path pattern
+  -t, --testNamePattern <regex>     Filter tests by name pattern
+  --outputFile <path>               Write results to file
+  --gameOutput <path>               Write game output (print/warn/error) to file
+  --sourceMap                       Map Luau stack traces to TypeScript source
+  --rojoProject <path>              Path to rojo project file (auto-detected if not set)
+  --verbose                         Show individual test results
+  --silent                          Suppress output
+  --no-color                        Disable colored output
+  -u, --updateSnapshot              Update snapshot files
+  --coverage                        Enable coverage collection
+  --coverageDirectory <path>        Directory for coverage output (default: coverage)
+  --coverageReporters <r...>        Coverage reporters (default: text, lcov)
+  --formatters <name...>            Output formatters (default, agent, json, github-actions)
+  --no-cache                        Force re-upload place file (skip cache)
+  --pollInterval <ms>               Open Cloud poll interval in ms (default: 500)
+  --project <name...>               Filter which named projects to run
+  --setupFiles <path...>            Setup scripts (package specifiers or relative paths)
+  --setupFilesAfterEnv <path...>    Post-env setup scripts (package specifiers or relative paths)
+  --no-show-luau                    Hide Luau code in failure output
+  --typecheck                       Enable type testing (*.test-d.ts, *.spec-d.ts)
+  --typecheckOnly                   Run only type tests, skip runtime tests
+  --typecheckTsconfig <path>        tsconfig for type testing
+  --help                            Show this help message
+  --version                         Show version number
 
 Environment Variables (open-cloud backend only):
   ROBLOX_OPEN_CLOUD_API_KEY  API key for Roblox Open Cloud
@@ -1457,7 +1863,7 @@ Examples:
   jest-roblox --backend studio        Run tests via Studio plugin
   jest-roblox src/player.spec.ts      Run specific test file
   jest-roblox -t "should spawn"       Run tests matching pattern
-  jest-roblox --json --outputFile results.json
+  jest-roblox --formatters json       Output JSON to file
   jest-roblox --coverage              Run tests with coverage instrumentation
 `;
 function parseArgs(args) {
@@ -1468,8 +1874,6 @@ function parseArgs(args) {
 			"backend": { type: "string" },
 			"cache": { type: "boolean" },
 			"color": { type: "boolean" },
-			"compact": { type: "boolean" },
-			"compactMaxFailures": { type: "string" },
 			"config": { type: "string" },
 			"coverage": { type: "boolean" },
 			"coverageDirectory": { type: "string" },
@@ -1486,14 +1890,13 @@ function parseArgs(args) {
 				default: false,
 				type: "boolean"
 			},
-			"json": { type: "boolean" },
 			"no-cache": { type: "boolean" },
 			"no-color": { type: "boolean" },
 			"no-show-luau": { type: "boolean" },
 			"outputFile": { type: "string" },
 			"pollInterval": { type: "string" },
 			"port": { type: "string" },
-			"projects": {
+			"project": {
 				multiple: true,
 				type: "string"
 			},
@@ -1530,7 +1933,6 @@ function parseArgs(args) {
 		},
 		strict: true
 	});
-	const compactMaxFailures = values.compactMaxFailures !== void 0 ? Number.parseInt(values.compactMaxFailures, 10) : void 0;
 	const pollInterval = values.pollInterval !== void 0 ? Number.parseInt(values.pollInterval, 10) : void 0;
 	const port = values.port !== void 0 ? Number.parseInt(values.port, 10) : void 0;
 	const timeout = values.timeout !== void 0 ? Number.parseInt(values.timeout, 10) : void 0;
@@ -1539,8 +1941,6 @@ function parseArgs(args) {
 		cache: values["no-cache"] === true ? false : values.cache,
 		collectCoverage: values.coverage,
 		color: values["no-color"] === true ? false : values.color,
-		compact: values.compact,
-		compactMaxFailures,
 		config: values.config,
 		coverageDirectory: values.coverageDirectory,
 		coverageReporters: values.coverageReporters,
@@ -1548,11 +1948,10 @@ function parseArgs(args) {
 		formatters: values.formatters,
 		gameOutput: values.gameOutput,
 		help: values.help,
-		json: values.json,
 		outputFile: values.outputFile,
 		pollInterval,
 		port,
-		projects: values.projects,
+		project: values.project,
 		rojoProject: values.rojoProject,
 		setupFiles: values.setupFiles,
 		setupFilesAfterEnv: values.setupFilesAfterEnv,
@@ -1570,6 +1969,77 @@ function parseArgs(args) {
 		version: values.version
 	};
 }
+function filterByName(projects, names) {
+	const available = new Set(projects.map((project) => project.displayName));
+	const unknown = names.filter((name) => !available.has(name));
+	if (unknown.length > 0) throw new Error(`Unknown project name(s): ${unknown.join(", ")}. Available: ${[...available].join(", ")}`);
+	const nameSet = new Set(names);
+	return projects.filter((project) => nameSet.has(project.displayName));
+}
+function mergeProjectResults(results) {
+	assert(results.length > 0, "mergeProjectResults requires at least one result");
+	if (results.length === 1) {
+		const [first] = results;
+		return first;
+	}
+	let numberFailedTests = 0;
+	let numberPassedTests = 0;
+	let numberPendingTests = 0;
+	let numberTodoTests = 0;
+	let numberTotalTests = 0;
+	let startTime = Number.POSITIVE_INFINITY;
+	let success = true;
+	const testResults = [];
+	let executionMs = 0;
+	let testsMs = 0;
+	let totalMs = 0;
+	let uploadMs = 0;
+	let coverageMs = 0;
+	let mergedCoverage;
+	for (const result of results) {
+		numberFailedTests += result.result.numFailedTests;
+		numberPassedTests += result.result.numPassedTests;
+		numberPendingTests += result.result.numPendingTests;
+		numberTodoTests += result.result.numTodoTests ?? 0;
+		numberTotalTests += result.result.numTotalTests;
+		startTime = Math.min(startTime, result.result.startTime);
+		success &&= result.result.success;
+		testResults.push(...result.result.testResults);
+		executionMs += result.timing.executionMs;
+		testsMs += result.timing.testsMs;
+		totalMs += result.timing.totalMs;
+		uploadMs += result.timing.uploadMs ?? 0;
+		coverageMs += result.timing.coverageMs ?? 0;
+		if (result.coverageData !== void 0) mergedCoverage = {
+			...mergedCoverage,
+			...result.coverageData
+		};
+	}
+	return {
+		coverageData: mergedCoverage,
+		exitCode: success ? 0 : 1,
+		output: "",
+		result: {
+			numFailedTests: numberFailedTests,
+			numPassedTests: numberPassedTests,
+			numPendingTests: numberPendingTests,
+			numTodoTests: numberTodoTests,
+			numTotalTests: numberTotalTests,
+			startTime,
+			success,
+			testResults
+		},
+		timing: {
+			coverageMs: coverageMs > 0 ? coverageMs : void 0,
+			executionMs,
+			startTime: Math.min(...results.map((result) => result.timing.startTime)),
+			testsMs,
+			totalMs,
+			uploadCached: results.every((result) => result.timing.uploadCached === true),
+			uploadMs
+		}
+	};
+}
 async function run(args) {
 	try {
 		return await runInner(args);
@@ -1582,24 +2052,35 @@ async function main() {
 	const exitCode = await run(process.argv.slice(2));
 	process.exit(exitCode);
 }
+function formatGameOutputLines(raw) {
+	if (raw === void 0) return;
+	const entries = parseGameOutput(raw);
+	if (entries.length === 0) return;
+	return entries.map((entry) => entry.message.replace(/^/gm, "  ")).join("\n");
+}
 function printError(err) {
-	if (err instanceof LuauScriptError) {
+	if (err instanceof ConfigError) {
+		const body = [color.red(err.message)];
+		if (err.hint !== void 0) body.push(`\n  ${color.dim("Hint:")} ${err.hint}`);
+		process.stderr.write(formatBanner({
+			body,
+			level: "error",
+			title: "Config Error"
+		}));
+	} else if (err instanceof LuauScriptError) {
+		const body = [color.red(err.message)];
 		const hint = getLuauErrorHint(err.message);
-		console.error(`\n  Luau script error: ${err.message}`);
-		if (hint !== void 0) console.error(`  Hint: ${hint}`);
-		console.error();
+		if (hint !== void 0) body.push(`\n  ${color.dim("Hint:")} ${hint}`);
+		const gameLines = formatGameOutputLines(err.gameOutput);
+		if (gameLines !== void 0) body.push(`\n  ${color.dim("Game output:")}\n${gameLines}`);
+		process.stderr.write(formatBanner({
+			body,
+			level: "error",
+			title: "Luau Error"
+		}));
 	} else if (err instanceof Error) console.error(`Error: ${err.message}`);
 	else console.error("An unknown error occurred");
 }
-async function executeRuntimeTests(config, testFiles, totalFiles) {
-	if (!config.silent && (!config.compact || config.verbose) && !config.json && testFiles.length !== totalFiles) process.stderr.write(`Running ${String(testFiles.length)} of ${String(totalFiles)} test files\n`);
-	return execute({
-		backend: await resolveBackend(config),
-		config,
-		testFiles,
-		version
-	});
-}
 function writeGameOutputIfConfigured(config, gameOutput, options) {
 	if (config.gameOutput === void 0) return;
 	const entries = parseGameOutput(gameOutput);
@@ -1637,13 +2118,8 @@ function processCoverage(config, coverageData) {
 	}
 	return true;
 }
-function findFormatterOptions(formatters, name) {
-	for (const entry of formatters) {
-		if (entry === name) return {};
-		if (Array.isArray(entry) && entry[0] === name) return entry[1];
-	}
-}
 function runGitHubActionsFormatter(config, result, sourceMapper) {
+	assert(config.formatters !== void 0, "formatters is set by resolveFormatters");
 	const userOptions = findFormatterOptions(config.formatters, "github-actions");
 	if (userOptions === void 0) return;
 	const typedOptions = userOptions;
@@ -1657,15 +2133,80 @@ function runGitHubActionsFormatter(config, result, sourceMapper) {
 		const outputPath = jobSummary?.outputPath ?? process.env["GITHUB_STEP_SUMMARY"];
 		if (outputPath !== void 0) {
 			const summary = formatJobSummary(result, options);
-			fs.appendFileSync(outputPath, summary);
+			fs$1.appendFileSync(outputPath, summary);
+		}
+	}
+}
+function hasFormatter(config, name) {
+	return config.formatters?.some((entry) => Array.isArray(entry) ? entry[0] === name : entry === name) === true;
+}
+function getCompactMaxFailures(config) {
+	assert(config.formatters !== void 0, "formatters is set by resolveFormatters");
+	const options = findFormatterOptions(config.formatters, "agent");
+	if (options !== void 0 && typeof options["maxFailures"] === "number") return options["maxFailures"];
+	return 10;
+}
+function usesAgentFormatter(config) {
+	return hasFormatter(config, "agent") && !config.verbose;
+}
+function usesDefaultFormatter(config) {
+	return !hasFormatter(config, "json") && !usesAgentFormatter(config);
+}
+function printOutput(output) {
+	if (output !== "") console.log(output);
+}
+function formatRuntimeOutput(config, runtimeResult, timing) {
+	return formatExecuteOutput({
+		config,
+		result: runtimeResult.result,
+		sourceMapper: runtimeResult.sourceMapper,
+		timing,
+		version: VERSION
+	});
+}
+function printFormattedOutput(options) {
+	const { config, mergedResult, runtimeResult, timing, typecheckResult } = options;
+	if (typecheckResult !== void 0 && runtimeResult !== void 0 && timing !== void 0) {
+		if (usesDefaultFormatter(config)) printOutput(formatResult(mergedResult, timing, {
+			collectCoverage: config.collectCoverage,
+			color: config.color,
+			rootDir: config.rootDir,
+			showLuau: config.showLuau,
+			sourceMapper: runtimeResult.sourceMapper,
+			typeErrors: typecheckResult.numFailedTests,
+			verbose: config.verbose,
+			version: VERSION
+		}));
+		else {
+			printOutput(formatRuntimeOutput(config, runtimeResult, timing));
+			process.stderr.write(formatTypecheckSummary(typecheckResult));
 		}
+		return;
+	}
+	if (typecheckResult !== void 0) {
+		process.stdout.write(formatTypecheckSummary(typecheckResult));
+		return;
 	}
+	assert(runtimeResult !== void 0 && timing !== void 0, "runtime result required");
+	printOutput(formatRuntimeOutput(config, runtimeResult, timing));
 }
-async function outputResults(config, typecheckResult, runtimeResult) {
+function addCoverageTiming(timing, coverageMs) {
+	return {
+		...timing,
+		coverageMs,
+		totalMs: timing.totalMs + coverageMs
+	};
+}
+async function outputResults(config, typecheckResult, runtimeResult, preCoverageMs) {
 	const mergedResult = mergeResults(typecheckResult, runtimeResult?.result);
-	if (runtimeResult !== void 0 && runtimeResult.output !== "") console.log(runtimeResult.output);
+	if (!config.silent) printFormattedOutput({
+		config,
+		mergedResult,
+		runtimeResult,
+		timing: runtimeResult !== void 0 ? addCoverageTiming(runtimeResult.timing, preCoverageMs) : void 0,
+		typecheckResult
+	});
 	const coveragePassed = processCoverage(config, runtimeResult?.coverageData);
-	if (typecheckResult !== void 0 && !config.silent) printTypecheckSummary(typecheckResult);
 	if (config.outputFile !== void 0) await writeJsonFile(mergedResult, config.outputFile);
 	if (runtimeResult !== void 0) writeGameOutputIfConfigured(config, runtimeResult.gameOutput, { hintsShown: !mergedResult.success });
 	runGitHubActionsFormatter(config, mergedResult, runtimeResult?.sourceMapper);
@@ -1673,18 +2214,205 @@ async function outputResults(config, typecheckResult, runtimeResult) {
 	if (!config.silent && config.collectCoverage) printFinalStatus(passed);
 	return passed ? 0 : 1;
 }
-async function runInner(args) {
-	const cli = parseArgs(args);
-	if (cli.help === true) {
-		console.log(HELP_TEXT);
-		return 0;
+function toProjectEntries(projectResults) {
+	return projectResults.map((pr) => {
+		return {
+			displayColor: pr.displayColor,
+			displayName: pr.displayName,
+			result: pr.result.result
+		};
+	});
+}
+function printMultiProjectOutput(options) {
+	const { config, merged, preCoverageMs, projectResults, typecheckResult } = options;
+	const timing = addCoverageTiming(merged.timing, preCoverageMs);
+	if (usesAgentFormatter(config)) {
+		printOutput(formatCompactMultiProject(toProjectEntries(projectResults), {
+			gameOutput: config.gameOutput,
+			maxFailures: getCompactMaxFailures(config),
+			outputFile: config.outputFile,
+			rootDir: config.rootDir,
+			sourceMapper: merged.sourceMapper,
+			typeErrorCount: typecheckResult?.numFailedTests
+		}));
+		return;
 	}
-	if (cli.version === true) {
-		console.log(version);
-		return 0;
+	if (hasFormatter(config, "json")) {
+		printOutput(formatRuntimeOutput(config, merged, timing));
+		return;
+	}
+	printOutput(formatMultiProjectResult(toProjectEntries(projectResults), timing, {
+		collectCoverage: config.collectCoverage,
+		color: config.color,
+		rootDir: config.rootDir,
+		showLuau: config.showLuau,
+		sourceMapper: merged.sourceMapper,
+		typeErrors: typecheckResult?.numFailedTests,
+		verbose: config.verbose,
+		version: VERSION
+	}));
+}
+async function outputMultiProjectResults(config, projectResults, typecheckResult, preCoverageMs) {
+	const merged = mergeProjectResults(projectResults.map((pr) => pr.result));
+	const mergedResult = mergeResults(typecheckResult, merged.result);
+	if (!config.silent) {
+		printMultiProjectOutput({
+			config,
+			merged,
+			preCoverageMs,
+			projectResults,
+			typecheckResult
+		});
+		if (typecheckResult !== void 0 && !usesDefaultFormatter(config)) process.stderr.write(formatTypecheckSummary(typecheckResult));
+	}
+	const coveragePassed = processCoverage(config, merged.coverageData);
+	if (config.outputFile !== void 0) await writeJsonFile(mergedResult, config.outputFile);
+	runGitHubActionsFormatter(config, mergedResult, merged.sourceMapper);
+	const passed = mergedResult.success && coveragePassed;
+	if (!config.silent && config.collectCoverage) printFinalStatus(passed);
+	return passed ? 0 : 1;
+}
+function loadRojoTree(config) {
+	const rojoPath = path$1.resolve(config.rootDir, config.rojoProject ?? DEFAULT_ROJO_PROJECT);
+	const content = fs$1.readFileSync(rojoPath, "utf8");
+	const validated = rojoProjectSchema(JSON.parse(content));
+	if (validated instanceof type.errors) throw new Error(`Invalid Rojo project: ${validated.summary}`);
+	return validated.tree;
+}
+const STUB_SKIP_KEYS = new Set([
+	"outDir",
+	"projects",
+	"root"
+]);
+function buildStubConfig(config) {
+	const result = {};
+	for (const [key, value] of Object.entries(config)) if (!ROOT_ONLY_KEYS.has(key) && !STUB_SKIP_KEYS.has(key) && value !== void 0) result[key] = value;
+	return result;
+}
+function generateProjectStubs(projects, rootDirectory) {
+	const entries = [];
+	for (const project of projects) {
+		if (project.outDir === void 0) continue;
+		const outputPath = path$1.resolve(rootDirectory, project.outDir, "jest.config.lua");
+		const stubConfig = {
+			...buildStubConfig(project.config),
+			displayName: project.displayName,
+			include: [],
+			testMatch: project.testMatch
+		};
+		entries.push({
+			config: stubConfig,
+			outputPath
+		});
 	}
-	let config = mergeCliWithConfig(cli, await loadConfig(cli.config));
-	const discovery = discoverTestFiles(config, cli.files);
+	generateProjectConfigs(entries);
+}
+function prepareMultiProjectCoverage(rootConfig, projects) {
+	if (!rootConfig.collectCoverage) return {
+		effectiveConfig: rootConfig,
+		preCoverageMs: 0
+	};
+	const start = Date.now();
+	const { placeFile } = prepareCoverage(rootConfig, (shadowDirectory) => {
+		return syncStubsToShadowDirectory(projects, rootConfig.rootDir, shadowDirectory);
+	});
+	return {
+		effectiveConfig: {
+			...rootConfig,
+			placeFile
+		},
+		preCoverageMs: Date.now() - start
+	};
+}
+function classifyTestFiles(files, config) {
+	const typeTestFiles = config.typecheck ? files.filter((file) => TYPE_TEST_PATTERN.test(file)) : [];
+	return {
+		runtimeFiles: config.typecheckOnly ? [] : files.filter((file) => !TYPE_TEST_PATTERN.test(file)),
+		typeTestFiles
+	};
+}
+function applySetupResolver(config, resolve) {
+	if (config.setupFiles !== void 0) config.setupFiles = config.setupFiles.map(resolve);
+	if (config.setupFilesAfterEnv !== void 0) config.setupFilesAfterEnv = config.setupFilesAfterEnv.map(resolve);
+}
+async function runMultiProject(cli, rootConfig, projectEntries) {
+	const allProjects = await resolveAllProjects(projectEntries, rootConfig, loadRojoTree(rootConfig), rootConfig.rootDir);
+	const rojoConfigPath = path$1.resolve(rootConfig.rootDir, rootConfig.rojoProject ?? DEFAULT_ROJO_PROJECT);
+	const resolveSetup = createSetupResolver({
+		configDirectory: rootConfig.rootDir,
+		rojoConfigPath
+	});
+	for (const project of allProjects) applySetupResolver(project.config, resolveSetup);
+	const projects = cli.project !== void 0 ? filterByName(allProjects, cli.project) : allProjects;
+	generateProjectStubs(projects, rootConfig.rootDir);
+	if (!rootConfig.collectCoverage) buildWithRojo(path$1.resolve(rootConfig.rootDir, rootConfig.rojoProject ?? DEFAULT_ROJO_PROJECT), path$1.resolve(rootConfig.rootDir, rootConfig.placeFile));
+	const { effectiveConfig, preCoverageMs } = prepareMultiProjectCoverage(rootConfig, projects);
+	const backend = await resolveBackend(effectiveConfig);
+	const projectResults = [];
+	const allTypeTestFiles = [];
+	for (const project of projects) {
+		const discoveryConfig = {
+			...project.config,
+			placeFile: effectiveConfig.placeFile,
+			projects: project.projects,
+			testMatch: project.include
+		};
+		const { runtimeFiles, typeTestFiles } = classifyTestFiles(discoverTestFiles(discoveryConfig, cli.files).files, rootConfig);
+		const projConfig = {
+			...discoveryConfig,
+			testMatch: project.testMatch
+		};
+		allTypeTestFiles.push(...typeTestFiles);
+		if (runtimeFiles.length === 0 && typeTestFiles.length === 0) continue;
+		if (runtimeFiles.length > 0) {
+			const result = await execute({
+				backend,
+				config: projConfig,
+				deferFormatting: true,
+				testFiles: runtimeFiles,
+				version: VERSION
+			});
+			projectResults.push({
+				displayColor: project.displayColor,
+				displayName: project.displayName,
+				result
+			});
+		}
+	}
+	const uniqueTypeTestFiles = [...new Set(allTypeTestFiles)];
+	const typecheckResult = uniqueTypeTestFiles.length > 0 ? runTypecheck({
+		files: uniqueTypeTestFiles,
+		rootDir: rootConfig.rootDir,
+		tsconfig: rootConfig.typecheckTsconfig
+	}) : void 0;
+	if (projectResults.length === 0 && typecheckResult === void 0) {
+		console.error("No test files found in any project");
+		return 2;
+	}
+	if (projectResults.length === 0) return outputResults(rootConfig, typecheckResult, void 0, preCoverageMs);
+	return outputMultiProjectResults(rootConfig, projectResults, typecheckResult, preCoverageMs);
+}
+async function executeRuntimeTests(config, testFiles, totalFiles) {
+	if (!config.silent && !usesAgentFormatter(config) && !hasFormatter(config, "json") && testFiles.length !== totalFiles) process.stderr.write(`Running ${String(testFiles.length)} of ${String(totalFiles)} test files\n`);
+	return execute({
+		backend: await resolveBackend(config),
+		config,
+		deferFormatting: true,
+		testFiles,
+		version: VERSION
+	});
+}
+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);
+	applySetupResolver(config, createSetupResolver({
+		configDirectory: config.rootDir,
+		rojoConfigPath
+	}));
+}
+async function runSingleProject(config, cliFiles) {
+	resolveSetupFilePaths(config);
+	const discovery = discoverTestFiles(config, cliFiles);
 	if (discovery.files.length === 0) {
 		console.error("No test files found");
 		return 2;
@@ -1695,20 +2423,40 @@ async function runInner(args) {
 		console.error("No test files found for the selected mode");
 		return 2;
 	}
+	let preCoverageMs = 0;
+	let effectiveConfig = config;
 	if (config.collectCoverage && !config.typecheckOnly && runtimeTestFiles.length > 0) {
+		const preCoverageStart = Date.now();
 		const { placeFile } = prepareCoverage(config);
-		config = {
+		preCoverageMs = Date.now() - preCoverageStart;
+		effectiveConfig = {
 			...config,
 			placeFile
 		};
 	}
 	const typecheckResult = typeTestFiles.length > 0 ? runTypecheck({
 		files: typeTestFiles,
-		rootDir: config.rootDir,
-		tsconfig: config.typecheckTsconfig
+		rootDir: effectiveConfig.rootDir,
+		tsconfig: effectiveConfig.typecheckTsconfig
 	}) : void 0;
-	const runtimeResult = runtimeTestFiles.length > 0 ? await executeRuntimeTests(config, runtimeTestFiles, discovery.totalFiles) : void 0;
-	return outputResults(config, typecheckResult, runtimeResult);
+	const runtimeResult = runtimeTestFiles.length > 0 ? await executeRuntimeTests(effectiveConfig, runtimeTestFiles, discovery.totalFiles) : void 0;
+	return outputResults(effectiveConfig, typecheckResult, runtimeResult, preCoverageMs);
+}
+async function runInner(args) {
+	const cli = parseArgs(args);
+	if (cli.help === true) {
+		console.log(HELP_TEXT);
+		return 0;
+	}
+	if (cli.version === true) {
+		console.log(VERSION);
+		return 0;
+	}
+	if (process.env["JEST_ROBLOX_SEA"] === "true" && cli.typecheck === true) throw new ConfigError("--typecheck is not available in the standalone binary. Install via npm instead.");
+	const config = mergeCliWithConfig(cli, await loadConfig$1(cli.config));
+	const rawProjects = config.projects;
+	if (rawProjects !== void 0 && rawProjects.length > 0) return runMultiProject(cli, config, rawProjects);
+	return runSingleProject(config, cli.files);
 }
 const LUAU_ERROR_HINTS = [
 	[/Failed to find Jest instance in ReplicatedStorage/, "Set \"jestPath\" in your config to specify the Jest module location, e.g. \"ReplicatedStorage/rbxts_include/node_modules/@rbxts/jest/src\""],
@@ -1757,10 +2505,19 @@ function validateBackend(value) {
 function getLuauErrorHint(message) {
 	for (const [pattern, hint] of LUAU_ERROR_HINTS) if (pattern.test(message)) return hint;
 }
+function normalizeFormatterName(name) {
+	return name === "compact" ? "agent" : name;
+}
+function normalizeFormatterEntry(entry) {
+	if (Array.isArray(entry)) return [normalizeFormatterName(entry[0]), entry[1]];
+	return normalizeFormatterName(entry);
+}
 function resolveFormatters(cli, config) {
 	const explicit = cli.formatters ?? config.formatters;
-	if (explicit !== void 0) return explicit;
-	return process.env["GITHUB_ACTIONS"] === "true" ? ["default", "github-actions"] : ["default"];
+	if (explicit !== void 0) return explicit.map(normalizeFormatterEntry);
+	const defaults = isAgent ? ["agent"] : ["default"];
+	if (process.env["GITHUB_ACTIONS"] === "true") defaults.push("github-actions");
+	return defaults;
 }
 function mergeCliWithConfig(cli, config) {
 	return {
@@ -1769,17 +2526,13 @@ function mergeCliWithConfig(cli, config) {
 		cache: cli.cache ?? config.cache,
 		collectCoverage: cli.collectCoverage ?? config.collectCoverage,
 		color: cli.color ?? config.color,
-		compact: cli.compact ?? config.compact,
-		compactMaxFailures: cli.compactMaxFailures ?? config.compactMaxFailures,
 		coverageDirectory: cli.coverageDirectory ?? config.coverageDirectory,
 		coverageReporters: cli.coverageReporters ?? config.coverageReporters,
 		formatters: resolveFormatters(cli, config),
 		gameOutput: cli.gameOutput ?? config.gameOutput,
-		json: cli.json ?? config.json,
 		outputFile: cli.outputFile ?? config.outputFile,
 		pollInterval: cli.pollInterval ?? config.pollInterval,
 		port: cli.port ?? config.port,
-		projects: cli.projects ?? config.projects,
 		rojoProject: cli.rojoProject ?? config.rojoProject,
 		setupFiles: cli.setupFiles ?? config.setupFiles,
 		setupFilesAfterEnv: cli.setupFilesAfterEnv ?? config.setupFilesAfterEnv,
@@ -1811,21 +2564,5 @@ function mergeResults(typecheck, runtime) {
 	assert(result !== void 0, "mergeResults requires at least one result");
 	return result;
 }
-function printTypecheckFailures(result) {
-	for (const file of result.testResults) for (const test of file.testResults) {
-		if (test.status !== "failed") continue;
-		process.stderr.write(`  FAIL ${test.fullName}\n`);
-		for (const message of test.failureMessages) process.stderr.write(`    ${message}\n`);
-	}
-}
-function printTypecheckSummary(result) {
-	const passed = result.numPassedTests;
-	const failed = result.numFailedTests;
-	const total = result.numTotalTests;
-	if (failed > 0) printTypecheckFailures(result);
-	const failedPart = failed > 0 ? `${String(failed)} failed, ` : "";
-	process.stderr.write(`\nType Tests: ${failedPart}${String(passed)} passed, ${String(total)} total\n`);
-}
-
 //#endregion
-export { main, parseArgs, run };
+export { filterByName, main, mergeProjectResults, parseArgs, run };