@isentinel/jest-roblox 0.1.1 → 0.1.3

package/dist/cli.d.mts

@@ -1,4 +1,4 @@
-import { _ as ResolvedProjectConfig, n as ExecuteResult, v as CliOptions } from "./executor-DqZE3wME.mjs";
+import { _ as ResolvedProjectConfig, n as ExecuteResult, v as CliOptions } from "./executor-D6BzDfQ_.mjs";
 
 //#region src/cli.d.ts
 declare function parseArgs(args: Array<string>): CliOptions;

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { D as createOpenCloudBackend, I as isValidBackend, L as LuauScriptError, M as ROOT_ONLY_KEYS, N as VALID_BACKENDS, O as hashBuffer, S as loadConfig$1, T as createStudioBackend, _ as formatResult, a as formatAnnotations, b as formatBanner, c as execute, d as findFormatterOptions, g as formatMultiProjectResult, i as runTypecheck, l as formatExecuteOutput, m as formatCompactMultiProject, n as parseGameOutput, o as formatJobSummary, p as writeJsonFile, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, u as loadCoverageManifest, x as rojoProjectSchema, y as formatTypecheckSummary } from "./game-output-C0_-YIAY.mjs";
+import { A as hashBuffer, C as resolveNestedProjects, D as createStudioBackend, F as VALID_BACKENDS, P as ROOT_ONLY_KEYS, R as isValidBackend, S as collectPaths, _ as formatResult, a as formatAnnotations, b as formatBanner, c as execute, d as findFormatterOptions, g as formatMultiProjectResult, i as runTypecheck, k as createOpenCloudBackend, l as formatExecuteOutput, m as formatCompactMultiProject, n as parseGameOutput, o as formatJobSummary, p as writeJsonFile, r as writeGameOutput, s as resolveGitHubActionsOptions, t as formatGameOutputNotice, u as loadCoverageManifest, w as loadConfig$1, x as rojoProjectSchema, y as formatTypecheckSummary, z as LuauScriptError } from "./game-output-BU-9pJ93.mjs";
 import { createRequire } from "node:module";
 import { type } from "arktype";
 import assert from "node:assert";
@@ -14,16 +14,16 @@ import { WebSocketServer } from "ws";
 import { loadConfig } from "c12";
 import * as os from "node:os";
 import { Buffer } from "node:buffer";
+import * as cp from "node:child_process";
 import { RojoResolver } from "@roblox-ts/rojo-resolver";
 import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import { getTsconfig } from "get-tsconfig";
 import picomatch from "picomatch";
-import * as cp from "node:child_process";
 import istanbulCoverage from "istanbul-lib-coverage";
 import istanbulReport from "istanbul-lib-report";
 import istanbulReports from "istanbul-reports";
 //#region package.json
