@isentinel/jest-roblox 0.2.0 → 0.2.2

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { A as createOpenCloudBackend, B as LuauScriptError, C as formatTypecheckSummary, F as ROOT_ONLY_KEYS, I as VALID_BACKENDS, O as createStudioBackend, T as loadConfig$1, _ as writeJsonFile, a as formatAnnotations, b as formatMultiProjectResult, c as execute, d as resolveTsconfigDirectories, f as collectPaths, h as findFormatterOptions, i as runTypecheck, j as hashBuffer, l as formatExecuteOutput, m as rojoProjectSchema, n as parseGameOutput, o as formatJobSummary, p as resolveNestedProjects, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, u as loadCoverageManifest, v as formatAgentMultiProject, w as formatBanner, x as formatResult, z as isValidBackend } from "./game-output-C0KykXIi.mjs";
+import { A as formatBanner, C as writeJsonFile, D as formatResult, E as formatMultiProjectResult, F as createStudioBackend, G as isValidBackend, H as VALID_BACKENDS, K as LuauScriptError, L as createOpenCloudBackend, M as loadConfig$1, V as ROOT_ONLY_KEYS, _ as resolveTsconfigDirectories, a as formatAnnotations, b as rojoProjectSchema, c as visitBlock, d as buildProjectJob, f as execute, g as processProjectResult, h as loadCoverageManifest, i as runTypecheck, j as combineSourceMappers, k as formatTypecheckSummary, m as formatExecuteOutput, n as parseGameOutput, o as formatJobSummary, p as executeBackend, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, v as collectPaths$1, w as formatAgentMultiProject, x as findFormatterOptions, y as resolveNestedProjects } from "./game-output-CwmtpYhn.mjs";
 import { createRequire } from "node:module";
 import { type } from "arktype";
 import assert from "node:assert";
@@ -11,26 +11,32 @@ import { parseArgs as parseArgs$1 } from "node:util";
 import { isAgent } from "std-env";
 import color from "tinyrainbow";
 import { WebSocketServer } from "ws";
+import { hashBuffer as hashBuffer$1 } from "@isentinel/roblox-runner";
 import { loadConfig } from "c12";
-import * as os from "node:os";
-import { Buffer } from "node:buffer";
+import { collectPaths, findInTree } from "@isentinel/rojo-utils";
 import { getTsconfig } from "get-tsconfig";
 import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import * as cp from "node:child_process";
+import * as os from "node:os";
 import { RojoResolver } from "@roblox-ts/rojo-resolver";
+import { Buffer } from "node:buffer";
 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.0";
+var version = "0.2.2";
 //#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);
@@ -156,7 +162,7 @@ function evalTable(entries) {
 }
 //#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\nlocal files: { string } = {}\ndiscoverFiles(luauRoot, luauRoot, files)\n\n-- Parse, strip, and write per-file AST JSON\nfor _, relativePath in files do\n	local fullPath = luauRoot .. \"/\" .. relativePath\n	local source = fs.readfiletostring(fullPath)\n	local parseResult = syntax.parse(source)\n	local stripped = strip(parseResult.root)\n\n	local outPath = outputDir .. \"/\" .. relativePath .. \".json\"\n	local dir = dirname(outPath)\n	if dir ~= \"\" then\n		fs.createdirectory(dir, { makeparents = true })\n	end\n\n	fs.writestringtofile(outPath, json.serialize(stripped))\nend\n\n-- Print file list to stdout (tiny — just paths)\nprint(json.serialize(files :: json.array))\n";
+var parse_ast_default = "local fs = require(\"@std/fs\")\nlocal json = require(\"@std/json\")\nlocal process = require(\"@std/process\")\nlocal syntax = require(\"@std/syntax\")\n\nlocal rawArgs = process.args\nlocal userArgs: { string } = {}\nlocal pastSeparator = false\n\nfor _, arg in rawArgs do\n	if pastSeparator then\n		table.insert(userArgs, arg)\n	elseif arg == \"--\" then\n		pastSeparator = true\n	end\nend\n\nlocal luauRoot = userArgs[1]\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;
@@ -400,24 +406,6 @@ function buildProjectConfigFromLuau(luauConfigPath, directoryPath) {
 	copyLuauOptionalFields(raw, config);
 	return config;
 }
