@isentinel/jest-roblox 0.2.7 → 0.3.1

package/dist/cli.mjs

@@ -1,2207 +1,33 @@
-import { A as collectMounts, B as createOpenCloudBackend, D as formatTypecheckSummary, F as loadConfig$1, G as VALID_BACKENDS, J as isValidBackend, M as findInTree, N as pruneAncestors, O as formatBanner, P as resolveNestedProjects, R as createStudioBackend, S as formatAgentMultiProject, T as formatResult, W as ROOT_ONLY_KEYS, X as LuauScriptError, Y as hashBuffer, _ as resolveTsconfigDirectories, a as formatAnnotations, c as visitBlock, d as buildProjectJob, f as execute, g as processProjectResult, h as loadCoverageManifest, i as runTypecheck, j as collectPaths, k as combineSourceMappers, m as formatExecuteOutput, n as parseGameOutput, o as formatJobSummary, p as executeBackend, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, v as rojoProjectSchema, w as formatMultiProjectResult, x as writeJsonFile, y as findFormatterOptions } from "./game-output-CCPIQMWm.mjs";
-import { createRequire } from "node:module";
-import { type } from "arktype";
-import assert from "node:assert";
-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 { A as mergeCliWithConfig, D as LuauScriptError, E as formatBanner, H as ConfigError, R as VALID_BACKENDS, U as version, V as isValidBackend, f as outputMultiResult, j as loadConfig, p as outputSingleResult, t as runJestRoblox, y as parseGameOutput } from "./run-Cl5gYSQr.mjs";
+import { OpenCloudError } from "@bedrock-rbx/ocale";
 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 * as os from "node:os";