-var version = "0.1.1";
+var version = "0.1.3";
 //#endregion
 //#region src/backends/auto.ts
 var StudioWithFallback = class {
@@ -115,10 +115,95 @@ function stripTsExtension(pattern) {
 	return pattern.replace(/\.(tsx?|luau?)$/, "");
 }
 //#endregion
-//#region src/utils/rojo-tree.ts
-function collectPaths(node, result) {
-	for (const [key, value] of Object.entries(node)) if (key === "$path" && typeof value === "string") result.push(value.replaceAll("\\", "/"));
-	else if (typeof value === "object" && !Array.isArray(value) && !key.startsWith("$")) collectPaths(value, result);
+//#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\nlocal files: { string } = {}\ndiscoverFiles(luauRoot, luauRoot, files)\n\n-- Parse, strip, and write per-file AST JSON\nfor _, relativePath in files do\n	local fullPath = luauRoot .. \"/\" .. relativePath\n	local source = fs.readfiletostring(fullPath)\n	local parseResult = syntax.parse(source)\n	local stripped = strip(parseResult.root)\n\n	local outPath = outputDir .. \"/\" .. relativePath .. \".json\"\n	local dir = dirname(outPath)\n	if dir ~= \"\" then\n		fs.createdirectory(dir, { makeparents = true })\n	end\n\n	fs.writestringtofile(outPath, json.serialize(stripped))\nend\n\n-- Print file list to stdout (tiny — just paths)\nprint(json.serialize(files :: json.array))\n";
+//#endregion
+//#region src/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
@@ -220,6 +305,8 @@ function resolveProjectConfig(project, rootConfig, rojoTree) {
 	};
 }
 async function loadProjectConfigFile(filePath, cwd) {
+	const luauConfigPath = findLuauConfigFile(filePath, cwd);
+	if (luauConfigPath !== void 0) return buildProjectConfigFromLuau(luauConfigPath, filePath);
 	let result;
 	try {
 		result = await loadConfig({
@@ -261,6 +348,38 @@ function mergeProjectConfig(rootConfig, project) {
 	for (const [key, value] of Object.entries(project)) if (!PROJECT_ONLY_KEYS.has(key) && value !== void 0) merged[key] = value;
 	return merged;
 }
+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"];
+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;
+}
 function matchNodePath(childNode, targetPath, childDataModelPath) {
 	const nodePath = childNode.$path;
 	if (typeof nodePath !== "string") return;
@@ -336,6 +455,8 @@ function serializeToLuau(config) {
 }
 function generateProjectConfigs(projects) {
 	for (const project of projects) {
+		const luauConfigPath = project.outputPath.replace(/\.lua$/, ".luau");
+		if (fs.existsSync(luauConfigPath)) continue;
 		const content = serializeToLuau(project.config);
 		const directory = path.dirname(project.outputPath);
 		fs.mkdirSync(directory, { recursive: true });
@@ -441,27 +562,133 @@ function mapCoverageToTypeScript(coverageData, manifest) {
 		if (record === void 0) continue;
 		const resources = loadFileResources(record);
 		if (resources === void 0) continue;
-		mapFileFunctions(resources, fileCoverage, pendingFunctions, mapFileStatements(resources, fileCoverage, pendingStatements));
-		mapFileBranches(resources, fileCoverage, pendingBranches);
+		if (resources.traceMap === void 0) {
+			passthroughFileStatements(resources, fileCoverage, pendingStatements);
+			passthroughFileFunctions(resources, fileCoverage, pendingFunctions);
+			passthroughFileBranches(resources, fileCoverage, pendingBranches);
+		} else {
+			const mapped = {
+				coverageMap: resources.coverageMap,
+				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;
-	let sourceMapRaw;
 	try {
 		coverageMapRaw = fs$1.readFileSync(record.coverageMapPath, "utf-8");
-		sourceMapRaw = fs$1.readFileSync(record.sourceMapPath, "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 {}
 	return {
 		coverageMap: parsed,
-		traceMap: new TraceMap(sourceMapRaw)
+		sourceKey: record.key,
+		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
+		});
+	}
+}
 function mapStatement(traceMap, span) {
 	const mappedStart = originalPositionFor(traceMap, {
 		column: Math.max(0, span.start.column - 1),
@@ -702,26 +929,7 @@ function buildResult(pending, pendingFunctions, pendingBranches) {
 	return { files };
 }
 //#endregion
-//#region src/types/luau-ast.ts
-const INSTRUMENTABLE_STATEMENT_TAGS = new Set([
-	"assign",
-	"break",
-	"compoundassign",
-	"conditional",
-	"continue",
-	"do",
-	"expression",
-	"for",
-	"forin",
-	"function",
-	"local",
-	"localfunction",
-	"repeat",
-	"return",
-	"while"
-]);
-//#endregion
-//#region src/coverage/luau-visitor.ts
+//#region src/luau/visitor.ts
 function visitExpression(expression, visitor) {
 	if (visitor.visitExpr?.(expression) === false) return;
 	const { tag } = expression;
@@ -992,6 +1200,23 @@ function visitExprInstantiate(node, visitor) {
 }
 //#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;
@@ -1231,9 +1456,6 @@ function buildCoverageMap$1(result) {
 	};
 }
 //#endregion
-//#region src/coverage/parse-ast.luau
-var parse_ast_default = "local fs = require(\"@std/fs\")\nlocal json = require(\"@std/json\")\nlocal process = require(\"@std/process\")\nlocal syntax = require(\"@std/syntax\")\n\nlocal rawArgs = process.args\nlocal userArgs: { string } = {}\nlocal pastSeparator = false\n\nfor _, arg in rawArgs do\n	if pastSeparator then\n		table.insert(userArgs, arg)\n	elseif arg == \"--\" then\n		pastSeparator = true\n	end\nend\n\nlocal luauRoot = userArgs[1]\nlocal outputDir = userArgs[2]\nif not luauRoot or not outputDir then\n	error(\"Usage: lute run parse-ast.luau -- <luau-root> <output-dir>\")\nend\n\nluauRoot = string.gsub(luauRoot, \"\\\\\", \"/\")\noutputDir = string.gsub(outputDir, \"\\\\\", \"/\")\n\n-- Fields to keep per AST tag (beyond tag/kind/location which are always kept).\n-- Tags shared by stat/expr variants are merged — nil fields are harmless.\nlocal KEEP: { [string]: { string } } = {\n	assign = { \"values\", \"variables\" },\n	binary = { \"lhsoperand\", \"rhsoperand\" },\n	block = { \"statements\" },\n	call = { \"arguments\", \"func\" },\n	cast = { \"operand\" },\n	compoundassign = { \"value\", \"variable\" },\n	conditional = { \"condition\", \"thenblock\", \"elseifs\", \"elseblock\", \"thenexpr\", \"elseexpr\" },\n	[\"do\"] = { \"body\" },\n	expression = { \"expression\" },\n	[\"for\"] = { \"body\", \"from\", \"to\", \"step\" },\n	forin = { \"body\", \"values\" },\n	[\"function\"] = { \"body\", \"name\", \"func\" },\n	global = { \"name\" },\n	group = { \"expression\" },\n	index = { \"expression\", \"index\" },\n	indexname = { \"expression\", \"accessor\", \"index\" },\n	instantiate = { \"expr\" },\n	interpolatedstring = { \"expressions\" },\n	[\"local\"] = { \"values\", \"variables\" },\n	localfunction = { \"name\", \"func\" },\n	[\"repeat\"] = { \"body\", \"condition\" },\n	[\"return\"] = { \"expressions\" },\n	table = { \"entries\" },\n	unary = { \"operand\" },\n	[\"while\"] = { \"body\", \"condition\" },\n}\n\nlocal function strip(value: any): any\n	if type(value) ~= \"table\" then\n		return value\n	end\n\n	-- LuauSpan — has beginline, no tag\n	if value.beginline ~= nil then\n		return value\n	end\n\n	-- Token — has text but no tag, reduce to {text}\n	if value.text ~= nil and value.tag == nil then\n		return { text = value.text }\n	end\n\n	-- AST node — has tag, keep only allowlisted fields\n	if value.tag ~= nil then\n		local result = { tag = value.tag, kind = value.kind, location = value.location }\n		local fields = KEEP[value.tag :: string]\n		if fields then\n			for _, field in fields do\n				if value[field] ~= nil then\n					result[field] = strip(value[field])\n				end\n			end\n		end\n\n		return result\n	end\n\n	-- Other tables (arrays, Pairs, ElseIf structs) — recurse all fields\n	local result: any = {}\n	for k, v in value do\n		result[k] = strip(v)\n	end\n\n	return result\nend\n\n-- Discover .luau files recursively, skipping node_modules, dot dirs, spec/test files\nlocal function discoverFiles(directory: string, relativeTo: string, results: { string })\n	local entries = fs.listdirectory(directory)\n	for _, entry in entries do\n		local fullPath = directory .. \"/\" .. entry.name\n		if entry.type == \"dir\" then\n			if entry.name == \"node_modules\" or entry.name == \".jest-roblox-coverage\" then\n				continue\n			end\n\n			if string.sub(entry.name, 1, 1) == \".\" then\n				continue\n			end\n\n			discoverFiles(fullPath, relativeTo, results)\n		elseif\n			entry.type == \"file\"\n			and (string.sub(entry.name, -5) == \".luau\" or string.sub(entry.name, -4) == \".lua\")\n		then\n			if\n				string.sub(entry.name, -10) == \".spec.luau\"\n				or string.sub(entry.name, -10) == \".test.luau\"\n				or string.sub(entry.name, -9) == \".spec.lua\"\n				or string.sub(entry.name, -9) == \".test.lua\"\n				or string.sub(entry.name, -10) == \".snap.luau\"\n				or string.sub(entry.name, -9) == \".snap.lua\"\n			then\n				continue\n			end\n\n			-- Compute relative path\n			local relative = string.sub(fullPath, #relativeTo + 2)\n			table.insert(results, relative)\n		end\n	end\nend\n\nlocal function dirname(filepath: string): string\n	local pos = string.find(filepath, \"/[^/]*$\")\n	if pos then\n		return string.sub(filepath, 1, pos - 1)\n	end\n\n	return \"\"\nend\n\nlocal files: { string } = {}\ndiscoverFiles(luauRoot, luauRoot, files)\n\n-- Parse, strip, and write per-file AST JSON\nfor _, relativePath in files do\n	local fullPath = luauRoot .. \"/\" .. relativePath\n	local source = fs.readfiletostring(fullPath)\n	local parseResult = syntax.parse(source)\n	local stripped = strip(parseResult.root)\n\n	local outPath = outputDir .. \"/\" .. relativePath .. \".json\"\n	local dir = dirname(outPath)\n	if dir ~= \"\" then\n		fs.createdirectory(dir, { makeparents = true })\n	end\n\n	fs.writestringtofile(outPath, json.serialize(stripped))\nend\n\n-- Print file list to stdout (tiny — just paths)\nprint(json.serialize(files :: json.array))\n";
-//#endregion
 //#region src/coverage/probe-inserter.ts
 function insertProbes(source, result, fileKey) {
 	const lines = splitLines(source);
@@ -1288,7 +1510,7 @@ function applyProbes(mutableLines, probes) {
 		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 + text + after;
+		mutableLines[lineIndex] = before + (before.length > 0 && !/\s$/.test(before) && /^[a-zA-Z_]/.test(text) ? " " : "") + text + after;
 	}
 }
 function extractModeDirective(lines) {
@@ -1653,8 +1875,12 @@ function writeManifest(manifestPath, allFiles, luauRoots, placeFile) {
 function buildRojoProject(rojoProjectPath, roots, placeFile) {
 	const rojoProjectRaw = rojoProjectSchema(JSON.parse(fs$1.readFileSync(rojoProjectPath, "utf-8")));
 	if (rojoProjectRaw instanceof type.errors) throw new Error(`Malformed Rojo project JSON: ${rojoProjectRaw.toString()}`);
-	const rewritten = rewriteRojoProject(rojoProjectRaw, {
-		projectRelocation: path$1.relative(COVERAGE_DIR, path$1.dirname(rojoProjectPath)).replaceAll("\\", "/"),
+	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));
@@ -1798,7 +2024,7 @@ function globSync(pattern, options = {}) {
 	return walkDirectory(cwd, cwd).filter((file) => matchesGlobPattern(file, pattern));
 }
 function matchesGlobPattern(filePath, pattern) {
-	const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{DOUBLESTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLESTAR\}\}/g, ".*");
+	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) {
@@ -1833,6 +2059,7 @@ Options:
   --gameOutput <path>               Write game output (print/warn/error) to file
   --sourceMap                       Map Luau stack traces to TypeScript source
   --rojoProject <path>              Path to rojo project file (auto-detected if not set)
+  --passWithNoTests                 Exit with 0 when no test files are found
   --verbose                         Show individual test results
   --silent                          Suppress output
   --no-color                        Disable colored output
@@ -1894,6 +2121,7 @@ function parseArgs(args) {
 			"no-color": { type: "boolean" },
 			"no-show-luau": { type: "boolean" },
 			"outputFile": { type: "string" },
+			"passWithNoTests": { type: "boolean" },
 			"pollInterval": { type: "string" },
 			"port": { type: "string" },
 			"project": {
@@ -1949,6 +2177,7 @@ function parseArgs(args) {
 		gameOutput: values.gameOutput,
 		help: values.help,
 		outputFile: values.outputFile,
+		passWithNoTests: values.passWithNoTests,
 		pollInterval,
 		port,
 		project: values.project,
@@ -2095,7 +2324,11 @@ function printFinalStatus(passed) {
 	process.stdout.write(`${badge}\n`);
 }
 function processCoverage(config, coverageData) {
-	if (!config.collectCoverage || coverageData === void 0) return true;
+	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");
@@ -2277,7 +2510,7 @@ function loadRojoTree(config) {
 	const content = fs$1.readFileSync(rojoPath, "utf8");
 	const validated = rojoProjectSchema(JSON.parse(content));
 	if (validated instanceof type.errors) throw new Error(`Invalid Rojo project: ${validated.summary}`);
-	return validated.tree;
+	return resolveNestedProjects(validated.tree, path$1.dirname(rojoPath));
 }
 const STUB_SKIP_KEYS = new Set([
 	"outDir",
@@ -2386,6 +2619,7 @@ async function runMultiProject(cli, rootConfig, projectEntries) {
 		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;
 	}
@@ -2414,12 +2648,14 @@ async function runSingleProject(config, cliFiles) {
 	resolveSetupFilePaths(config);
 	const discovery = discoverTestFiles(config, cliFiles);
 	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;
 	}
@@ -2531,6 +2767,7 @@ function mergeCliWithConfig(cli, config) {
 		formatters: resolveFormatters(cli, config),
 		gameOutput: cli.gameOutput ?? config.gameOutput,
 		outputFile: cli.outputFile ?? config.outputFile,
+		passWithNoTests: cli.passWithNoTests ?? config.passWithNoTests,
 		pollInterval: cli.pollInterval ?? config.pollInterval,
 		port: cli.port ?? config.port,
 		rojoProject: cli.rojoProject ?? config.rojoProject,

package/dist/{executor-DqZE3wME.d.mts → executor-D6BzDfQ_.d.mts}

@@ -825,6 +825,7 @@ interface Config extends Except<Argv, "projects" | "rootDir" | "setupFiles" | "s
   gameOutput?: string;
   jestPath?: string;
   luauRoots?: Array<string>;
+  passWithNoTests?: boolean;
   placeFile?: string;
   pollInterval?: number;
   port?: number;
@@ -852,6 +853,7 @@ interface ResolvedConfig extends Except<Config, "projects"> {
   coverageDirectory: string;
   coveragePathIgnorePatterns: Array<string>;
   coverageReporters: Array<CoverageReporter>;
+  passWithNoTests: boolean;
   placeFile: string;
   pollInterval: number;
   port: number;
@@ -884,6 +886,7 @@ interface CliOptions {
   gameOutput?: string;
   help?: boolean;
   outputFile?: string;
+  passWithNoTests?: boolean;
   pollInterval?: number;
   port?: number;
   project?: Array<string>;