-function matchNodePath(childNode, targetPath, childDataModelPath) {
-	const nodePath = childNode.$path;
-	if (typeof nodePath !== "string") return;
-	const normalizedNodePath = nodePath.replace(/\/$/, "");
-	if (normalizedNodePath === targetPath) return childDataModelPath;
-	if (targetPath.startsWith(`${normalizedNodePath}/`)) return `${childDataModelPath}/${targetPath.slice(normalizedNodePath.length + 1)}`;
-}
-function findInTree(node, targetPath, currentDataModelPath) {
-	for (const [key, value] of Object.entries(node)) {
-		if (key.startsWith("$") || typeof value !== "object") continue;
-		const childNode = value;
-		const childDataModelPath = currentDataModelPath === "" ? key : `${currentDataModelPath}/${key}`;
-		const pathMatch = matchNodePath(childNode, targetPath, childDataModelPath);
-		if (pathMatch !== void 0) return pathMatch;
-		const found = findInTree(childNode, targetPath, childDataModelPath);
-		if (found !== void 0) return found;
-	}
-}
 //#endregion
 //#region src/config/setup-resolver.ts
 const PROBE_EXTENSIONS = [
@@ -552,22 +540,39 @@ function findShadowStubs(directory) {
 * Derives `collectCoverageFrom` glob patterns from project `include` patterns.
 *
 * Extracts the static root directory from each include pattern and generates
-* coverage globs that match all `.ts` source files within those roots, excluding
-* test files. Returns `undefined` when no roots can be extracted (preserving
-* default all-files behavior).
+* 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 roots = /* @__PURE__ */ new Set();
-	for (const project of projects) for (const pattern of project.include) try {
-		const { root } = extractStaticRoot(pattern);
-		roots.add(root);
-	} catch {}
-	if (roots.size === 0) return;
+	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 root of roots) patterns.push(`${root}/**/*.ts`);
-	patterns.push("!**/*.spec.ts", "!**/*.test.ts");
+	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({
@@ -1027,276 +1032,6 @@ function mergeFileCoverage(a, b) {
 	return merged;
 }
 //#endregion
-//#region src/luau/visitor.ts
-function visitExpression(expression, visitor) {
-	if (visitor.visitExpr?.(expression) === false) return;
-	const { tag } = expression;
-	switch (tag) {
-		case "binary":
-			visitExprBinary(expression, visitor);
-			break;
-		case "boolean":
-			visitor.visitExprConstantBool?.(expression);
-			break;
-		case "call":
-			visitExprCall(expression, visitor);
-			break;
-		case "cast":
-			visitExprTypeAssertion(expression, visitor);
-			break;
-		case "conditional":
-			visitExprIfElse(expression, visitor);
-			break;
-		case "function":
-			visitExprFunction(expression, visitor);
-			break;
-		case "global":
-			visitor.visitExprGlobal?.(expression);
-			break;
-		case "group":
-			visitExprGroup(expression, visitor);
-			break;
-		case "index":
-			visitExprIndexExpr(expression, visitor);
-			break;
-		case "indexname":
-			visitExprIndexName(expression, visitor);
-			break;
-		case "instantiate":
-			visitExprInstantiate(expression, visitor);
-			break;
-		case "interpolatedstring":
-			visitExprInterpString(expression, visitor);
-			break;
-		case "local":
-			visitor.visitExprLocal?.(expression);
-			break;
-		case "nil":
-			visitor.visitExprConstantNil?.(expression);
-			break;
-		case "number":
-			visitor.visitExprConstantNumber?.(expression);
-			break;
-		case "string":
-			visitor.visitExprConstantString?.(expression);
-			break;
-		case "table":
-			visitExprTable(expression, visitor);
-			break;
-		case "unary":
-			visitExprUnary(expression, visitor);
-			break;
-		case "vararg":
-			visitor.visitExprVarargs?.(expression);
-			break;
-		default: break;
-	}
-	visitor.visitExprEnd?.(expression);
-}
-function visitStatement(statement, visitor) {
-	const { tag } = statement;
-	switch (tag) {
-		case "assign":
-			visitStatAssign(statement, visitor);
-			break;
-		case "block":
-			visitStatBlock(statement, visitor);
-			break;
-		case "break":
-			visitor.visitStatBreak?.(statement);
-			break;
-		case "compoundassign":
-			visitStatCompoundAssign(statement, visitor);
-			break;
-		case "conditional":
-			visitStatIf(statement, visitor);
-			break;
-		case "continue":
-			visitor.visitStatContinue?.(statement);
-			break;
-		case "do":
-			visitStatDo(statement, visitor);
-			break;
-		case "expression":
-			visitStatExpr(statement, visitor);
-			break;
-		case "for":
-			visitStatFor(statement, visitor);
-			break;
-		case "forin":
-			visitStatForIn(statement, visitor);
-			break;
-		case "function":
-			visitStatFunction(statement, visitor);
-			break;
-		case "local":
-			visitStatLocal(statement, visitor);
-			break;
-		case "localfunction":
-			visitStatLocalFunction(statement, visitor);
-			break;
-		case "repeat":
-			visitStatRepeat(statement, visitor);
-			break;
-		case "return":
-			visitStatReturn(statement, visitor);
-			break;
-		case "typealias":
-			visitor.visitStatTypeAlias?.(statement);
-			break;
-		case "typefunction":
-			visitor.visitStatTypeFunction?.(statement);
-			break;
-		case "while":
-			visitStatWhile(statement, visitor);
-			break;
-		default: break;
-	}
-}
-function visitBlock(block, visitor) {
-	visitStatBlock(block, visitor);
-}
-function visitPunctuated(list, visitor, apply) {
-	for (const item of list) apply(item.node, visitor);
-}
-function visitStatBlock(block, visitor) {
-	if (visitor.visitStatBlock?.(block) === false) return;
-	for (const statement of block.statements) visitStatement(statement, visitor);
-	visitor.visitStatBlockEnd?.(block);
-}
-function visitStatDo(node, visitor) {
-	if (visitor.visitStatDo?.(node) === false) return;
-	visitStatBlock(node.body, visitor);
-}
-function visitStatIf(node, visitor) {
-	if (visitor.visitStatIf?.(node) === false) return;
-	visitExpression(node.condition, visitor);
-	visitStatBlock(node.thenblock, visitor);
-	for (const elseif of node.elseifs) visitElseIfStat(elseif, visitor);
-	if (node.elseblock) visitStatBlock(node.elseblock, visitor);
-}
-function visitElseIfStat(node, visitor) {
-	visitExpression(node.condition, visitor);
-	visitStatBlock(node.thenblock, visitor);
-}
-function visitStatWhile(node, visitor) {
-	if (visitor.visitStatWhile?.(node) === false) return;
-	visitExpression(node.condition, visitor);
-	visitStatBlock(node.body, visitor);
-}
-function visitStatRepeat(node, visitor) {
-	if (visitor.visitStatRepeat?.(node) === false) return;
-	visitStatBlock(node.body, visitor);
-	visitExpression(node.condition, visitor);
-}
-function visitStatReturn(node, visitor) {
-	if (visitor.visitStatReturn?.(node) === false) return;
-	visitPunctuated(node.expressions, visitor, visitExpression);
-}
-function visitStatLocal(node, visitor) {
-	if (visitor.visitStatLocal?.(node) === false) return;
-	visitPunctuated(node.values, visitor, visitExpression);
-}
-function visitStatFor(node, visitor) {
-	if (visitor.visitStatFor?.(node) === false) return;
-	visitExpression(node.from, visitor);
-	visitExpression(node.to, visitor);
-	if (node.step) visitExpression(node.step, visitor);
-	visitStatBlock(node.body, visitor);
-}
-function visitStatForIn(node, visitor) {
-	if (visitor.visitStatForIn?.(node) === false) return;
-	visitPunctuated(node.values, visitor, visitExpression);
-	visitStatBlock(node.body, visitor);
-}
-function visitStatAssign(node, visitor) {
-	if (visitor.visitStatAssign?.(node) === false) return;
-	visitPunctuated(node.variables, visitor, visitExpression);
-	visitPunctuated(node.values, visitor, visitExpression);
-}
-function visitStatCompoundAssign(node, visitor) {
-	if (visitor.visitStatCompoundAssign?.(node) === false) return;
-	visitExpression(node.variable, visitor);
-	visitExpression(node.value, visitor);
-}
-function visitStatExpr(node, visitor) {
-	if (visitor.visitStatExpr?.(node) === false) return;
-	visitExpression(node.expression, visitor);
-}
-function visitStatFunction(node, visitor) {
-	if (visitor.visitStatFunction?.(node) === false) return;
-	visitExpression(node.name, visitor);
-	visitExprFunction(node.func, visitor);
-}
-function visitStatLocalFunction(node, visitor) {
-	if (visitor.visitStatLocalFunction?.(node) === false) return;
-	visitExprFunction(node.func, visitor);
-}
-function visitExprFunction(node, visitor) {
-	if (visitor.visitExprFunction?.(node) === false) return;
-	visitStatBlock(node.body, visitor);
-	visitor.visitExprFunctionEnd?.(node);
-}
-function visitExprCall(node, visitor) {
-	if (visitor.visitExprCall?.(node) === false) return;
-	visitExpression(node.func, visitor);
-	visitPunctuated(node.arguments, visitor, visitExpression);
-}
-function visitExprUnary(node, visitor) {
-	if (visitor.visitExprUnary?.(node) === false) return;
-	visitExpression(node.operand, visitor);
-}
-function visitExprBinary(node, visitor) {
-	if (visitor.visitExprBinary?.(node) === false) return;
-	visitExpression(node.lhsoperand, visitor);
-	visitExpression(node.rhsoperand, visitor);
-}
-function visitExprTable(node, visitor) {
-	if (visitor.visitExprTable?.(node) === false) return;
-	for (const item of node.entries) visitTableExprItem(item, visitor);
-}
-function visitTableExprItem(node, visitor) {
-	if (visitor.visitTableExprItem?.(node) === false) return;
-	visitExpression(node.value, visitor);
-	if (node.kind === "general") visitExpression(node.key, visitor);
-}
-function visitExprIndexName(node, visitor) {
-	if (visitor.visitExprIndexName?.(node) === false) return;
-	visitExpression(node.expression, visitor);
-}
-function visitExprIndexExpr(node, visitor) {
-	if (visitor.visitExprIndexExpr?.(node) === false) return;
-	visitExpression(node.expression, visitor);
-	visitExpression(node.index, visitor);
-}
-function visitExprGroup(node, visitor) {
-	if (visitor.visitExprGroup?.(node) === false) return;
-	visitExpression(node.expression, visitor);
-}
-function visitExprInterpString(node, visitor) {
-	if (visitor.visitExprInterpString?.(node) === false) return;
-	for (const expr of node.expressions) visitExpression(expr, visitor);
-}
-function visitExprTypeAssertion(node, visitor) {
-	if (visitor.visitExprTypeAssertion?.(node) === false) return;
-	visitExpression(node.operand, visitor);
-}
-function visitExprIfElse(node, visitor) {
-	if (visitor.visitExprIfElse?.(node) === false) return;
-	visitExpression(node.condition, visitor);
-	visitExpression(node.thenexpr, visitor);
-	for (const elseif of node.elseifs) visitElseIfExpr(elseif, visitor);
-	visitExpression(node.elseexpr, visitor);
-}
-function visitElseIfExpr(node, visitor) {
-	visitExpression(node.condition, visitor);
-	visitExpression(node.thenexpr, visitor);
-}
-function visitExprInstantiate(node, visitor) {
-	if (visitor.visitExprInstantiate?.(node) === false) return;
-	visitExpression(node.expr, visitor);
-}
-//#endregion
 //#region src/coverage/coverage-collector.ts
 const INSTRUMENTABLE_STATEMENT_TAGS = new Set([
 	"assign",
@@ -1350,36 +1085,36 @@ function collectCoverage(root) {
 			branch.arms.push({
 				bodyFirstColumn: 0,
 				bodyFirstLine: 0,
-				location: { ...node.thenexpr.location }
+				location: { ...node.thenExpr.location }
 			});
 			exprIfProbes.push({
 				armIndex,
 				branchIndex,
-				exprLocation: { ...node.thenexpr.location }
+				exprLocation: { ...node.thenExpr.location }
 			});
 			armIndex++;
 			for (const elseif of node.elseifs) {
 				branch.arms.push({
 					bodyFirstColumn: 0,
 					bodyFirstLine: 0,
-					location: { ...elseif.thenexpr.location }
+					location: { ...elseif.thenExpr.location }
 				});
 				exprIfProbes.push({
 					armIndex,
 					branchIndex,
-					exprLocation: { ...elseif.thenexpr.location }
+					exprLocation: { ...elseif.thenExpr.location }
 				});
 				armIndex++;
 			}
 			branch.arms.push({
 				bodyFirstColumn: 0,
 				bodyFirstLine: 0,
-				location: { ...node.elseexpr.location }
+				location: { ...node.elseExpr.location }
 			});
 			exprIfProbes.push({
 				armIndex,
 				branchIndex,
-				exprLocation: { ...node.elseexpr.location }
+				exprLocation: { ...node.elseExpr.location }
 			});
 			branches.push(branch);
 			branchIndex++;
@@ -1415,21 +1150,21 @@ function collectCoverage(root) {
 				branchType: "if",
 				index: branchIndex
 			};
-			const thenFirst = getBodyFirstStatement(node.thenblock);
+			const thenFirst = getBodyFirstStatement(node.thenBlock);
 			branch.arms.push({
 				bodyFirstColumn: thenFirst.column,
 				bodyFirstLine: thenFirst.line,
-				location: { ...node.thenblock.location }
+				location: { ...node.thenBlock.location }
 			});
 			for (const elseif of node.elseifs) {
-				const elseifFirst = getBodyFirstStatement(elseif.thenblock);
+				const elseifFirst = getBodyFirstStatement(elseif.thenBlock);
 				branch.arms.push({
 					bodyFirstColumn: elseifFirst.column,
 					bodyFirstLine: elseifFirst.line,
-					location: { ...elseif.thenblock.location }
+					location: { ...elseif.thenBlock.location }
 				});
 			}
-			const elseBlock = node.elseblock;
+			const { elseBlock } = node;
 			const hasExplicitElse = elseBlock !== void 0 && elseBlock.statements.length > 0;
 			if (hasExplicitElse) {
 				const elseFirst = getBodyFirstStatement(elseBlock);
@@ -1676,15 +1411,21 @@ function instrumentRoot(options) {
 	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", [
-			"run",
-			scriptPath,
-			"--",
-			path$1.resolve(luauRoot),
-			astOutputDirectory
-		], {
+		fileListJson = cp.execFileSync("lute", luteArgs, {
 			encoding: "utf-8",
 			maxBuffer: 1024 * 1024
 		});
@@ -1732,7 +1473,7 @@ function instrumentRoot(options) {
 			functionCount: collectorResult.functions.length,
 			instrumentedLuauPath,
 			originalLuauPath,
-			sourceHash: hashBuffer(sourceBuffer),
+			sourceHash: hashBuffer$1(sourceBuffer),
 			sourceMapPath,
 			statementCount: collectorResult.statements.length
 		};
@@ -1841,7 +1582,7 @@ const previousManifestSchema = type({
 }).as();
 function collectLuauRootsFromRojo(project, config) {
 	const paths = [];
-	collectPaths(project.tree, paths);
+	collectPaths$1(project.tree, paths);
 	const ignorePatterns = config.coveragePathIgnorePatterns;
 	const isIgnored = picomatch(ignorePatterns, { contains: true });
 	return paths.filter((directoryPath) => {
@@ -1851,6 +1592,16 @@ function collectLuauRootsFromRojo(project, config) {
 		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);
@@ -1924,26 +1675,30 @@ function resolveLuauRootsWithRojo(config, rojoProjectPath) {
 	if (outDirectory !== void 0) return [outDirectory];
 	throw new Error("Could not determine luauRoots. Set luauRoots in config or ensure tsconfig has outDir.");
 }
-function validateRelativeRoots(luauRoots) {
-	for (const root of luauRoots) if (path$1.isAbsolute(root)) throw new Error("luauRoots must be relative paths, got absolute path. Set a relative outDir in tsconfig or relative luauRoots in config.");
-}
-function computeSkipFiles(luauRoot, previousManifest) {
-	const skipFiles = /* @__PURE__ */ new Set();
-	const posixRoot = luauRoot.replaceAll("\\", "/");
-	for (const [fileKey, record] of Object.entries(previousManifest.files)) {
-		if (!fileKey.startsWith(`${posixRoot}/`)) continue;
-		const relativePath = fileKey.slice(posixRoot.length + 1);
-		const sourcePath = path$1.resolve(record.originalLuauPath);
-		if (!fs$1.existsSync(sourcePath)) continue;
-		if (hashBuffer(fs$1.readFileSync(sourcePath)) === record.sourceHash) skipFiles.add(relativePath);
+/**
+* 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);
+		}
 	}
-	return skipFiles;
 }
-function countPreviousFilesForRoot(luauRoot, previousManifest) {
-	const posixRoot = luauRoot.replaceAll("\\", "/");
-	let count = 0;
-	for (const fileKey of Object.keys(previousManifest.files)) if (fileKey.startsWith(`${posixRoot}/`)) count++;
-	return count;
+function 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("\\", "/");
@@ -1953,18 +1708,7 @@ function carryForwardRecords(luauRoot, previousManifest, allFiles, skipFiles) {
 	}
 }
 function discoverNonInstrumentedFiles(directory, relativeTo, 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;
-			discoverNonInstrumentedFiles(fullPath, relativeTo, results);
-		} else if (isNonInstrumentedFile(entry.name)) {
-			const relative = fullPath.slice(relativeTo.length + 1);
-			results.push(relative);
-		}
-	}
+	walkLuauDirectory(directory, relativeTo, isNonInstrumentedFile, results);
 }
 function pruneStaleNonInstrumented(posixRoot, previousNonInstrumented, currentFiles) {
 	if (previousNonInstrumented === void 0) return false;
@@ -1988,7 +1732,7 @@ function syncNonInstrumentedFiles(luauRoot, shadowDirectory, previousNonInstrume
 	for (const relativePath of discovered) {
 		const sourcePath = `${posixRoot}/${relativePath}`;
 		const shadowPath = `${shadowDirectory}/${relativePath}`;
-		const currentHash = hashBuffer(fs$1.readFileSync(path$1.resolve(sourcePath)));
+		const currentHash = hashBuffer$1(fs$1.readFileSync(path$1.resolve(sourcePath)));
 		const previousRecord = previousNonInstrumented?.[sourcePath];
 		if (previousRecord?.sourceHash === currentHash) {
 			files[sourcePath] = previousRecord;
@@ -2010,6 +1754,59 @@ function syncNonInstrumentedFiles(luauRoot, shadowDirectory, previousNonInstrume
 		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$1(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;
@@ -2017,11 +1814,23 @@ function instrumentRootWithCache(luauRoot, useIncremental, previousManifest) {
 		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) {
-		skipFiles = computeSkipFiles(luauRoot, previousManifest);
-		const previousCount = countPreviousFilesForRoot(luauRoot, previousManifest);
-		if (skipFiles.size !== previousCount) changed = true;
+		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,
@@ -2033,16 +1842,11 @@ function instrumentRootWithCache(luauRoot, useIncremental, previousManifest) {
 	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;
-	const relocatedShadowDirectory = path$1.relative(COVERAGE_DIR, shadowDirectory).replaceAll("\\", "/");
 	return {
 		changed,
 		files: allFiles,
 		nonInstrumentedFiles: syncResult.files,
-		rootEntry: {
-			luauRoot,
-			relocatedShadowDirectory,
-			shadowDir: shadowDirectory
-		}
+		rootEntry
 	};
 }
 function writeManifest(options) {
@@ -2312,6 +2116,8 @@ Options:
   --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)
+  --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
   --setupFiles <path...>            Setup scripts (package specifiers or relative paths)
   --setupFilesAfterEnv <path...>    Post-env setup scripts (package specifiers or relative paths)
@@ -2338,7 +2144,7 @@ Examples:
 function parseArgs(args) {
 	const { positionals, values } = parseArgs$1({
 		allowPositionals: true,
-		args,
+		args: normalizeParallelFlag(args),
 		options: {
 			"backend": { type: "string" },
 			"cache": { type: "boolean" },
@@ -2367,6 +2173,7 @@ function parseArgs(args) {
 			"no-color": { type: "boolean" },
 			"no-show-luau": { type: "boolean" },
 			"outputFile": { type: "string" },
+			"parallel": { type: "string" },
 			"passWithNoTests": { type: "boolean" },
 			"pollInterval": { type: "string" },
 			"port": { type: "string" },
@@ -2424,6 +2231,7 @@ function parseArgs(args) {
 		gameOutput: values.gameOutput,
 		help: values.help,
 		outputFile: values.outputFile,
+		parallel: parseParallelValue(values.parallel),
 		passWithNoTests: values.passWithNoTests,
 		pollInterval,
 		port,
@@ -2466,11 +2274,8 @@ function mergeProjectResults(results) {
 	let startTime = Number.POSITIVE_INFINITY;
 	let success = true;
 	const testResults = [];
-	let executionMs = 0;
 	let testsMs = 0;
-	let totalMs = 0;
-	let uploadMs = 0;
-	let coverageMs = 0;
+	let setupMs = 0;
 	let mergedCoverage;
 	for (const result of results) {
 		numberFailedTests += result.result.numFailedTests;
@@ -2481,13 +2286,14 @@ function mergeProjectResults(results) {
 		startTime = Math.min(startTime, result.result.startTime);
 		success &&= result.result.success;
 		testResults.push(...result.result.testResults);
-		executionMs += result.timing.executionMs;
 		testsMs += result.timing.testsMs;
-		totalMs += result.timing.totalMs;
-		uploadMs += result.timing.uploadMs ?? 0;
-		coverageMs += result.timing.coverageMs ?? 0;
+		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,
@@ -2502,14 +2308,16 @@ function mergeProjectResults(results) {
 			success,
 			testResults
 		},
+		sourceMapper: mergedSourceMapper,
 		timing: {
-			coverageMs: coverageMs > 0 ? coverageMs : void 0,
-			executionMs,
-			startTime: Math.min(...results.map((result) => result.timing.startTime)),
+			coverageMs: sharedTiming.timing.coverageMs,
+			executionMs: sharedTiming.timing.executionMs,
+			setupMs: setupMs > 0 ? setupMs : void 0,
+			startTime: mergedStartTime,
 			testsMs,
 			totalMs,
-			uploadCached: results.every((result) => result.timing.uploadCached === true),
-			uploadMs
+			uploadCached: sharedTiming.timing.uploadCached,
+			uploadMs: sharedTiming.timing.uploadMs
 		}
 	};
 }
@@ -2525,6 +2333,36 @@ async function main() {
 	const exitCode = await run(process.argv.slice(2));
 	process.exit(exitCode);
 }
+/**
+* `--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 = [];
+	for (let index = 0; index < args.length; index++) {
+		const current = args[index];
+		if (current !== PARALLEL_FLAG) {
+			out.push(current);
+			continue;
+		}
+		const next = args[index + 1];
+		if (next !== void 0 && !next.startsWith("-") && (next === "auto" || /^-?\d+$/.test(next))) {
+			out.push(PARALLEL_FLAG, next);
+			index += 1;
+		} else out.push(PARALLEL_FLAG, "auto");
+	}
+	return out;
+}
+function parseParallelValue(raw) {
+	if (raw === void 0) return;
+	if (raw === "auto") return "auto";
+	const parsed = Number.parseInt(raw, 10);
+	if (Number.isNaN(parsed) || parsed < 1) throw new Error(`Invalid --parallel value "${raw}". Must be a positive integer or "auto".`);
+	return parsed;
+}
 function formatGameOutputLines(raw) {
 	if (raw === void 0) return;
 	const entries = parseGameOutput(raw);
@@ -2563,6 +2401,21 @@ function writeGameOutputIfConfigured(config, gameOutput, options) {
 		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`);
@@ -2746,6 +2599,7 @@ async function outputMultiProjectResults(config, projectResults, 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);
@@ -2814,6 +2668,15 @@ 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);
@@ -2827,7 +2690,8 @@ async function runMultiProject(cli, rootConfig, projectEntries) {
 	if (!rootConfig.collectCoverage) buildWithRojo(path$1.resolve(rootConfig.rootDir, rootConfig.rojoProject ?? DEFAULT_ROJO_PROJECT), path$1.resolve(rootConfig.rootDir, rootConfig.placeFile));
 	const { effectiveConfig, preCoverageMs } = prepareMultiProjectCoverage(rootConfig, projects);
 	const backend = await resolveBackend(effectiveConfig);
-	const projectResults = [];
+	const parallel = effectiveParallelForBackend(effectiveConfig.parallel, backend);
+	const pendingJobs = [];
 	const allTypeTestFiles = [];
 	for (const project of projects) {
 		const discoveryConfig = {
@@ -2842,19 +2706,46 @@ async function runMultiProject(cli, rootConfig, projectEntries) {
 			testMatch: project.testMatch
 		};
 		allTypeTestFiles.push(...typeTestFiles);
-		if (runtimeFiles.length === 0 && typeTestFiles.length === 0) continue;
-		if (runtimeFiles.length > 0) {
-			const result = await execute({
-				backend,
-				config: projConfig,
+		if (runtimeFiles.length === 0) continue;
+		pendingJobs.push({
+			config: projConfig,
+			displayColor: project.displayColor,
+			displayName: project.displayName,
+			runtimeFiles
+		});
+	}
+	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,
-				testFiles: runtimeFiles,
+				startTime,
 				version: VERSION
 			});
 			projectResults.push({
-				displayColor: project.displayColor,
-				displayName: project.displayName,
-				result
+				displayColor: pending.displayColor,
+				displayName: pending.displayName,
+				result: executeResult
 			});
 		}
 	}
@@ -2877,13 +2768,18 @@ async function runMultiProject(cli, rootConfig, projectEntries) {
 }
 async function executeRuntimeTests(config, testFiles, totalFiles) {
 	if (!config.silent && !usesAgentFormatter(config) && !hasFormatter(config, "json") && testFiles.length !== totalFiles) process.stderr.write(`Running ${String(testFiles.length)} of ${String(totalFiles)} test files\n`);
-	return execute({
-		backend: await resolveBackend(config),
-		config,
-		deferFormatting: true,
-		testFiles,
-		version: VERSION
-	});
+	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;
@@ -2893,9 +2789,9 @@ function resolveSetupFilePaths(config) {
 		rojoConfigPath
 	}));
 }
-async function runSingleProject(config, cliFiles) {
+async function runSingleProject(cli, config) {
 	resolveSetupFilePaths(config);
-	const discovery = discoverTestFiles(config, cliFiles);
+	const discovery = discoverTestFiles(config, cli.files);
 	if (discovery.files.length === 0) {
 		if (config.passWithNoTests) return 0;
 		console.error("No test files found");
@@ -2941,7 +2837,7 @@ async function runInner(args) {
 	const config = mergeCliWithConfig(cli, await loadConfig$1(cli.config));
 	const rawProjects = config.projects;
 	if (rawProjects !== void 0 && rawProjects.length > 0) return runMultiProject(cli, config, rawProjects);
-	return runSingleProject(config, cli.files);
+	return runSingleProject(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\""],
@@ -3010,6 +2906,7 @@ function mergeCliWithConfig(cli, config) {
 		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,