-import { Buffer } from "node:buffer";
-import { loadConfig } from "c12";
-import { getTsconfig } from "get-tsconfig";
-import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
-import * as cp from "node:child_process";
-import { RojoResolver } from "@roblox-ts/rojo-resolver";
-import picomatch from "picomatch";
-import istanbulCoverage from "istanbul-lib-coverage";
-import istanbulReport from "istanbul-lib-report";
-import istanbulReports from "istanbul-reports";
-//#region package.json
-var version = "0.2.7";
-//#endregion
-//#region src/backends/auto.ts
-var StudioWithFallback = class {
-	studio;
-	kind = "studio";
-	constructor(studio) {
-		this.studio = studio;
-	}
-	async close() {
-		await this.studio.close?.();
-	}
-	async runTests(options) {
-		try {
-			return await this.studio.runTests(options);
-		} catch (err) {
-			if (isStudioBusyError(err)) {
-				process.stderr.write("Studio busy, falling back to Open Cloud\n");
-				return createOpenCloudBackend().runTests(options);
-			}
-			throw err;
-		}
-	}
-};
-function isStudioBusyError(error) {
-	if (error instanceof LuauScriptError) return /previous call to start play session/i.test(error.message);
-	return typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE";
-}
-async function probeStudioPlugin(port, timeoutMs, createServer = (wsPort) => {
-	return new WebSocketServer({ port: wsPort });
-}) {
-	return new Promise((resolve) => {
-		const wss = createServer(port);
-		const timer = setTimeout(() => {
-			wss.close();
-			resolve({ detected: false });
-		}, timeoutMs);
-		wss.on("connection", (ws) => {
-			clearTimeout(timer);
-			resolve({
-				detected: true,
-				server: wss,
-				socket: ws
-			});
-		});
-		wss.on("error", () => {
-			clearTimeout(timer);
-			wss.close();
-			resolve({ detected: false });
-		});
-	});
-}
-async function resolveBackend(config, probe = probeStudioPlugin) {
-	if (config.backend === "studio") return createStudioBackend({
-		port: config.port,
-		timeout: config.timeout
-	});
-	if (config.backend === "open-cloud") return createOpenCloudBackend();
-	const probeResult = await probe(config.port, 500);
-	if (probeResult.detected) {
-		process.stderr.write("Backend: studio (plugin detected)\n");
-		const studio = createStudioBackend({
-			port: config.port,
-			preConnected: {
-				server: probeResult.server,
-				socket: probeResult.socket
-			},
-			timeout: config.timeout
-		});
-		if (hasOpenCloudCredentials()) return new StudioWithFallback(studio);
-		return studio;
-	}
-	if (hasOpenCloudCredentials()) {
-		process.stderr.write("Backend: open-cloud (no plugin, using Open Cloud)\n");
-		return createOpenCloudBackend();
-	}
-	throw new Error("No backend available: Studio plugin not detected and Open Cloud env vars (ROBLOX_OPEN_CLOUD_API_KEY, ROBLOX_UNIVERSE_ID, ROBLOX_PLACE_ID) are missing");
-}
-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/luau/eval-literals.ts
-/**
-* Evaluate the first return expression in a Lute-stripped AST root block,
-* supporting only literal values (string, boolean, number, nil, table, cast).
-*
-* Accepts `unknown` and narrows safely — no type casts on JSON.parse needed.
-*/
-function evalLuauReturnLiterals(root) {
-	if (!isObject(root) || !Array.isArray(root["statements"])) throw new Error("Config file has no return statement");
-	const returnStat = root["statements"].find((stat) => isObject(stat) && stat["tag"] === "return");
-	if (!isObject(returnStat) || !Array.isArray(returnStat["expressions"])) throw new Error("Config file has no return statement");
-	const first = returnStat["expressions"][0];
-	if (!isObject(first) || !("node" in first)) throw new Error("Return statement has no expressions");
-	return evalExpr(first["node"]);
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-function evalExpr(node) {
-	if (!isObject(node)) return;
-	let current = node;
-	while (current["tag"] === "cast" && isObject(current["operand"])) current = current["operand"];
-	const { tag } = current;
-	if (tag === "boolean" || tag === "number") return current["value"];
-	if (tag === "string") return current["text"];
-	if (tag === "table" && Array.isArray(current["entries"])) return evalTable(current["entries"]);
-}
-function evalTable(entries) {
-	if (entries.length === 0) return {};
-	const first = entries[0];
-	if (isObject(first) && first["kind"] === "list") return entries.map((entry) => isObject(entry) ? evalExpr(entry["value"]) : void 0);
-	const result = {};
-	for (const entry of entries) {
-		if (!isObject(entry) || entry["kind"] !== "record") continue;
-		const { key, value } = entry;
-		if (isObject(key) && typeof key["text"] === "string") result[key["text"]] = evalExpr(value);
-	}
-	return result;
-}
-//#endregion
-//#region src/luau/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]\nif not luauRoot then\n	error(\"Usage: lute run parse-ast.luau -- <file.luau | luau-root> [output-dir]\")\nend\n\nluauRoot = string.gsub(luauRoot, \"\\\\\", \"/\")\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	boolean = { \"value\" },\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	number = { \"value\" },\n	[\"repeat\"] = { \"body\", \"condition\" },\n	[\"return\"] = { \"expressions\" },\n	string = { \"text\" },\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-- Single-file mode: parse one file, print stripped AST to stdout\nif string.sub(luauRoot, -5) == \".luau\" or string.sub(luauRoot, -4) == \".lua\" then\n	local source = fs.readFileToString(luauRoot)\n	local parseResult = syntax.parse(source)\n	print(json.serialize(strip(parseResult.root)))\n	return\nend\n\nlocal outputDir = userArgs[2]\nif not outputDir then\n	error(\"Usage: lute run parse-ast.luau -- <luau-root> <output-dir>\")\nend\n\noutputDir = string.gsub(outputDir, \"\\\\\", \"/\")\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\n-- Optional 3rd arg: path to skip list JSON file.\n-- Skipped files are still included in the file list but not parsed.\nlocal skipListPath = userArgs[3]\nlocal skipSet: { [string]: boolean } = {}\nif skipListPath then\n	local skipJson = fs.readFileToString(skipListPath)\n	local skipList = json.deserialize(skipJson) :: { string }\n	for _, entry in skipList do\n		skipSet[entry] = true\n	end\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	if skipSet[relativePath] then\n		continue\n	end\n\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/config/luau-config-loader.ts
-let cachedTemporaryDirectory$1;
-/**
-* Parse a .luau config file via Lute and evaluate its return expression.
-*/
-function loadLuauConfig(filePath) {
-	const temporaryDirectory = getTemporaryDirectory$1();
-	const scriptPath = path$1.join(temporaryDirectory, "parse-ast.luau");
-	fs$1.writeFileSync(scriptPath, parse_ast_default);
-	let stdout;
-	try {
-		stdout = cp.execFileSync("lute", [
-			"run",
-			scriptPath,
-			"--",
-			path$1.resolve(filePath)
-		], {
-			encoding: "utf-8",
-			maxBuffer: 1024 * 1024
-		});
-	} catch (err) {
-		if (err instanceof Error && "code" in err && err.code === "ENOENT") throw new Error("lute is required to load .luau config files but was not found on PATH");
-		throw new Error(`Failed to evaluate Luau config ${filePath}`, { cause: err });
-	}
-	let ast;
-	try {
-		ast = JSON.parse(stdout);
-	} catch (err) {
-		throw new Error(`Failed to parse AST JSON from Luau config ${filePath}`, { cause: err });
-	}
-	const result = evalLuauReturnLiterals(ast);
-	if (typeof result !== "object" || result === null) throw new Error(`Luau config ${filePath} must return a table`);
-	return result;
-}
-/**
-* Check if `<cwd>/<directoryOrFile>/jest.config.luau` exists. Returns the
-* resolved path if found, undefined otherwise.
-*/
-function findLuauConfigFile(directoryOrFile, cwd) {
-	const resolved = path$1.resolve(cwd, directoryOrFile, "jest.config.luau");
-	if (fs$1.existsSync(resolved)) return resolved;
-}
-function getTemporaryDirectory$1() {
-	if (cachedTemporaryDirectory$1 !== void 0 && fs$1.existsSync(cachedTemporaryDirectory$1)) return cachedTemporaryDirectory$1;
-	cachedTemporaryDirectory$1 = fs$1.mkdtempSync(path$1.join(os.tmpdir(), "jest-roblox-luau-config-"));
-	return cachedTemporaryDirectory$1;
-}
-//#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 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 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 applyProjectRoot(include, projectRoot) {
-	if (projectRoot === void 0) return include;
-	return include.map((pattern) => path$1.posix.join(projectRoot, pattern));
-}
-function createFsClassifier(rootDirectory) {
-	return function classify(fsPath) {
-		const absolute = path$1.isAbsolute(fsPath) ? fsPath : path$1.resolve(rootDirectory, fsPath);
-		const stat = fs.statSync(absolute, { throwIfNoEntry: false });
-		if (stat === void 0) return "missing";
-		return stat.isDirectory() ? "directory" : "file";
-	};
-}
-function validateProjects(projects) {
-	const names = /* @__PURE__ */ new Set();
-	for (const project of projects) {
-		const name = displayNameOf(project);
-		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, classify) {
-	const rootPrefixedInclude = applyProjectRoot(project.include, project.root);
-	const roots = extractProjectRoots(rootPrefixedInclude);
-	const testMatch = roots.flatMap((entry) => entry.testMatch);
-	const rojoMounts = resolveMounts(project, roots, rojoTree, classify);
-	const projects = rojoMounts.map((mount) => mount.dataModelPath);
-	const singleMount = rojoMounts.length === 1 ? rojoMounts[0] : void 0;
-	const config = mergeProjectConfig(rootConfig, project);
-	const displayName = displayNameOf(project);
-	return {
-		config,
-		displayColor: typeof project.displayName === "string" ? void 0 : project.displayName.color,
-		displayName,
-		include: rootPrefixedInclude,
-		outDir: singleMount?.fsPath,
-		projects,
-		rojoMounts,
-		testMatch
-	};
-}
-async function loadProjectConfigFile(filePath, cwd) {
-	const luauConfigPath = findLuauConfigFile(filePath, cwd);
-	if (luauConfigPath !== void 0) return buildProjectConfigFromLuau(luauConfigPath, filePath);
-	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
+//#region src/utils/error-chain.ts
+const MAX_DEPTH = 5;
+function walkErrorChain(err) {
+	const entries = [];
+	let current = err;
+	while (current instanceof Error && entries.length < MAX_DEPTH) {
+		entries.push({
+			name: current.constructor.name,
+			code: readStringProperty(current, "code"),
+			errno: readStringProperty(current, "errno"),
+			message: current.message,
+			syscall: readStringProperty(current, "syscall")
 		});
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(`Failed to load project config file ${filePath}: ${message}`, { cause: err });
+		current = current.cause;
 	}
-	const { config } = result;
-	if ((typeof config.displayName === "string" ? config.displayName : config.displayName.name) === "") throw new Error(`Project config file "${filePath}" must have a displayName`);
-	deriveIncludeFromTestMatch(config, path$1.posix.dirname(filePath), resolveTsconfigDirectories(cwd));
-	return config;
+	return entries;
 }
-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);
-	const classify = createFsClassifier(cwd);
-	return projects.map((project) => resolveProjectConfig(project, rootConfig, rojoTree, classify));
-}
-function displayNameOf(project) {
-	return typeof project.displayName === "string" ? project.displayName : project.displayName.name;
-}
-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 dedupeMounts(mounts) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const mount of mounts) if (!seen.has(mount.dataModelPath)) {
-		seen.add(mount.dataModelPath);
-		result.push(mount);
-	}
-	return result;
-}
-function joinProjectRoot(relativePath, projectRoot) {
-	return projectRoot !== void 0 ? path$1.posix.join(projectRoot, relativePath) : relativePath;
-}
-function pruneAncestorMounts(mounts) {
-	const dataModelPaths = mounts.map((mount) => mount.dataModelPath);
-	const surviving = new Set(pruneAncestors(dataModelPaths));
-	return mounts.filter((mount) => surviving.has(mount.dataModelPath));
-}
-function unmappableRootError(project, root, rojoTree) {
-	const name = displayNameOf(project);
-	const available = [];
-	collectPaths(rojoTree, available);
-	let message = `Project "${name}": include root "${root}" did not match any Rojo $path entry or subdirectory.`;
-	if (available.length > 0) message += `\n\nAvailable $path entries: ${available.join(", ")}`;
-	const hint = root.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;
-	return new ConfigError(message, hint);
-}
-function filterMountsForRoot(allMounts, root) {
-	return allMounts.filter((mount) => mount.fsPath === root || mount.fsPath.startsWith(`${root}/`));
-}
-function resolveMounts(project, roots, rojoTree, classify) {
-	if (project.outDir !== void 0) {
-		const resolvedOutDirectory = joinProjectRoot(project.outDir, project.root);
-		return [{
-			dataModelPath: mapFsRootToDataModel(resolvedOutDirectory, rojoTree),
-			fsPath: resolvedOutDirectory
-		}];
-	}
-	let collectedMounts;
-	const allMounts = [];
-	for (const { root } of roots) {
-		const exact = findInTree(rojoTree, root, "");
-		if (exact !== void 0) {
-			allMounts.push({
-				dataModelPath: exact,
-				fsPath: root
-			});
-			continue;
-		}
-		collectedMounts ??= collectMounts(rojoTree, "", classify);
-		const expanded = filterMountsForRoot(collectedMounts, root);
-		if (expanded.length === 0) throw unmappableRootError(project, root, rojoTree);
-		allMounts.push(...expanded);
-	}
-	return pruneAncestorMounts(dedupeMounts(allMounts));
-}
-function copyLuauOptionalFields(raw, config) {
-	const record = config;
-	for (const key of LUAU_BOOLEAN_KEYS) if (typeof raw[key] === "boolean") record[key] = raw[key];
-	for (const key of LUAU_NUMBER_KEYS) if (typeof raw[key] === "number") record[key] = raw[key];
-	for (const key of LUAU_STRING_KEYS) if (typeof raw[key] === "string") record[key] = raw[key];
-	for (const key of LUAU_STRING_ARRAY_KEYS) if (Array.isArray(raw[key])) record[key] = raw[key];
-}
-function buildProjectConfigFromLuau(luauConfigPath, directoryPath) {
-	const raw = loadLuauConfig(luauConfigPath);
-	const { displayName } = raw;
-	if (typeof displayName !== "string" || displayName === "") throw new Error(`Luau config file "${luauConfigPath}" must have a displayName string`);
-	const testMatch = Array.isArray(raw["testMatch"]) ? raw["testMatch"] : void 0;
-	const config = {
-		displayName,
-		include: testMatch !== void 0 ? testMatch.map((pattern) => path$1.posix.join(directoryPath, `${pattern}.luau`)) : [path$1.posix.join(directoryPath, "**/*.spec.luau")]
-	};
-	if (testMatch !== void 0) config.testMatch = testMatch;
-	copyLuauOptionalFields(raw, config);
-	return config;
-}
-/**
-* When a project config provides `testMatch` but not `include`, derive
-* `include` by appending `.ts` and `.tsx` extensions.  This lets users
-* write project configs with the standard Jest `testMatch` field without
-* needing the CLI-specific `include`.
-*/
-function deriveIncludeFromTestMatch(config, configDirectory, tsconfig) {
-	const raw = config;
-	if (raw["include"] !== void 0) return;
-	if (!Array.isArray(raw["testMatch"])) return;
-	config.include = raw["testMatch"].flatMap((pattern) => {
-		return (/\.(tsx?|luau?)$/.test(pattern) ? [pattern] : [`${pattern}.ts`, `${pattern}.tsx`]).map((extension) => path$1.posix.join(configDirectory, extension));
-	});
-	const { outDir, rootDir } = tsconfig;
-	if (raw["outDir"] === void 0 && rootDir !== void 0 && outDir !== void 0) {
-		const rootPrefix = `${rootDir}/`;
-		if (configDirectory.startsWith(rootPrefix)) config.outDir = `${outDir}/${configDirectory.slice(rootPrefix.length)}`;
-	}
-}
-const LUAU_BOOLEAN_KEYS = [
-	"automock",
-	"clearMocks",
-	"injectGlobals",
-	"mockDataModel",
-	"resetMocks",
-	"resetModules",
-	"restoreMocks"
-];
-const LUAU_NUMBER_KEYS = ["slowTestThreshold", "testTimeout"];
-const LUAU_STRING_KEYS = ["testEnvironment"];
-const LUAU_STRING_ARRAY_KEYS = ["setupFiles", "setupFilesAfterEnv"];
-//#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 STUB_FILENAME = "jest.config.lua";
-const USER_LUAU_FILENAME = "jest.config.luau";
-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 directory = path.dirname(project.outputPath);
-		if (hasUserAuthoredConfig(directory)) continue;
-		const content = serializeToLuau(project.config);
-		fs.mkdirSync(directory, { recursive: true });
-		fs.writeFileSync(project.outputPath, content, "utf8");
-	}
-}
-/**
-* Refuse to let any downstream write land outside `rootDirectory`. Mount
-* fsPaths originate from the rojo tree and `resolveNestedProjects` can emit
-* values with `..` segments (nested projects relocate paths); combined with
-* `path.resolve` on Windows, a permissive fsPath could send stub writes to
-* `D:\outside\...`. Guard at every write-site.
-*/
-function assertMountContained(project, fsPath, rootDirectory) {
-	if (path.isAbsolute(fsPath)) throw new Error(`Project "${project.displayName}" mount fsPath must be relative, got: ${fsPath}`);
-	const rootResolved = path.resolve(rootDirectory);
-	const mountResolved = path.resolve(rootDirectory, fsPath);
-	if (mountResolved !== rootResolved && !mountResolved.startsWith(rootResolved + path.sep)) throw new Error(`Project "${project.displayName}" mount fsPath escapes root directory: ${fsPath}`);
-}
-/**
-* For a multi-mount project, the stubs-per-mount rule requires that a
-* user-authored config at any tracked FS path must appear at every tracked
-* FS path (or none). Throws `ConfigError` when the project has partial
-* coverage — some mounts have a user config and others don't.
-*/
-function assertStubCollisionRule(project, rootDirectory) {
-	const withUser = [];
-	const withoutUser = [];
-	for (const mount of project.rojoMounts) {
-		assertMountContained(project, mount.fsPath, rootDirectory);
-		if (hasUserAuthoredConfig(path.resolve(rootDirectory, mount.fsPath))) withUser.push(mount.fsPath);
-		else withoutUser.push(mount.fsPath);
-	}
-	if (withUser.length === 0 || withoutUser.length === 0) return;
-	const withUserList = withUser.join(", ");
-	const withoutUserList = withoutUser.join(", ");
-	throw new ConfigError(`Project "${project.displayName}": user-authored jest config present at some mounts but not others.\n\nWith user config: ${withUserList}\nWithout user config: ${withoutUserList}\n\nFor multi-mount projects, either every tracked mount must have a user config, or none.`);
-}
-function syncStubsToShadowDirectory(projects, rootDirectory, shadowDirectory) {
-	let changed = false;
-	const expectedPaths = /* @__PURE__ */ new Set();
-	for (const project of projects) for (const mount of project.rojoMounts) {
-		const result = syncMountStub(project, mount.fsPath, rootDirectory, shadowDirectory);
-		if (result.targetPath !== void 0) expectedPaths.add(result.targetPath);
-		changed ||= result.changed;
-	}
-	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, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
-}
-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(", ")} }`;
-	}
+function readStringProperty(err, key) {
+	const value = Reflect.get(err, key);
+	if (value === void 0 || value === null) return;
 	return String(value);
 }
-function hasUserAuthoredConfig(directoryPath) {
-	const luauPath = path.join(directoryPath, USER_LUAU_FILENAME);
-	if (fs.existsSync(luauPath)) return true;
-	const luaPath = path.join(directoryPath, STUB_FILENAME);
-	if (!fs.existsSync(luaPath)) return false;
-	return !fs.readFileSync(luaPath, "utf8").startsWith(HEADER);
-}
-function syncMountStub(project, fsPath, rootDirectory, shadowDirectory) {
-	assertMountContained(project, fsPath, rootDirectory);
-	const sourcePath = path.resolve(rootDirectory, fsPath, STUB_FILENAME);
-	if (!fs.existsSync(sourcePath)) return {
-		changed: false,
-		targetPath: void 0
-	};
-	const targetPath = path.resolve(shadowDirectory, fsPath, STUB_FILENAME);
-	const sourceContent = fs.readFileSync(sourcePath);
-	if (fs.existsSync(targetPath)) {
-		const targetContent = fs.readFileSync(targetPath);
-		if (Buffer.compare(sourceContent, targetContent) === 0) return {
-			changed: false,
-			targetPath
-		};
-	}
-	fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-	fs.copyFileSync(sourcePath, targetPath);
-	return {
-		changed: true,
-		targetPath
-	};
-}
-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 === STUB_FILENAME) results.push(fullPath);
-	}
-	return results;
-}
-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 {}
-}
-//#endregion
-//#region src/coverage/derive-coverage-from.ts
-/**
-* Derives `collectCoverageFrom` glob patterns from project `include` patterns.
-*
-* Extracts the static root directory from each include pattern and generates
-* coverage globs that match source files within those roots, excluding test
-* files. The source extension (`.ts`, `.tsx`, `.luau`, `.lua`) is inferred from
-* each include pattern. Returns `undefined` when no roots can be extracted
-* (preserving default all-files behavior).
-*/
-function deriveCoverageFromIncludes(projects) {
-	const rootsByExtension = /* @__PURE__ */ new Map();
-	for (const project of projects) for (const pattern of project.include) {
-		const extension = inferSourceExtension(pattern);
-		try {
-			const { root } = extractStaticRoot(pattern);
-			const roots = rootsByExtension.get(extension) ?? /* @__PURE__ */ new Set();
-			roots.add(root);
-			rootsByExtension.set(extension, roots);
-		} catch {}
-	}
-	if (rootsByExtension.size === 0) return;
-	const patterns = [];
-	for (const [extension, roots] of rootsByExtension) for (const root of roots) patterns.push(`${root}/**/*${extension}`);
-	for (const extension of rootsByExtension.keys()) patterns.push(`!**/*.spec${extension}`, `!**/*.test${extension}`);
-	return patterns;
-}
-/**
-* Infers the source file extension from an include pattern by stripping the
-* `.spec` or `.test` suffix. Throws when the pattern has no recognizable test
-* extension so that misconfigured globs fail loudly.
-*/
-function inferSourceExtension(pattern) {
-	const match = pattern.match(/\.(?:spec|test)(\.\w+)$/);
-	if (!match) throw new Error(`Cannot infer source extension from include pattern "${pattern}". Patterns must end with .spec.<ext> or .test.<ext> (e.g. **/*.spec.ts, **/*.test.luau).`);
-	const [, extension] = match;
-	return extension;
-}
-//#endregion
-//#region src/coverage/mapper.ts
-const positionSchema = type({
-	column: "number",
-	line: "number"
-});
-const spanSchema = type({
-	end: positionSchema,
-	start: positionSchema
-});
-const functionEntrySchema = type({
-	name: "string",
-	location: type({
-		end: positionSchema,
-		start: positionSchema
-	})
-});
-const branchEntrySchema = type({
-	locations: type("Record<string, unknown>[]"),
-	type: "string"
-});
-const NESTED_RECORD = "Record<string, Record<string, unknown>>";
-const coverageMapSchema = type({
-	"branchMap?": NESTED_RECORD,
-	"functionMap?": NESTED_RECORD,
-	"statementMap": type(NESTED_RECORD)
-});
-function mapCoverageToTypeScript(coverageData, manifest) {
-	const pendingStatements = /* @__PURE__ */ new Map();
-	const pendingFunctions = /* @__PURE__ */ new Map();
-	const pendingBranches = /* @__PURE__ */ new Map();
-	for (const [fileKey, fileCoverage] of Object.entries(coverageData)) {
-		const record = manifest.files[fileKey];
-		if (record === void 0) continue;
-		const resources = loadFileResources(record);
-		if (resources === void 0) continue;
-		if (resources.traceMap === void 0) {
-			passthroughFileStatements(resources, fileCoverage, pendingStatements);
-			passthroughFileFunctions(resources, fileCoverage, pendingFunctions);
-			passthroughFileBranches(resources, fileCoverage, pendingBranches);
-		} else {
-			const mapped = {
-				coverageMap: resources.coverageMap,
-				sourceMapDirectory: resources.sourceMapDirectory,
-				traceMap: resources.traceMap
-			};
-			mapFileFunctions(mapped, fileCoverage, pendingFunctions, mapFileStatements(mapped, fileCoverage, pendingStatements));
-			mapFileBranches(mapped, fileCoverage, pendingBranches);
-		}
-	}
-	return buildResult(pendingStatements, pendingFunctions, pendingBranches);
-}
-function loadFileResources(record) {
-	let coverageMapRaw;
-	try {
-		coverageMapRaw = fs$1.readFileSync(record.coverageMapPath, "utf-8");
-	} catch {
-		return;
-	}
-	const parsed = coverageMapSchema(JSON.parse(coverageMapRaw));
-	if (parsed instanceof type.errors) return;
-	let traceMap;
-	try {
-		traceMap = new TraceMap(fs$1.readFileSync(record.sourceMapPath, "utf-8"));
-	} catch {}
-	const sourceMapDirectory = path$1.posix.dirname(record.sourceMapPath);
-	return {
-		coverageMap: parsed,
-		sourceKey: record.key,
-		sourceMapDirectory,
-		traceMap
-	};
-}
-function toIstanbulColumn(luauColumn) {
-	return Math.max(0, luauColumn - 1);
-}
-function passthroughFileStatements(resources, fileCoverage, pending) {
-	let fileStatements = pending.get(resources.sourceKey);
-	if (fileStatements === void 0) {
-		fileStatements = /* @__PURE__ */ new Map();
-		pending.set(resources.sourceKey, fileStatements);
-	}
-	for (const [statementId, rawSpan] of Object.entries(resources.coverageMap.statementMap)) {
-		const span = spanSchema(rawSpan);
-		if (span instanceof type.errors) continue;
-		const hitCount = fileCoverage.s[statementId] ?? 0;
-		fileStatements.set(statementId, {
-			end: {
-				column: toIstanbulColumn(span.end.column),
-				line: span.end.line
-			},
-			hitCount,
-			start: {
-				column: toIstanbulColumn(span.start.column),
-				line: span.start.line
-			}
-		});
-	}
-}
-function passthroughFileFunctions(resources, fileCoverage, pendingFunctions) {
-	if (resources.coverageMap.functionMap === void 0) return;
-	let fileFunctions = pendingFunctions.get(resources.sourceKey);
-	if (fileFunctions === void 0) {
-		fileFunctions = [];
-		pendingFunctions.set(resources.sourceKey, fileFunctions);
-	}
-	for (const [functionId, rawEntry] of Object.entries(resources.coverageMap.functionMap)) {
-		const entry = functionEntrySchema(rawEntry);
-		if (entry instanceof type.errors) continue;
-		fileFunctions.push({
-			name: entry.name,
-			hitCount: fileCoverage.f?.[functionId] ?? 0,
-			loc: {
-				end: {
-					column: toIstanbulColumn(entry.location.end.column),
-					line: entry.location.end.line
-				},
-				start: {
-					column: toIstanbulColumn(entry.location.start.column),
-					line: entry.location.start.line
-				}
-			}
-		});
-	}
-}
-function passthroughFileBranches(resources, fileCoverage, pendingBranches) {
-	if (resources.coverageMap.branchMap === void 0) return;
-	let fileBranches = pendingBranches.get(resources.sourceKey);
-	if (fileBranches === void 0) {
-		fileBranches = [];
-		pendingBranches.set(resources.sourceKey, fileBranches);
-	}
-	for (const [branchId, rawEntry] of Object.entries(resources.coverageMap.branchMap)) {
-		const entry = branchEntrySchema(rawEntry);
-		if (entry instanceof type.errors) continue;
-		const armHitCounts = fileCoverage.b?.[branchId] ?? [];
-		const locations = [];
-		for (const rawLocation of entry.locations) {
-			const location = spanSchema(rawLocation);
-			if (location instanceof type.errors) continue;
-			locations.push({
-				end: {
-					column: toIstanbulColumn(location.end.column),
-					line: location.end.line
-				},
-				start: {
-					column: toIstanbulColumn(location.start.column),
-					line: location.start.line
-				}
-			});
-		}
-		if (locations.length === 0) continue;
-		const firstLocation = locations[0];
-		const lastLocation = locations[locations.length - 1];
-		assert(firstLocation !== void 0 && lastLocation !== void 0, "Branch locations must not be empty after filtering");
-		fileBranches.push({
-			armHitCounts: entry.locations.map((_, index) => armHitCounts[index] ?? 0),
-			loc: {
-				end: lastLocation.end,
-				start: firstLocation.start
-			},
-			locations,
-			type: entry.type
-		});
-	}
-}
-/**
-* Resolves a source path from a source map against the source map's directory.
-* Source maps produce paths relative to the .map file (e.g.,
-* `../../../packages/src/file.ts` from `out/packages/src/file.lua.map`).
-* Joining with the map directory normalizes these to cwd-relative paths.
-* Paths that are already cwd-relative (no `..` prefix) pass through unchanged.
-*/
-function resolveSourcePath(source, sourceMapDirectory) {
-	const normalized = source.replaceAll("\\", "/");
-	if (!normalized.startsWith("..")) return normalized;
-	return path$1.posix.normalize(path$1.posix.join(sourceMapDirectory, normalized));
-}
-function mapStatement(traceMap, span, sourceMapDirectory) {
-	const mappedStart = originalPositionFor(traceMap, {
-		column: Math.max(0, span.start.column - 1),
-		line: span.start.line
-	});
-	const mappedEnd = originalPositionFor(traceMap, {
-		column: Math.max(0, span.end.column - 1),
-		line: span.end.line
-	});
-	if (mappedStart.source === null || mappedEnd.source === null || mappedStart.source !== mappedEnd.source) return;
-	const resolvedSource = resolveSourcePath(mappedStart.source, sourceMapDirectory);
-	return {
-		end: {
-			column: mappedEnd.column,
-			line: mappedEnd.line,
-			source: resolvedSource
-		},
-		start: {
-			column: mappedStart.column,
-			line: mappedStart.line,
-			source: resolvedSource
-		}
-	};
-}
-function maxPosition(a, b) {
-	if (a.line > b.line) return a;
-	if (b.line > a.line) return b;
-	return a.column >= b.column ? a : b;
-}
-function addOrCoalesce(pending, start, end, hitCount) {
-	const tsPath = start.source;
-	let fileStatements = pending.get(tsPath);
-	if (fileStatements === void 0) {
-		fileStatements = /* @__PURE__ */ new Map();
-		pending.set(tsPath, fileStatements);
-	}
-	const coalescenceKey = `${String(start.line)}:${String(start.column)}`;
-	const existing = fileStatements.get(coalescenceKey);
-	if (existing !== void 0) {
-		existing.hitCount += hitCount;
-		existing.end = maxPosition(existing.end, {
-			column: end.column,
-			line: end.line
-		});
-	} else fileStatements.set(coalescenceKey, {
-		end: {
-			column: end.column,
-			line: end.line
-		},
-		hitCount,
-		start: {
-			column: start.column,
-			line: start.line
-		}
-	});
-}
-function mapFileStatements(resources, fileCoverage, pending) {
-	const resolvedTsPaths = /* @__PURE__ */ new Set();
-	for (const [statementId, rawSpan] of Object.entries(resources.coverageMap.statementMap)) {
-		const span = spanSchema(rawSpan);
-		if (span instanceof type.errors) continue;
-		const hitCount = fileCoverage.s[statementId] ?? 0;
-		const mapped = mapStatement(resources.traceMap, span, resources.sourceMapDirectory);
-		if (mapped === void 0) continue;
-		resolvedTsPaths.add(mapped.start.source);
-		addOrCoalesce(pending, mapped.start, mapped.end, hitCount);
-	}
-	return resolvedTsPaths;
-}
-function mapFileFunctions(resources, fileCoverage, pendingFunctions, resolvedTsPaths) {
-	if (resources.coverageMap.functionMap === void 0) return;
-	for (const [functionId, rawEntry] of Object.entries(resources.coverageMap.functionMap)) {
-		const entry = functionEntrySchema(rawEntry);
-		if (entry instanceof type.errors) continue;
-		const hitCount = fileCoverage.f?.[functionId] ?? 0;
-		const mapped = mapStatement(resources.traceMap, entry.location, resources.sourceMapDirectory);
-		if (mapped !== void 0) {
-			const tsPath = mapped.start.source;
-			let fileFunctions = pendingFunctions.get(tsPath);
-			if (fileFunctions === void 0) {
-				fileFunctions = [];
-				pendingFunctions.set(tsPath, fileFunctions);
-			}
-			fileFunctions.push({
-				name: entry.name,
-				hitCount,
-				loc: {
-					end: {
-						column: mapped.end.column,
-						line: mapped.end.line
-					},
-					start: {
-						column: mapped.start.column,
-						line: mapped.start.line
-					}
-				}
-			});
-			continue;
-		}
-		const fallbackPath = resolvedTsPaths.values().next().value;
-		if (fallbackPath === void 0) continue;
-		let fileFunctions = pendingFunctions.get(fallbackPath);
-		if (fileFunctions === void 0) {
-			fileFunctions = [];
-			pendingFunctions.set(fallbackPath, fileFunctions);
-		}
-		fileFunctions.push({
-			name: entry.name,
-			hitCount,
-			loc: {
-				end: {
-					column: 0,
-					line: 1
-				},
-				start: {
-					column: 0,
-					line: 1
-				}
-			}
-		});
-	}
-}
-function mapBranchArmLocations(traceMap, rawLocations, sourceMapDirectory) {
-	const mappedLocations = [];
-	let tsPath;
-	for (const rawLocation of rawLocations) {
-		const location = spanSchema(rawLocation);
-		if (location instanceof type.errors) return;
-		const mapped = mapStatement(traceMap, location, sourceMapDirectory);
-		if (mapped === void 0) return;
-		if (tsPath === void 0) tsPath = mapped.start.source;
-		else if (tsPath !== mapped.start.source) return;
-		mappedLocations.push({
-			end: {
-				column: mapped.end.column,
-				line: mapped.end.line
-			},
-			start: {
-				column: mapped.start.column,
-				line: mapped.start.line
-			}
-		});
-	}
-	if (tsPath === void 0 || mappedLocations.length === 0) return;
-	return {
-		locations: mappedLocations,
-		tsPath
-	};
-}
-function mapFileBranches(resources, fileCoverage, pendingBranches) {
-	if (resources.coverageMap.branchMap === void 0) return;
-	for (const [branchId, rawEntry] of Object.entries(resources.coverageMap.branchMap)) {
-		const entry = branchEntrySchema(rawEntry);
-		if (entry instanceof type.errors) continue;
-		const armHitCounts = fileCoverage.b?.[branchId] ?? [];
-		const result = mapBranchArmLocations(resources.traceMap, entry.locations, resources.sourceMapDirectory);
-		if (result === void 0) continue;
-		let fileBranches = pendingBranches.get(result.tsPath);
-		if (fileBranches === void 0) {
-			fileBranches = [];
-			pendingBranches.set(result.tsPath, fileBranches);
-		}
-		const firstLocation = result.locations[0];
-		const lastLocation = result.locations[result.locations.length - 1];
-		assert(firstLocation !== void 0 && lastLocation !== void 0, "Branch locations must not be empty after successful mapping");
-		fileBranches.push({
-			armHitCounts: entry.locations.map((_, index) => armHitCounts[index] ?? 0),
-			loc: {
-				end: lastLocation.end,
-				start: firstLocation.start
-			},
-			locations: result.locations,
-			type: entry.type
-		});
-	}
-}
-function populateStatements(file, statementMap) {
-	if (statementMap === void 0) return;
-	let index = 0;
-	for (const statement of statementMap.values()) {
-		const id = String(index);
-		file.statementMap[id] = {
-			end: statement.end,
-			start: statement.start
-		};
-		file.s[id] = statement.hitCount;
-		index++;
-	}
-}
-function populateFunctions(file, fileFunctions) {
-	if (fileFunctions === void 0) return;
-	let functionIndex = 0;
-	for (const func of fileFunctions) {
-		const id = String(functionIndex);
-		file.fnMap[id] = {
-			name: func.name,
-			loc: func.loc
-		};
-		file.f[id] = func.hitCount;
-		functionIndex++;
-	}
-}
-function populateBranches(file, fileBranches) {
-	if (fileBranches === void 0) return;
-	let branchIndex = 0;
-	for (const branch of fileBranches) {
-		const id = String(branchIndex);
-		file.branchMap[id] = {
-			loc: branch.loc,
-			locations: branch.locations,
-			type: branch.type
-		};
-		file.b[id] = branch.armHitCounts;
-		branchIndex++;
-	}
-}
-function buildResult(pending, pendingFunctions, pendingBranches) {
-	const files = {};
-	const allPaths = new Set([
-		...pending.keys(),
-		...pendingFunctions.keys(),
-		...pendingBranches.keys()
-	]);
-	for (const tsPath of allPaths) {
-		const file = {
-			b: {},
-			branchMap: {},
-			f: {},
-			fnMap: {},
-			path: tsPath,
-			s: {},
-			statementMap: {}
-		};
-		populateStatements(file, pending.get(tsPath));
-		populateFunctions(file, pendingFunctions.get(tsPath));
-		populateBranches(file, pendingBranches.get(tsPath));
-		files[tsPath] = file;
-	}
-	return { files };
-}
-//#endregion
-//#region src/coverage/merge-raw-coverage.ts
-/**
-* Additively merge two raw coverage datasets. Overlapping files have their
-* hit counts summed (matching istanbul-lib-coverage's semantics).
-*/
-function mergeRawCoverage(target, source) {
-	if (target === void 0) return source;
-	if (source === void 0) return target;
-	const result = { ...target };
-	for (const [filePath, fileCoverage] of Object.entries(source)) {
-		const existing = result[filePath];
-		result[filePath] = existing === void 0 ? { ...fileCoverage } : mergeFileCoverage(existing, fileCoverage);
-	}
-	return result;
-}
-function sumScalars(a, b) {
-	const result = { ...a };
-	for (const [key, value] of Object.entries(b)) result[key] = (result[key] ?? 0) + value;
-	return result;
-}
-function sumBranches(a, b) {
-	const result = { ...a };
-	for (const [key, bArms] of Object.entries(b)) {
-		const aArms = result[key];
-		if (aArms === void 0) {
-			result[key] = [...bArms];
-			continue;
-		}
-		const length = Math.max(aArms.length, bArms.length);
-		result[key] = Array.from({ length }, (_, index) => (aArms[index] ?? 0) + (bArms[index] ?? 0));
-	}
-	return result;
-}
-function mergeFileCoverage(a, b) {
-	const merged = { s: sumScalars(a.s, b.s) };
-	if (a.f !== void 0 || b.f !== void 0) merged.f = sumScalars(a.f ?? {}, b.f ?? {});
-	if (a.b !== void 0 || b.b !== void 0) merged.b = sumBranches(a.b ?? {}, b.b ?? {});
-	return merged;
-}
-//#endregion
-//#region src/coverage/coverage-collector.ts
-const INSTRUMENTABLE_STATEMENT_TAGS = new Set([
-	"assign",
-	"break",
-	"compoundassign",
-	"conditional",
-	"continue",
-	"do",
-	"expression",
-	"for",
-	"forin",
-	"function",
-	"local",
-	"localfunction",
-	"repeat",
-	"return",
-	"while"
-]);
-const END_KEYWORD_LENGTH = 3;
-function collectCoverage(root) {
-	let statementIndex = 1;
-	let functionIndex = 1;
-	let branchIndex = 1;
-	const statements = [];
-	const functions = [];
-	const branches = [];
-	const implicitElseProbes = [];
-	const exprIfProbes = [];
-	const namedFunctions = /* @__PURE__ */ new Set();
-	visitBlock(root, {
-		visitExprFunction(node) {
-			if (namedFunctions.has(node)) return true;
-			const first = getBodyFirstStatement(node.body);
-			functions.push({
-				name: "(anonymous)",
-				bodyFirstColumn: first.column,
-				bodyFirstLine: first.line,
-				index: functionIndex,
-				location: { ...node.location }
-			});
-			functionIndex++;
-			return true;
-		},
-		visitExprIfElse(node) {
-			const branch = {
-				arms: [],
-				branchType: "expr-if",
-				index: branchIndex
-			};
-			let armIndex = 1;
-			branch.arms.push({
-				bodyFirstColumn: 0,
-				bodyFirstLine: 0,
-				location: { ...node.thenExpr.location }
-			});
-			exprIfProbes.push({
-				armIndex,
-				branchIndex,
-				exprLocation: { ...node.thenExpr.location }
-			});
-			armIndex++;
-			for (const elseif of node.elseifs) {
-				branch.arms.push({
-					bodyFirstColumn: 0,
-					bodyFirstLine: 0,
-					location: { ...elseif.thenExpr.location }
-				});
-				exprIfProbes.push({
-					armIndex,
-					branchIndex,
-					exprLocation: { ...elseif.thenExpr.location }
-				});
-				armIndex++;
-			}
-			branch.arms.push({
-				bodyFirstColumn: 0,
-				bodyFirstLine: 0,
-				location: { ...node.elseExpr.location }
-			});
-			exprIfProbes.push({
-				armIndex,
-				branchIndex,
-				exprLocation: { ...node.elseExpr.location }
-			});
-			branches.push(branch);
-			branchIndex++;
-			return true;
-		},
-		visitStatBlock(block) {
-			for (const stmt of block.statements) if (INSTRUMENTABLE_STATEMENT_TAGS.has(stmt.tag)) {
-				statements.push({
-					index: statementIndex,
-					location: { ...stmt.location }
-				});
-				statementIndex++;
-			}
-			return true;
-		},
-		visitStatFunction(node) {
-			const name = extractFunctionName(node);
-			const first = getBodyFirstStatement(node.func.body);
-			namedFunctions.add(node.func);
-			functions.push({
-				name,
-				bodyFirstColumn: first.column,
-				bodyFirstLine: first.line,
-				index: functionIndex,
-				location: { ...node.location }
-			});
-			functionIndex++;
-			return true;
-		},
-		visitStatIf(node) {
-			const branch = {
-				arms: [],
-				branchType: "if",
-				index: branchIndex
-			};
-			const thenFirst = getBodyFirstStatement(node.thenBlock);
-			branch.arms.push({
-				bodyFirstColumn: thenFirst.column,
-				bodyFirstLine: thenFirst.line,
-				location: { ...node.thenBlock.location }
-			});
-			for (const elseif of node.elseifs) {
-				const elseifFirst = getBodyFirstStatement(elseif.thenBlock);
-				branch.arms.push({
-					bodyFirstColumn: elseifFirst.column,
-					bodyFirstLine: elseifFirst.line,
-					location: { ...elseif.thenBlock.location }
-				});
-			}
-			const { elseBlock } = node;
-			const hasExplicitElse = elseBlock !== void 0 && elseBlock.statements.length > 0;
-			if (hasExplicitElse) {
-				const elseFirst = getBodyFirstStatement(elseBlock);
-				branch.arms.push({
-					bodyFirstColumn: elseFirst.column,
-					bodyFirstLine: elseFirst.line,
-					location: { ...elseBlock.location }
-				});
-			}
-			if (!hasExplicitElse) {
-				branch.arms.push({
-					bodyFirstColumn: 0,
-					bodyFirstLine: 0,
-					location: {
-						beginColumn: node.location.beginColumn,
-						beginLine: node.location.beginLine,
-						endColumn: node.location.beginColumn,
-						endLine: node.location.beginLine
-					}
-				});
-				implicitElseProbes.push({
-					armIndex: branch.arms.length,
-					branchIndex,
-					endColumn: node.location.endColumn - END_KEYWORD_LENGTH,
-					endLine: node.location.endLine
-				});
-			}
-			branches.push(branch);
-			branchIndex++;
-			return true;
-		},
-		visitStatLocalFunction(node) {
-			const name = node.name.name.text;
-			const first = getBodyFirstStatement(node.func.body);
-			namedFunctions.add(node.func);
-			functions.push({
-				name,
-				bodyFirstColumn: first.column,
-				bodyFirstLine: first.line,
-				index: functionIndex,
-				location: { ...node.location }
-			});
-			functionIndex++;
-			return true;
-		}
-	});
-	return {
-		branches,
-		exprIfProbes,
-		functions,
-		implicitElseProbes,
-		statements
-	};
-}
-function getBodyFirstStatement(block) {
-	const first = block.statements[0];
-	if (first !== void 0) return {
-		column: first.location.beginColumn,
-		line: first.location.beginLine
-	};
-	return {
-		column: block.location.beginColumn,
-		line: block.location.beginLine
-	};
-}
-function extractExprName(expr) {
-	if (expr.tag === "global") return expr.name.text;
-	if (expr.tag === "indexname") return `${extractExprName(expr.expression)}${expr.accessor.text}${expr.index.text}`;
-	return "(anonymous)";
-}
-function extractFunctionName(node) {
-	return extractExprName(node.name);
-}
-//#endregion
-//#region src/coverage/coverage-map-builder.ts
-function buildCoverageMap$1(result) {
-	const statementMap = {};
-	for (const statement of result.statements) statementMap[String(statement.index)] = {
-		end: {
-			column: statement.location.endColumn,
-			line: statement.location.endLine
-		},
-		start: {
-			column: statement.location.beginColumn,
-			line: statement.location.beginLine
-		}
-	};
-	const functionMap = {};
-	for (const func of result.functions) functionMap[String(func.index)] = {
-		name: func.name,
-		location: {
-			end: {
-				column: func.location.endColumn,
-				line: func.location.endLine
-			},
-			start: {
-				column: func.location.beginColumn,
-				line: func.location.beginLine
-			}
-		}
-	};
-	const branchMap = {};
-	for (const branch of result.branches) branchMap[String(branch.index)] = {
-		locations: branch.arms.map((arm) => {
-			return {
-				end: {
-					column: arm.location.endColumn,
-					line: arm.location.endLine
-				},
-				start: {
-					column: arm.location.beginColumn,
-					line: arm.location.beginLine
-				}
-			};
-		}),
-		type: branch.branchType
-	};
-	return {
-		branchMap,
-		functionMap,
-		statementMap
-	};
-}
-//#endregion
-//#region src/coverage/probe-inserter.ts
-function insertProbes(source, result, fileKey) {
-	const lines = splitLines(source);
-	applyProbes(lines, collectProbes(result));
-	return buildPreamble(extractModeDirective(lines), fileKey, result) + lines.join("\n");
-}
-function collectProbes(result) {
-	const probes = [];
-	for (const stmt of result.statements) probes.push({
-		column: stmt.location.beginColumn,
-		line: stmt.location.beginLine,
-		text: `__cov_s[${stmt.index}] += 1; `
-	});
-	for (const func of result.functions) if (func.bodyFirstLine > 0) probes.push({
-		column: func.bodyFirstColumn,
-		line: func.bodyFirstLine,
-		text: `__cov_f[${func.index}] += 1; `
-	});
-	for (const branch of result.branches) for (let armIndex = 0; armIndex < branch.arms.length; armIndex++) {
-		const arm = branch.arms[armIndex];
-		if (arm !== void 0 && arm.bodyFirstLine > 0) probes.push({
-			column: arm.bodyFirstColumn,
-			line: arm.bodyFirstLine,
-			text: `__cov_b[${branch.index}][${armIndex + 1}] += 1; `
-		});
-	}
-	for (const probe of result.implicitElseProbes) probes.push({
-		column: probe.endColumn,
-		line: probe.endLine,
-		text: `else __cov_b[${probe.branchIndex}][${probe.armIndex}] += 1 `
-	});
-	for (const probe of result.exprIfProbes) probes.push({
-		column: probe.exprLocation.beginColumn,
-		line: probe.exprLocation.beginLine,
-		text: `__cov_br(${probe.branchIndex}, ${probe.armIndex}, `
-	}, {
-		column: probe.exprLocation.endColumn,
-		line: probe.exprLocation.endLine,
-		text: ")"
-	});
-	probes.sort((a, b) => {
-		if (a.line === b.line) return b.column - a.column;
-		return b.line - a.line;
-	});
-	return probes;
-}
-/** Mutates `mutableLines` in place, inserting probe text at each probe's position. */
-function applyProbes(mutableLines, probes) {
-	for (const { column, line: probeLine, text } of probes) {
-		const lineIndex = probeLine - 1;
-		const line = mutableLines[lineIndex];
-		assert(line !== void 0, `Invalid probe line number: ${probeLine}`);
-		const before = line.slice(0, column - 1);
-		const after = line.slice(column - 1);
-		mutableLines[lineIndex] = before + (before.length > 0 && !/\s$/.test(before) && /^[a-zA-Z_]/.test(text) ? " " : "") + text + after;
-	}
-}
-function extractModeDirective(lines) {
-	if (lines.length > 0 && lines[0] !== void 0 && /^--![a-z]+/.test(lines[0])) {
-		const directive = `${lines[0]}\n`;
-		lines.splice(0, 1);
-		return directive;
-	}
-	return "";
-}
-function splitLines(source) {
-	const lines = [];
-	let position = 0;
-	while (position < source.length) {
-		const nlPosition = source.indexOf("\n", position);
-		if (nlPosition !== -1) {
-			let lineEnd = nlPosition;
-			if (lineEnd > position && source[lineEnd - 1] === "\r") lineEnd--;
-			lines.push(source.slice(position, lineEnd));
-			position = nlPosition + 1;
-		} else {
-			lines.push(source.slice(position));
-			position = source.length;
-		}
-	}
-	if (lines.length === 0) lines.push("");
-	return lines;
-}
-function buildPreamble(modeDirective, fileKey, result) {
-	const escapedKey = fileKey.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("\0", "");
-	let preamble = modeDirective;
-	preamble += "if _G.__jest_roblox_cov == nil then _G.__jest_roblox_cov = {} end\n";
-	preamble += `local __cov_file_key = "${escapedKey}"\n`;
-	preamble += "if _G.__jest_roblox_cov[__cov_file_key] == nil then _G.__jest_roblox_cov[__cov_file_key] = {} end\n";
-	preamble += "if _G.__jest_roblox_cov[__cov_file_key].s == nil then _G.__jest_roblox_cov[__cov_file_key].s = {} end\n";
-	preamble += "local __cov_s = _G.__jest_roblox_cov[__cov_file_key].s\n";
-	if (result.statements.length > 0) preamble += `for __i = 1, ${result.statements.length} do if __cov_s[__i] == nil then __cov_s[__i] = 0 end end\n`;
-	if (result.functions.length > 0) {
-		preamble += "if _G.__jest_roblox_cov[__cov_file_key].f == nil then _G.__jest_roblox_cov[__cov_file_key].f = {} end\n";
-		preamble += "local __cov_f = _G.__jest_roblox_cov[__cov_file_key].f\n";
-		preamble += `for __i = 1, ${result.functions.length} do if __cov_f[__i] == nil then __cov_f[__i] = 0 end end\n`;
-	}
-	if (result.branches.length > 0) {
-		preamble += "if _G.__jest_roblox_cov[__cov_file_key].b == nil then _G.__jest_roblox_cov[__cov_file_key].b = {} end\n";
-		preamble += "local __cov_b = _G.__jest_roblox_cov[__cov_file_key].b\n";
-		for (const branch of result.branches) {
-			const zeros = branch.arms.map(() => "0").join(", ");
-			preamble += `if __cov_b[${branch.index}] == nil then __cov_b[${branch.index}] = {${zeros}} end\n`;
-		}
-		if (result.exprIfProbes.length > 0) preamble += "local function __cov_br(__bi, __ai, ...) __cov_b[__bi][__ai] += 1; return ... end\n";
-	}
-	return preamble;
-}
-//#endregion
-//#region src/coverage/instrumenter.ts
-let cachedTemporaryDirectory;
-/**
-* Instrument a single luauRoot directory. Returns the files map without
-* writing a manifest — used by `prepareCoverage()` to merge multiple roots.
-*/
-function instrumentRoot(options) {
-	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 = astOutputDirectoryOption ?? path$1.join(lazyTemporaryDirectory, "asts");
-	if (parseScript === void 0) fs$1.writeFileSync(scriptPath, parse_ast_default);
-	fs$1.mkdirSync(astOutputDirectory, { recursive: true });
-	const luteArgs = [
-		"run",
-		scriptPath,
-		"--",
-		path$1.resolve(luauRoot),
-		astOutputDirectory
-	];
-	if (skipFiles !== void 0 && skipFiles.size > 0) {
-		const skipListPath = toPosix(path$1.join(astOutputDirectory, "skip-list.json"));
-		fs$1.writeFileSync(skipListPath, JSON.stringify([...skipFiles]));
-		luteArgs.push(skipListPath);
-	}
-	let fileListJson;
-	try {
-		fileListJson = cp.execFileSync("lute", luteArgs, {
-			encoding: "utf-8",
-			maxBuffer: 1024 * 1024
-		});
-	} catch (err) {
-		if (err instanceof Error && "code" in err && err.code === "ENOENT") throw new Error("lute is required for instrumentation but was not found on PATH");
-		throw new Error("Failed to parse Luau files", { cause: err });
-	}
-	let fileList;
-	try {
-		fileList = JSON.parse(fileListJson);
-	} catch (err) {
-		throw new Error("Failed to parse file list from lute", { cause: err });
-	}
-	if (!Array.isArray(fileList)) throw new Error("Expected file list array from lute");
-	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$1.readFileSync(astJsonPath, "utf-8");
-		} catch (err) {
-			throw new Error(`Failed to read AST for ${relativePath}`, { cause: err });
-		}
-		const ast = JSON.parse(astJson);
-		const fileKey = toPosix(path$1.join(posixLuauRoot, relativePath));
-		const originalLuauPath = fileKey;
-		const instrumentedLuauPath = toPosix(path$1.join(shadowDir, relativePath));
-		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$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$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,
-			coverageMapPath: toPosix(coverageMapOutputPath),
-			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$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) {
-	try {
-		cp.execFileSync("rojo", [
-			"build",
-			projectPath,
-			"-o",
-			outputPath
-		], { stdio: "pipe" });
-	} catch (err) {
-		if (err instanceof Error && "code" in err && err.code === "ENOENT") throw new Error("rojo is required for --coverage but was not found on PATH");
-		const stderr = err instanceof Error && "stderr" in err && Buffer.isBuffer(err.stderr) ? err.stderr.toString().trim() : void 0;
-		const message = stderr !== void 0 && stderr.length > 0 ? `rojo build failed: ${stderr}` : "rojo build failed";
-		throw new Error(message, { cause: err });
-	}
-}
-//#endregion
-//#region src/coverage/rojo-rewriter.ts
-function rewriteRojoProject(project, options) {
-	const roots = isMultiRoot(options) ? options.roots.map(buildRootContext) : [buildRootContext(options)];
-	const context = {
-		relocation: options.projectRelocation?.replaceAll("\\", "/"),
-		roots
-	};
-	return {
-		...project,
-		tree: walkTree(project.tree, context)
-	};
-}
-function isMultiRoot(options) {
-	return "roots" in options;
-}
-function buildRootContext(entry) {
-	return {
-		luauRoot: entry.luauRoot.replaceAll("\\", "/").replace(/\/$/, ""),
-		relocatedShadowDirectory: entry.relocatedShadowDirectory?.replaceAll("\\", "/"),
-		shadowDirectory: entry.shadowDir
-	};
-}
-function rewritePath(value, context) {
-	const normalized = value.replaceAll("\\", "/");
-	for (const root of context.roots) if (normalized === root.luauRoot || normalized.startsWith(`${root.luauRoot}/`)) {
-		const suffix = normalized.slice(root.luauRoot.length);
-		if (context.relocation === void 0 || root.relocatedShadowDirectory === void 0) return root.shadowDirectory + suffix;
-		return root.relocatedShadowDirectory + suffix;
-	}
-	if (context.relocation !== void 0) return `${context.relocation}/${normalized}`;
-	return value;
-}
-function walkTree(node, context) {
-	const result = {};
-	for (const [key, value] of Object.entries(node)) if (key === "$path" && typeof value === "string") result[key] = rewritePath(value, context);
-	else if (typeof value === "object" && !Array.isArray(value) && !key.startsWith("$")) result[key] = walkTree(value, context);
-	else result[key] = value;
-	return result;
-}
-//#endregion
-//#region src/coverage/prepare.ts
-const COVERAGE_DIR = ".jest-roblox-coverage";
-/**
-* Suffixes for files that are not instrumented for coverage but still need
-* syncing to the shadow directory. Matches parse-ast.luau:131-139.
-*/
-const NON_INSTRUMENTED_SUFFIXES = [
-	".spec.luau",
-	".test.luau",
-	".spec.lua",
-	".test.lua",
-	".snap.luau",
-	".snap.lua"
-];
-function isNonInstrumentedFile(filename) {
-	return NON_INSTRUMENTED_SUFFIXES.some((suffix) => filename.endsWith(suffix));
-}
-const previousManifestSchema = type({
-	"files": type({ "[string]": { sourceHash: "string" } }),
-	"instrumenterVersion": "number",
-	"luauRoots": "string[]",
-	"nonInstrumentedFiles?": type({ "[string]": {
-		shadowPath: "string",
-		sourceHash: "string",
-		sourcePath: "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$1.existsSync(directoryPath)) return false;
-		if (!fs$1.statSync(directoryPath).isDirectory()) return false;
-		if (isIgnored(directoryPath)) return false;
-		return containsLuauFiles(directoryPath);
-	});
-}
-/**
-* Fast directory walk to discover instrumentable .luau/.lua files.
-* Must match parse-ast.luau's discoverFiles logic (same skip rules).
-*/
-function discoverInstrumentableFiles(luauRoot) {
-	const posixRoot = luauRoot.replaceAll("\\", "/");
-	const results = [];
-	walkLuauDirectory(posixRoot, posixRoot, isInstrumentableFile, results);
-	return new Set(results);
-}
-function prepareCoverage(config, beforeBuild) {
-	const rojoProjectPath = findRojoProject(config);
-	const luauRoots = resolveLuauRootsWithRojo(config, rojoProjectPath);
-	validateRelativeRoots(luauRoots);
-	const manifestPath = path$1.join(COVERAGE_DIR, "manifest.json");
-	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 allNonInstrumented = {};
-	const roots = [];
-	let hasChanges = !useIncremental;
-	for (const luauRoot of luauRoots) {
-		const rootResult = instrumentRootWithCache(luauRoot, useIncremental, previousManifest);
-		if (rootResult.changed) hasChanges = true;
-		Object.assign(allFiles, rootResult.files);
-		Object.assign(allNonInstrumented, rootResult.nonInstrumentedFiles);
-		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 placeFile = path$1.join(COVERAGE_DIR, "game.rbxl");
-	const manifest = writeManifest({
-		allFiles,
-		luauRoots,
-		manifestPath,
-		nonInstrumentedFiles: allNonInstrumented,
-		placeFile
-	});
-	if (!hasChanges && previousManifest?.placeFilePath !== void 0) return {
-		manifest,
-		placeFile: previousManifest.placeFilePath
-	};
-	buildRojoProject(rojoProjectPath, roots, placeFile);
-	return {
-		manifest,
-		placeFile
-	};
-}
-function containsLuauFiles(directoryPath) {
-	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;
-	});
-}
-function findRojoProject(config) {
-	if (config.rojoProject !== void 0) return config.rojoProject;
-	const defaultPath = path$1.join(config.rootDir, "default.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.");
-}
-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$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 });
-	}
-	const outDirectory = (getTsconfig(config.rootDir) ?? void 0)?.config.compilerOptions?.outDir;
-	if (outDirectory !== void 0) return [outDirectory];
-	throw new Error("Could not determine luauRoots. Set luauRoots in config or ensure tsconfig has outDir.");
-}
-/**
-* Shared directory walker. Skips node_modules, .jest-roblox-coverage, and
-* dot-prefixed directories — matching parse-ast.luau:113-147.
-* `predicate` receives the entry name and returns true to collect the file.
-*/
-function walkLuauDirectory(directory, relativeTo, predicate, results) {
-	const entries = fs$1.readdirSync(directory, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = path$1.join(directory, entry.name).replaceAll("\\", "/");
-		if (entry.isDirectory()) {
-			if (entry.name === "node_modules" || entry.name === COVERAGE_DIR) continue;
-			if (entry.name.startsWith(".")) continue;
-			walkLuauDirectory(fullPath, relativeTo, predicate, results);
-		} else if (predicate(entry.name)) {
-			const relative = fullPath.slice(relativeTo.length + 1);
-			results.push(relative);
-		}
-	}
-}
-function isInstrumentableFile(name) {
-	return (name.endsWith(".luau") || name.endsWith(".lua")) && !isNonInstrumentedFile(name);
-}
-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 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 discoverNonInstrumentedFiles(directory, relativeTo, results) {
-	walkLuauDirectory(directory, relativeTo, isNonInstrumentedFile, results);
-}
-function pruneStaleNonInstrumented(posixRoot, previousNonInstrumented, currentFiles) {
-	if (previousNonInstrumented === void 0) return false;
-	let changed = false;
-	for (const [fileKey, record] of Object.entries(previousNonInstrumented)) {
-		if (!fileKey.startsWith(`${posixRoot}/`)) continue;
-		if (fileKey in currentFiles) continue;
-		try {
-			if (fs$1.existsSync(record.shadowPath)) fs$1.unlinkSync(record.shadowPath);
-		} catch {}
-		changed = true;
-	}
-	return changed;
-}
-function syncNonInstrumentedFiles(luauRoot, shadowDirectory, previousNonInstrumented) {
-	const posixRoot = luauRoot.replaceAll("\\", "/");
-	const discovered = [];
-	discoverNonInstrumentedFiles(posixRoot, posixRoot, discovered);
-	const files = {};
-	let changed = false;
-	for (const relativePath of discovered) {
-		const sourcePath = `${posixRoot}/${relativePath}`;
-		const shadowPath = `${shadowDirectory}/${relativePath}`;
-		const currentHash = hashBuffer(fs$1.readFileSync(path$1.resolve(sourcePath)));
-		const previousRecord = previousNonInstrumented?.[sourcePath];
-		if (previousRecord?.sourceHash === currentHash) {
-			files[sourcePath] = previousRecord;
-			continue;
-		}
-		const outputDirectory = path$1.dirname(shadowPath);
-		fs$1.mkdirSync(outputDirectory, { recursive: true });
-		fs$1.copyFileSync(path$1.resolve(sourcePath), shadowPath);
-		files[sourcePath] = {
-			shadowPath,
-			sourceHash: currentHash,
-			sourcePath
-		};
-		changed = true;
-	}
-	changed = pruneStaleNonInstrumented(posixRoot, previousNonInstrumented, files) || changed;
-	return {
-		changed,
-		files
-	};
-}
-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;
-}
-/**
-* Check if all files in this root are unchanged (full cache hit).
-*
-* `changed` means previous files were deleted or modified — it does NOT cover
-* new files appearing on disk. When `allCached` is false but `changed` is also
-* false, new files exist and the caller detects them when `instrumentRoot`
-* returns non-empty results.
-*/
-function computeIncrementalState(luauRoot, previousManifest) {
-	const skipFiles = computeSkipFiles(luauRoot, previousManifest);
-	const previousCount = countPreviousFilesForRoot(luauRoot, previousManifest);
-	const changed = skipFiles.size !== previousCount;
-	if (changed) return {
-		allCached: false,
-		changed,
-		skipFiles
-	};
-	return {
-		allCached: discoverInstrumentableFiles(luauRoot).size === previousCount,
-		changed,
-		skipFiles
-	};
-}
-function buildFullCacheResult(options) {
-	const { luauRoot, previousManifest, rootEntry, shadowDirectory, skipFiles } = options;
-	const allFiles = {};
-	carryForwardRecords(luauRoot, previousManifest, allFiles, skipFiles);
-	const syncResult = syncNonInstrumentedFiles(luauRoot, shadowDirectory, previousManifest.nonInstrumentedFiles);
-	return {
-		changed: syncResult.changed,
-		files: allFiles,
-		nonInstrumentedFiles: syncResult.files,
-		rootEntry
-	};
-}
-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 });
-	}
-	const rootEntry = {
-		luauRoot,
-		relocatedShadowDirectory: path$1.relative(COVERAGE_DIR, shadowDirectory).replaceAll("\\", "/"),
-		shadowDir: shadowDirectory
-	};
-	let skipFiles;
-	if (useIncremental && previousManifest !== void 0) {
-		const { allCached, changed: hasChanges, skipFiles: computed } = computeIncrementalState(luauRoot, previousManifest);
-		skipFiles = computed;
-		changed = hasChanges;
-		if (allCached) return buildFullCacheResult({
-			luauRoot,
-			previousManifest,
-			rootEntry,
-			shadowDirectory,
-			skipFiles
-		});
-	}
-	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 syncResult = syncNonInstrumentedFiles(luauRoot, shadowDirectory, previousManifest?.nonInstrumentedFiles);
-	if (syncResult.changed) changed = true;
-	return {
-		changed,
-		files: allFiles,
-		nonInstrumentedFiles: syncResult.files,
-		rootEntry
-	};
-}
-function writeManifest(options) {
-	const { allFiles, luauRoots, manifestPath, nonInstrumentedFiles, placeFile } = options;
-	const manifest = {
-		files: allFiles,
-		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		instrumenterVersion: 2,
-		luauRoots,
-		nonInstrumentedFiles,
-		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 projectRelocation = path$1.relative(COVERAGE_DIR, path$1.dirname(rojoProjectPath)).replaceAll("\\", "/");
-	const rewritten = rewriteRojoProject({
-		...rojoProjectRaw,
-		tree: resolveNestedProjects(rojoProjectRaw.tree, path$1.dirname(rojoProjectPath))
-	}, {
-		projectRelocation,
-		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;
-	if (previousManifest.nonInstrumentedFiles === void 0) 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([
-	"clover",
-	"cobertura",
-	"html",
-	"html-spa",
-	"json",
-	"json-summary",
-	"lcov",
-	"lcovonly",
-	"none",
-	"teamcity",
-	"text",
-	"text-lcov",
-	"text-summary"
-]);
-function printCoverageHeader() {
-	const header = ` ${color.blue("%")} ${color.dim("Coverage report from")} ${color.yellow("istanbul")}`;
-	process.stdout.write(`\n${header}\n`);
-}
-const TEXT_REPORTERS = new Set(["text", "text-summary"]);
-function generateReports(options) {
-	const coverageMap = buildCoverageMap(filterMappedFiles(options.mapped, options.collectCoverageFrom));
-	const context = istanbulReport.createContext({
-		coverageMap,
-		defaultSummarizer: options.agentMode === true ? "flat" : "pkg",
-		dir: options.coverageDirectory
-	});
-	const terminalColumns = getTerminalColumns();
-	const allFilesFull = options.agentMode === true && isAllFilesFull(coverageMap);
-	for (const reporterName of options.reporters) {
-		if (!isValidReporter(reporterName)) throw new Error(`Unknown coverage reporter: ${reporterName}`);
-		if (allFilesFull && TEXT_REPORTERS.has(reporterName)) {
-			const fileCount = coverageMap.files().length;
-			const label = fileCount === 1 ? "file" : "files";
-			process.stdout.write(`Coverage: 100% (${fileCount} ${label})\n`);
-			continue;
-		}
-		let reporterOptions = {};
-		if (reporterName === "text") reporterOptions = {
-			maxCols: terminalColumns,
-			skipFull: options.agentMode === true
-		};
-		else if (TEXT_REPORTERS.has(reporterName)) reporterOptions = { skipFull: options.agentMode === true };
-		istanbulReports.create(reporterName, reporterOptions).execute(context);
-	}
-}
-function checkThresholds(mapped, thresholds, collectCoverageFrom) {
-	const summary = buildCoverageMap(filterMappedFiles(mapped, collectCoverageFrom)).getCoverageSummary();
-	const failures = [];
-	const checks = [
-		{
-			metric: "statements",
-			threshold: thresholds.statements
-		},
-		{
-			metric: "functions",
-			threshold: thresholds.functions
-		},
-		{
-			metric: "branches",
-			threshold: thresholds.branches
-		},
-		{
-			metric: "lines",
-			threshold: thresholds.lines
-		}
-	];
-	const summaryData = type({ "[string]": { pct: "number | string" } })(summary.toJSON());
-	assert(!(summaryData instanceof type.errors), "Istanbul summary produced invalid data");
-	for (const { metric, threshold } of checks) {
-		if (threshold === void 0) continue;
-		const pct = summaryData[metric]?.pct;
-		if (typeof pct !== "number") continue;
-		if (pct < threshold) failures.push({
-			actual: pct,
-			metric,
-			threshold
-		});
-	}
-	return {
-		failures,
-		passed: failures.length === 0
-	};
-}
-function getTerminalColumns() {
-	if (process.stdout.columns !== void 0) return process.stdout.columns;
-	const columnsEnvironment = process.env["COLUMNS"];
-	if (columnsEnvironment === void 0) return;
-	const parsed = Number(columnsEnvironment);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-}
-function isAllFilesFull(coverageMap) {
-	const files = coverageMap.files();
-	if (files.length === 0) return false;
-	return files.every((file) => {
-		const summary = coverageMap.fileCoverageFor(file).toSummary();
-		return summary.statements.pct === 100 && summary.branches.pct === 100 && summary.functions.pct === 100 && summary.lines.pct === 100;
-	});
-}
-function buildCoverageMap(mapped) {
-	const coverageMap = istanbulCoverage.createCoverageMap({});
-	for (const [filePath, fileCoverage] of Object.entries(mapped.files)) {
-		const fileCoverageData = {
-			b: fileCoverage.b,
-			branchMap: Object.fromEntries(Object.entries(fileCoverage.branchMap).map(([id, entry]) => {
-				return [id, {
-					line: entry.loc.start.line,
-					loc: entry.loc,
-					locations: entry.locations,
-					type: entry.type
-				}];
-			})),
-			f: fileCoverage.f,
-			fnMap: Object.fromEntries(Object.entries(fileCoverage.fnMap).map(([id, entry]) => {
-				return [id, {
-					name: entry.name,
-					decl: entry.loc,
-					line: entry.loc.start.line,
-					loc: entry.loc
-				}];
-			})),
-			path: path$1.resolve(filePath),
-			s: fileCoverage.s,
-			statementMap: fileCoverage.statementMap
-		};
-		coverageMap.addFileCoverage(fileCoverageData);
-	}
-	return coverageMap;
-}
-function createGlobMatcher(patterns) {
-	const withPath = patterns.filter((pattern) => pattern.includes("/"));
-	const withoutPath = patterns.filter((pattern) => !pattern.includes("/"));
-	const matchers = [];
-	if (withPath.length > 0) matchers.push(picomatch(withPath));
-	if (withoutPath.length > 0) matchers.push(picomatch(withoutPath, { matchBase: true }));
-	return (filePath) => matchers.some((matcher) => matcher(filePath));
-}
-function filterMappedFiles(mapped, collectCoverageFrom) {
-	if (collectCoverageFrom === void 0 || collectCoverageFrom.length === 0) return mapped;
-	const includePatterns = collectCoverageFrom.filter((pattern) => !pattern.startsWith("!"));
-	const excludePatterns = collectCoverageFrom.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
-	const isIncluded = includePatterns.length > 0 ? createGlobMatcher(includePatterns) : () => true;
-	const isExcluded = excludePatterns.length > 0 ? createGlobMatcher(excludePatterns) : () => false;
-	const cwd = process.cwd();
-	return { files: Object.fromEntries(Object.entries(mapped.files).filter(([filePath]) => {
-		const relativePath = path$1.isAbsolute(filePath) ? path$1.relative(cwd, filePath).replaceAll("\\", "/") : filePath;
-		return isIncluded(relativePath) && !isExcluded(relativePath);
-	})) };
-}
-function isValidReporter(name) {
-	return VALID_REPORTERS.has(name);
-}
-//#endregion
-//#region src/utils/glob.ts
-function globSync(pattern, options = {}) {
-	const cwd = options.cwd ?? process.cwd();
-	return walkDirectory(cwd, cwd).filter((file) => matchesGlobPattern(file, pattern));
-}
-function matchesGlobPattern(filePath, pattern) {
-	const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*\//g, "{{DOUBLESTAR_SLASH}}").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLESTAR_SLASH\}\}/g, "(.+/)?");
-	return new RegExp(`^${regexPattern}$`).test(filePath);
-}
-function walkDirectory(directoryPath, baseDirectory) {
-	const results = [];
-	try {
-		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, "/");
-			if (entry.isDirectory()) {
-				if (!entry.name.startsWith(".") && entry.name !== "node_modules") results.push(...walkDirectory(fullPath, baseDirectory));
-			} else results.push(relativePath);
-		}
-	} 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...]
 
@@ -2225,8 +51,12 @@ Options:
   --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)
+  --workspace                       Run tests across all workspace packages
+  --packages <names>                Comma-separated package names (workspace mode)
+  --workspace-root <path>           Directory to load the workspace config from
+                                    (use when running outside any package)
+  --affected-since <ref>            Run only packages affected since git ref via turbo/nx
+  --no-coverage-cache               Force a clean coverage re-instrumentation (skip incremental cache)
   --parallel [n]                    Open-Cloud-only: number of concurrent sessions
                                     (or "auto" = min(jobs, 3); default: 1 session)
   --project <name...>               Filter which named projects to run
@@ -2236,13 +66,22 @@ Options:
   --typecheck                       Enable type testing (*.test-d.ts, *.spec-d.ts)
   --typecheckOnly                   Run only type tests, skip runtime tests
   --typecheckTsconfig <path>        tsconfig for type testing
+  --apiKey <key>                    Roblox Open Cloud API key
+  --universeId <id>                 Target universe ID
+  --placeId <id>                    Target place ID
   --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
-  ROBLOX_UNIVERSE_ID         Target universe ID
-  ROBLOX_PLACE_ID            Target place ID
+Open Cloud credentials (open-cloud backend only):
+  Sources, in precedence order:
+    1. CLI flags (--apiKey, --universeId, --placeId)
+    2. JEST_ROBLOX_* env vars (JEST_ROBLOX_OPEN_CLOUD_API_KEY,
+       JEST_ROBLOX_UNIVERSE_ID, JEST_ROBLOX_PLACE_ID)
+    3. ROBLOX_* env vars (ROBLOX_OPEN_CLOUD_API_KEY, ROBLOX_UNIVERSE_ID,
+       ROBLOX_PLACE_ID)
+    4. jest.config.ts (universeId, placeId — apiKey is CLI/env only)
+
+  --apiKey is visible in process listings; prefer env vars in CI.
 
 Examples:
   jest-roblox                         Run all tests (open-cloud)
@@ -2257,8 +96,9 @@ function parseArgs(args) {
 		allowPositionals: true,
 		args: normalizeParallelFlag(args),
 		options: {
+			"affected-since": { type: "string" },
+			"apiKey": { type: "string" },
 			"backend": { type: "string" },
-			"cache": { type: "boolean" },
 			"collectCoverageFrom": {
 				multiple: true,
 				type: "string"
@@ -2266,6 +106,7 @@ function parseArgs(args) {
 			"color": { type: "boolean" },
 			"config": { type: "string" },
 			"coverage": { type: "boolean" },
+			"coverage-cache": { type: "boolean" },
 			"coverageDirectory": { type: "string" },
 			"coverageReporters": {
 				multiple: true,
@@ -2280,13 +121,14 @@ function parseArgs(args) {
 				default: false,
 				type: "boolean"
 			},
-			"no-cache": { type: "boolean" },
 			"no-color": { type: "boolean" },
+			"no-coverage-cache": { type: "boolean" },
 			"no-show-luau": { type: "boolean" },
 			"outputFile": { type: "string" },
+			"packages": { type: "string" },
 			"parallel": { type: "string" },
 			"passWithNoTests": { type: "boolean" },
-			"pollInterval": { type: "string" },
+			"placeId": { type: "string" },
 			"port": { type: "string" },
 			"project": {
 				multiple: true,
@@ -2313,6 +155,7 @@ function parseArgs(args) {
 			"typecheck": { type: "boolean" },
 			"typecheckOnly": { type: "boolean" },
 			"typecheckTsconfig": { type: "string" },
+			"universeId": { type: "string" },
 			"updateSnapshot": {
 				short: "u",
 				type: "boolean"
@@ -2321,20 +164,23 @@ function parseArgs(args) {
 			"version": {
 				default: false,
 				type: "boolean"
-			}
+			},
+			"workspace": { type: "boolean" },
+			"workspace-root": { type: "string" }
 		},
 		strict: true
 	});
-	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;
 	return {
+		affectedSince: values["affected-since"],
+		apiKey: values.apiKey,
 		backend: validateBackend(values.backend),
-		cache: values["no-cache"] === true ? false : values.cache,
 		collectCoverage: values.coverage,
 		collectCoverageFrom: values.collectCoverageFrom,
 		color: values["no-color"] === true ? false : values.color,
 		config: values.config,
+		coverageCache: values["no-coverage-cache"] === true ? false : values["coverage-cache"],
 		coverageDirectory: values.coverageDirectory,
 		coverageReporters: values.coverageReporters,
 		files: positionals.length > 0 ? positionals : void 0,
@@ -2342,9 +188,10 @@ function parseArgs(args) {
 		gameOutput: values.gameOutput,
 		help: values.help,
 		outputFile: values.outputFile,
+		packages: values.packages,
 		parallel: parseParallelValue(values.parallel),
 		passWithNoTests: values.passWithNoTests,
-		pollInterval,
+		placeId: values.placeId,
 		port,
 		project: values.project,
 		rojoProject: values.rojoProject,
@@ -2359,77 +206,12 @@ function parseArgs(args) {
 		typecheck: values.typecheckOnly === true ? true : values.typecheck,
 		typecheckOnly: values.typecheckOnly,
 		typecheckTsconfig: values.typecheckTsconfig,
+		universeId: values.universeId,
 		updateSnapshot: values.updateSnapshot,
 		verbose: values.verbose,
-		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 testsMs = 0;
-	let setupMs = 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);
-		testsMs += result.timing.testsMs;
-		setupMs += result.timing.setupMs ?? 0;
-		if (result.coverageData !== void 0) mergedCoverage = mergeRawCoverage(mergedCoverage, result.coverageData);
-	}
-	const [sharedTiming] = results;
-	const mergedStartTime = Math.min(...results.map((result) => result.timing.startTime));
-	const totalMs = Math.max(...results.map((result) => result.timing.totalMs));
-	const mergedSourceMapper = combineSourceMappers(results.flatMap((result) => result.sourceMapper !== void 0 ? [result.sourceMapper] : []));
-	return {
-		coverageData: mergedCoverage,
-		exitCode: success ? 0 : 1,
-		output: "",
-		result: {
-			numFailedTests: numberFailedTests,
-			numPassedTests: numberPassedTests,
-			numPendingTests: numberPendingTests,
-			numTodoTests: numberTodoTests,
-			numTotalTests: numberTotalTests,
-			startTime,
-			success,
-			testResults
-		},
-		sourceMapper: mergedSourceMapper,
-		timing: {
-			coverageMs: sharedTiming.timing.coverageMs,
-			executionMs: sharedTiming.timing.executionMs,
-			setupMs: setupMs > 0 ? setupMs : void 0,
-			startTime: mergedStartTime,
-			testsMs,
-			totalMs,
-			uploadCached: sharedTiming.timing.uploadCached,
-			uploadMs: sharedTiming.timing.uploadMs
-		}
+		version: values.version,
+		workspace: values.workspace,
+		workspaceRoot: values["workspace-root"]
 	};
 }
 async function run(args) {
@@ -2443,12 +225,6 @@ async function run(args) {
 async function main() {
 	process.exitCode = await run(process.argv.slice(2));
 }
-/**
-* `--parallel` with no value means `"auto"`. Node's `parseArgs` can't express
-* optional values, so rewrite bare `--parallel` (at the end of argv, or
-* followed by another `--flag`, or followed by a non-numeric, non-"auto" token)
-* into `--parallel auto` before handing it off.
-*/
 const PARALLEL_FLAG = "--parallel";
 function normalizeParallelFlag(args) {
 	const out = [];
@@ -2479,6 +255,46 @@ function formatGameOutputLines(raw) {
 	if (entries.length === 0) return;
 	return entries.map((entry) => entry.message.replace(/^/gm, "  ")).join("\n");
 }
+const EXIT_CODE_MESSAGE = /^Exited with code: \d+$/;
+function formatLuauErrorBanner(err) {
+	const bannerLines = formatGameOutputLines(err.bannerOutput);
+	if (EXIT_CODE_MESSAGE.test(err.message) && bannerLines !== void 0) return formatBanner({
+		body: [bannerLines, `\n  ${color.dim(err.message)}`],
+		level: "error",
+		title: "Test Run Failed"
+	});
+	const body = [color.red(err.message)];
+	const hint = getLuauErrorHint(err.message);
+	if (hint !== void 0) body.push(`\n  ${color.dim("Hint:")} ${hint}`);
+	if (bannerLines !== void 0) body.push(`\n  ${color.dim("Game output:")}\n${bannerLines}`);
+	return formatBanner({
+		body,
+		level: "error",
+		title: "Luau Error"
+	});
+}
+function formatChainExtras(entry) {
+	const pieces = [];
+	if (entry.code !== void 0) pieces.push(`code=${entry.code}`);
+	if (entry.errno !== void 0) pieces.push(`errno=${entry.errno}`);
+	if (entry.syscall !== void 0) pieces.push(`syscall=${entry.syscall}`);
+	return pieces.length > 0 ? color.dim(` (${pieces.join(" ")})`) : "";
+}
+function formatBackendErrorBanner(err) {
+	const body = [color.red(err.message)];
+	const chain = walkErrorChain(err.cause);
+	body.push(`\n  ${color.dim("Caused by:")}`);
+	for (const [index, entry] of chain.entries()) {
+		const extras = formatChainExtras(entry);
+		const label = color.dim(`[${index.toString()}]`);
+		body.push(`    ${label} ${entry.name}: ${entry.message}${extras}`);
+	}
+	return formatBanner({
+		body,
+		level: "error",
+		title: "Backend Error"
+	});
+}
 function printError(err) {
 	if (err instanceof ConfigError) {
 		const body = [color.red(err.message)];
@@ -2488,452 +304,22 @@ function printError(err) {
 			level: "error",
 			title: "Config Error"
 		}));
-	} else if (err instanceof LuauScriptError) {
-		const body = [color.red(err.message)];
-		const hint = getLuauErrorHint(err.message);
-		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 if (err instanceof LuauScriptError) process.stderr.write(formatLuauErrorBanner(err));
+	else if (err instanceof Error && err.cause instanceof OpenCloudError) process.stderr.write(formatBackendErrorBanner(err));
+	else if (err instanceof Error) console.error(`Error: ${err.message}`);
 	else console.error("An unknown error occurred");
 }
-function writeGameOutputIfConfigured(config, gameOutput, options) {
-	if (config.gameOutput === void 0) return;
-	const entries = parseGameOutput(gameOutput);
-	writeGameOutput(config.gameOutput, entries);
-	if (!config.silent && options.hintsShown !== true) {
-		const notice = formatGameOutputNotice(config.gameOutput, entries.length);
-		if (notice) console.error(notice);
-	}
-}
-/**
-* Multi-project variant: `--gameOutput` used to silently drop when a config
-* declared `projects`, because the output path here never called
-* `writeGameOutputIfConfigured`. Aggregate every project's parsed entries into
-* one file so the contract matches the single-project path.
-*/
-function writeAggregatedGameOutput(config, projectResults, options) {
-	if (config.gameOutput === void 0) return;
-	const entries = projectResults.flatMap((project) => parseGameOutput(project.result.gameOutput));
-	writeGameOutput(config.gameOutput, entries);
-	if (!config.silent && options.hintsShown !== true) {
-		const notice = formatGameOutputNotice(config.gameOutput, entries.length);
-		if (notice) console.error(notice);
-	}
-}
-function printFinalStatus(passed) {
-	const badge = passed ? color.bgGreen(color.black(color.bold(" PASS "))) : color.bgRed(color.white(color.bold(" FAIL ")));
-	process.stdout.write(`${badge}\n`);
-}
-function hasFormatter(config, name) {
-	return config.formatters?.some((entry) => Array.isArray(entry) ? entry[0] === name : entry === name) === true;
-}
-function usesAgentFormatter(config) {
-	return hasFormatter(config, "agent") && !config.verbose;
-}
-function processCoverage(config, coverageData) {
-	if (!config.collectCoverage) return true;
-	if (coverageData === void 0) {
-		if (!config.silent) process.stderr.write("Warning: coverage data was empty — the Rojo project may point at uninstrumented source\n");
-		return true;
-	}
-	const manifest = loadCoverageManifest(config.rootDir);
-	if (manifest === void 0) {
-		if (!config.silent) process.stderr.write("Warning: Coverage manifest not found, skipping TS mapping\n");
-		return true;
-	}
-	const mapped = mapCoverageToTypeScript(coverageData, manifest);
-	const coverageDirectory = path$1.resolve(config.rootDir, config.coverageDirectory);
-	if (!config.silent) printCoverageHeader();
-	generateReports({
-		agentMode: usesAgentFormatter(config),
-		collectCoverageFrom: config.collectCoverageFrom,
-		coverageDirectory,
-		mapped,
-		reporters: config.coverageReporters
-	});
-	if (config.coverageThreshold !== void 0) {
-		const result = checkThresholds(mapped, config.coverageThreshold, config.collectCoverageFrom);
-		if (!result.passed) {
-			for (const failure of result.failures) process.stderr.write(`Coverage threshold not met for ${failure.metric}: ${String(failure.actual.toFixed(2))}% < ${String(failure.threshold)}%\n`);
-			return false;
-		}
-	}
-	return true;
-}
-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;
-	const options = resolveGitHubActionsOptions(typedOptions, sourceMapper);
-	if (typedOptions.displayAnnotations !== false) {
-		const annotations = formatAnnotations(result, options);
-		if (annotations !== "") process.stderr.write(`${annotations}\n`);
-	}
-	const { jobSummary } = typedOptions;
-	if (jobSummary?.enabled !== false) {
-		const outputPath = jobSummary?.outputPath ?? process.env["GITHUB_STEP_SUMMARY"];
-		if (outputPath !== void 0) {
-			const summary = formatJobSummary(result, options);
-			fs$1.appendFileSync(outputPath, summary);
-		}
-	}
-}
-function getAgentMaxFailures(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 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));
-}
-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 (!config.silent) printFormattedOutput({
-		config,
-		mergedResult,
-		runtimeResult,
-		timing: runtimeResult !== void 0 ? addCoverageTiming(runtimeResult.timing, preCoverageMs) : void 0,
-		typecheckResult
-	});
-	const coveragePassed = processCoverage(config, runtimeResult?.coverageData);
-	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);
-	const passed = mergedResult.success && coveragePassed;
-	if (!config.silent && config.collectCoverage) printFinalStatus(passed);
-	return passed ? 0 : 1;
-}
-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(formatAgentMultiProject(toProjectEntries(projectResults), {
-			gameOutput: config.gameOutput,
-			maxFailures: getAgentMaxFailures(config),
-			outputFile: config.outputFile,
-			rootDir: config.rootDir,
-			sourceMapper: merged.sourceMapper,
-			typeErrorCount: typecheckResult?.numFailedTests
-		}));
-		return;
-	}
-	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);
-	writeAggregatedGameOutput(config, projectResults, { hintsShown: !mergedResult.success });
-	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 resolveNestedProjects(validated.tree, path$1.dirname(rojoPath));
-}
-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) {
-		assertStubCollisionRule(project, rootDirectory);
-		const stubConfig = {
-			...buildStubConfig(project.config),
-			displayName: project.displayName,
-			include: [],
-			testMatch: project.testMatch
-		};
-		for (const mount of project.rojoMounts) {
-			const outputPath = path$1.resolve(rootDirectory, mount.fsPath, "jest.config.lua");
-			entries.push({
-				config: stubConfig,
-				outputPath
-			});
-		}
-	}
-	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);
-}
-/**
-* Drop `parallel` on any non-open-cloud backend. Studio has no concept of
-* multi-session, so passing `parallel` there is a silent noop — this lets
-* users keep `parallel: 3` in `jest.config.ts` and still drop to
-* `--backend studio` for debugging without editing config.
-*/
-function effectiveParallelForBackend(parallel, backend) {
-	return backend.kind === "open-cloud" ? parallel : void 0;
-}
-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 parallel = effectiveParallelForBackend(effectiveConfig.parallel, backend);
-	const pendingJobs = [];
-	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) continue;
-		pendingJobs.push({
-			config: projConfig,
-			displayColor: project.displayColor,
-			displayName: project.displayName,
-			runtimeFiles
-		});
+async function dispatchResult(config, result) {
+	if (result.validationExitCode !== void 0) {
+		if ("validationMessage" in result && result.validationMessage !== void 0) process.stderr.write(result.validationMessage);
+		return result.validationExitCode;
 	}
-	const jobs = pendingJobs.map((pending) => {
-		return buildProjectJob({
-			config: pending.config,
-			displayColor: pending.displayColor,
-			displayName: pending.displayName,
-			testFiles: pending.runtimeFiles
-		});
-	});
-	const projectResults = [];
-	if (jobs.length > 0) {
-		const startTime = Date.now();
-		let backendResult;
-		try {
-			backendResult = await executeBackend(backend, jobs, parallel);
-		} finally {
-			await backend.close?.();
-		}
-		const sharedTiming = backendResult.timing;
-		for (const [index, entry] of backendResult.results.entries()) {
-			const pending = pendingJobs[index];
-			const jobConfig = jobs[index].config;
-			const executeResult = processProjectResult(entry, {
-				backendTiming: sharedTiming,
-				config: jobConfig,
-				deferFormatting: true,
-				startTime,
-				version: VERSION
-			});
-			projectResults.push({
-				displayColor: pending.displayColor,
-				displayName: pending.displayName,
-				result: executeResult
-			});
-		}
-	}
-	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) {
-		if (rootConfig.passWithNoTests) return 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,
-		collectCoverageFrom: rootConfig.collectCoverageFrom ?? deriveCoverageFromIncludes(projects)
-	}, 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`);
-	const backend = await resolveBackend(config);
-	try {
-		return await execute({
-			backend,
-			config,
-			deferFormatting: true,
-			testFiles,
-			version: VERSION
-		});
-	} finally {
-		await backend.close?.();
-	}
-}
-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(cli, config) {
-	resolveSetupFilePaths(config);
-	const discovery = discoverTestFiles(config, cli.files);
-	if (discovery.files.length === 0) {
-		if (config.passWithNoTests) return 0;
-		console.error("No test files found");
-		return 2;
-	}
-	const typeTestFiles = config.typecheck ? discovery.files.filter((file) => TYPE_TEST_PATTERN.test(file)) : [];
-	const runtimeTestFiles = config.typecheckOnly ? [] : discovery.files.filter((file) => !TYPE_TEST_PATTERN.test(file));
-	if (typeTestFiles.length === 0 && runtimeTestFiles.length === 0) {
-		if (config.passWithNoTests) return 0;
-		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);
-		preCoverageMs = Date.now() - preCoverageStart;
-		effectiveConfig = {
-			...config,
-			placeFile
-		};
+	if (result.mode === "single") {
+		if (result.runtimeResult === void 0 && result.typecheckResult === void 0) return 0;
+		return outputSingleResult(config, result);
 	}
-	const typecheckResult = typeTestFiles.length > 0 ? runTypecheck({
-		files: typeTestFiles,
-		rootDir: effectiveConfig.rootDir,
-		tsconfig: effectiveConfig.typecheckTsconfig
-	}) : void 0;
-	const runtimeResult = runtimeTestFiles.length > 0 ? await executeRuntimeTests(effectiveConfig, runtimeTestFiles, discovery.totalFiles) : void 0;
-	return outputResults(effectiveConfig, typecheckResult, runtimeResult, preCoverageMs);
+	if (result.projectResults.length === 0 && result.typecheckResult === void 0) return 0;
+	return outputMultiResult(config, result);
 }
 async function runInner(args) {
 	const cli = parseArgs(args);
@@ -2946,47 +332,17 @@ async function runInner(args) {
 		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(cli, config);
+	const config = mergeCliWithConfig(cli, await loadConfig(cli.config, cli.workspaceRoot));
+	return dispatchResult(config, await runJestRoblox(cli, config));
 }
 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\""],
 	[/Failed to find Jest instance at path/, "The configured jestPath does not resolve to a valid instance. Verify the path matches your Rojo project tree."],
 	[/Failed to find service/, "The first segment of jestPath must be a valid Roblox service name (e.g. ReplicatedStorage, ServerScriptService)."],
-	[/No projects configured/, "Set \"projects\" in jest.config.ts (e.g. [\"ReplicatedStorage/client\", \"ServerScriptService/server\"]) or pass --projects."],
+	[/No projects configured/, "Set \"projects\" in jest.config.ts (e.g. [\"ReplicatedStorage/client\", \"ServerScriptService/server\"])."],
 	[/Infinite yield detected/, "A :WaitForChild() call is waiting for an instance that doesn't exist. Check your DataModel paths and Rojo project configuration."],
 	[/loadstring\(\) is not available/, "loadstring() must be enabled for Jest to run. Add \"LoadStringEnabled\": true to ServerScriptService.$properties in your project.json."]
 ];
-function discoverTestFiles(config, cliFiles) {
-	if (cliFiles && cliFiles.length > 0) {
-		const files = cliFiles.map((file) => path$1.resolve(config.rootDir, file));
-		return {
-			files,
-			totalFiles: files.length
-		};
-	}
-	const allFiles = [];
-	for (const pattern of config.testMatch) {
-		const matches = globSync(pattern, { cwd: config.rootDir });
-		allFiles.push(...matches);
-	}
-	const ignoredPatterns = config.testPathIgnorePatterns.map((pat) => new RegExp(pat));
-	const baseFiles = allFiles.filter((file) => {
-		return !ignoredPatterns.some((pattern) => pattern.test(file));
-	});
-	const totalFiles = new Set(baseFiles).size;
-	let filtered = baseFiles;
-	if (config.testPathPattern !== void 0) {
-		const pathPattern = new RegExp(config.testPathPattern);
-		filtered = filtered.filter((file) => pathPattern.test(file));
-	}
-	return {
-		files: [...new Set(filtered)],
-		totalFiles
-	};
-}
 function validateBackend(value) {
 	if (value === void 0) return;
 	if (!isValidBackend(value)) {
@@ -2998,60 +354,5 @@ function validateBackend(value) {
 function getLuauErrorHint(message) {
 	for (const [pattern, hint] of LUAU_ERROR_HINTS) if (pattern.test(message)) return hint;
 }
-function resolveFormatters(cli, config) {
-	const explicit = cli.formatters ?? config.formatters;
-	if (explicit !== void 0) return explicit;
-	const defaults = isAgent ? ["agent"] : ["default"];
-	if (process.env["GITHUB_ACTIONS"] === "true") defaults.push("github-actions");
-	return defaults;
-}
-function mergeCliWithConfig(cli, config) {
-	return {
-		...config,
-		backend: cli.backend ?? config.backend,
-		cache: cli.cache ?? config.cache,
-		collectCoverage: cli.collectCoverage ?? config.collectCoverage,
-		collectCoverageFrom: cli.collectCoverageFrom ?? config.collectCoverageFrom,
-		color: cli.color ?? config.color,
-		coverageDirectory: cli.coverageDirectory ?? config.coverageDirectory,
-		coverageReporters: cli.coverageReporters ?? config.coverageReporters,
-		formatters: resolveFormatters(cli, config),
-		gameOutput: cli.gameOutput ?? config.gameOutput,
-		outputFile: cli.outputFile ?? config.outputFile,
-		parallel: cli.parallel ?? config.parallel,
-		passWithNoTests: cli.passWithNoTests ?? config.passWithNoTests,
-		pollInterval: cli.pollInterval ?? config.pollInterval,
-		port: cli.port ?? config.port,
-		rojoProject: cli.rojoProject ?? config.rojoProject,
-		setupFiles: cli.setupFiles ?? config.setupFiles,
-		setupFilesAfterEnv: cli.setupFilesAfterEnv ?? config.setupFilesAfterEnv,
-		showLuau: cli.showLuau ?? config.showLuau,
-		silent: cli.silent ?? config.silent,
-		sourceMap: cli.sourceMap ?? config.sourceMap,
-		testNamePattern: cli.testNamePattern ?? config.testNamePattern,
-		testPathPattern: cli.testPathPattern ?? config.testPathPattern,
-		timeout: cli.timeout ?? config.timeout,
-		typecheck: cli.typecheck ?? config.typecheck,
-		typecheckOnly: cli.typecheckOnly ?? config.typecheckOnly,
-		typecheckTsconfig: cli.typecheckTsconfig ?? config.typecheckTsconfig,
-		updateSnapshot: cli.updateSnapshot ?? config.updateSnapshot,
-		verbose: cli.verbose ?? config.verbose
-	};
-}
-function mergeResults(typecheck, runtime) {
-	if (typecheck !== void 0 && runtime !== void 0) return {
-		numFailedTests: typecheck.numFailedTests + runtime.numFailedTests,
-		numPassedTests: typecheck.numPassedTests + runtime.numPassedTests,
-		numPendingTests: typecheck.numPendingTests + runtime.numPendingTests,
-		numTodoTests: (typecheck.numTodoTests ?? 0) + (runtime.numTodoTests ?? 0),
-		numTotalTests: typecheck.numTotalTests + runtime.numTotalTests,
-		startTime: Math.min(typecheck.startTime, runtime.startTime),
-		success: typecheck.success && runtime.success,
-		testResults: [...typecheck.testResults, ...runtime.testResults]
-	};
-	const result = typecheck ?? runtime;
-	assert(result !== void 0, "mergeResults requires at least one result");
-	return result;
-}
 //#endregion
-export { filterByName, main, mergeProjectResults, parseArgs, run };
+export { main, parseArgs, run };