@isentinel/jest-roblox 0.3.2 → 0.3.4

package/dist/index.d.mts

@@ -1,9 +1,112 @@
-import { _ as SnapshotFormatOptions, a as DisplayName, b as defineProject, c as GlobalTestConfig, d as ProjectEntry, f as ProjectTestConfig, g as SharedTestConfig, h as SHARED_TEST_KEYS, i as DEFAULT_CONFIG, l as InlineProjectConfig, m as ResolvedConfig, n as Config, o as FormatterEntry, p as ROOT_CLI_KEYS, r as ConfigInput, s as GLOBAL_TEST_KEYS, t as CliOptions, u as JEST_ARGV_EXCLUDED_KEYS, v as WorkspaceConfig, y as defineConfig } from "./schema-BpjBo-Aw.mjs";
+import { _ as SnapshotFormatOptions, a as DisplayName, b as defineProject, c as GlobalTestConfig, d as ProjectEntry, f as ProjectTestConfig, g as SharedTestConfig, h as SHARED_TEST_KEYS, i as DEFAULT_CONFIG, l as InlineProjectConfig, m as ResolvedConfig, n as Config, o as FormatterEntry, p as ROOT_CLI_KEYS, r as ConfigInput, s as GLOBAL_TEST_KEYS, t as CliOptions, u as JEST_ARGV_EXCLUDED_KEYS, v as WorkspaceConfig, x as TypecheckConfig, y as defineConfig } from "./schema-BCTnsaiC.mjs";
 import { type } from "arktype";
 import { WebSocket, WebSocketServer } from "ws";
 import { StorageClient } from "@bedrock-rbx/ocale/storage";
 
-//#region src/coverage/types.d.ts
+//#region src/coverage-pipeline/build-manifest.d.ts
+/**
+* On-disk format version for `build-manifest.json`. Independent of
+* `MANIFEST_VERSION` (the coverage manifest's version) — the two siblings
+* version separately and are cross-linked by `buildId`.
+*/
+declare const BUILD_MANIFEST_VERSION: 1;
+interface BuildManifestProject {
+  displayName: string;
+  jestDataModelPath?: string;
+  projectDataModelPath: string;
+  setupFiles: Array<string>;
+  setupFilesAfterEnv: Array<string>;
+  testMatch: Array<string>;
+}
+interface BuildManifestFileRecord {
+  sourceHash: string;
+}
+interface BuildManifestArtifact {
+  hash: string;
+  path: string;
+}
+interface BuildManifest {
+  /** Shared UUID linking this manifest to its sibling `CoverageManifest`. */
+  buildId: string;
+  /**
+  * The uninstrumented place a consumer mutates and runs against. Present only
+  * when produced by `prepareArtifacts`; `runJestRoblox` / the CLI never build
+  * one, so coverage-only manifests omit it.
+  */
+  cleanPlace?: BuildManifestArtifact;
+  /** The coverage-instrumented place — the only source of coverage hit data. */
+  coveragePlace: BuildManifestArtifact;
+  /** SHA-256 of each compiled `.luau`, keyed by package-relative POSIX path. */
+  files: Record<string, BuildManifestFileRecord>;
+  generatedAt: string;
+  projects: Array<BuildManifestProject>;
+  version: typeof BUILD_MANIFEST_VERSION;
+}
+type ReadBuildManifestResult = {
+  actual: string;
+  expected: string;
+  kind: "buildid-mismatch";
+} | {
+  actual: string;
+  expected: string;
+  kind: "clean-place-hash-mismatch";
+  path: string;
+} | {
+  actual: string;
+  expected: string;
+  kind: "coverage-place-hash-mismatch";
+  path: string;
+} | {
+  actual: string;
+  expected: string;
+  kind: "source-drift";
+  path: string;
+} | {
+  actual: unknown;
+  expected: number;
+  kind: "version-mismatch";
+} | {
+  kind: "invalid";
+  summary: string;
+} | {
+  kind: "malformed-json";
+} | {
+  kind: "missing";
+} | {
+  kind: "missing-referenced-artifact";
+  path: string;
+} | {
+  kind: "ok";
+  manifest: BuildManifest;
+};
+interface ReadBuildManifestOptions {
+  /** When set, refuse if the manifest's `buildId` differs from this value. */
+  expectedBuildId?: string;
+  /** Base for resolving place paths and `files` keys when re-hashing. */
+  rootDir?: string;
+}
+declare const buildManifestSchema: type<BuildManifest>;
+/**
+* The producer-side build record an entry point emits after a coverage run.
+* `prepareCoverage` returns this so `runJestRoblox` and `prepareArtifacts` can
+* each write the Build Manifest with the place set they actually have.
+*/
+interface CoverageArtifacts {
+  buildId: string;
+  coveragePlace: BuildManifestArtifact;
+  files: Record<string, BuildManifestFileRecord>;
+  generatedAt: string;
+  /**
+  * Per-project DataModel paths the kernel consumes, resolved by the run path
+  * that built the place. Empty when the run resolved no projects.
+  */
+  projects: Array<BuildManifestProject>;
+  /** `false` on the incremental no-change reuse path. */
+  rebuilt: boolean;
+}
+declare function readBuildManifest(filePath: string, options?: ReadBuildManifestOptions): ReadBuildManifestResult;
+//#endregion
+//#region src/coverage-pipeline/types.d.ts
 /**
 * Raw hit counts for a single file, keyed by statement/function index.
 */
@@ -16,6 +119,44 @@ interface RawFileCoverage {
 * Raw coverage data for all files, keyed by original Luau-relative path.
 */
 type RawCoverageData = Record<string, RawFileCoverage>;
+/**
+* One Jest test case's coverage delta, as the Luau runner harvested it: the
+* statements (keyed by original Luau-relative path) whose hit count rose while
+* that test ran. Produced by the parser from the run envelope, consumed by the
+* per-test attribution harvester.
+*/
+interface PerTestCoverageEntry {
+  delta: Record<string, {
+    s: Array<number>;
+  }>;
+  testCaseId: string;
+  testFilePath: string;
+}
+//#endregion
+//#region src/artifacts/prepare-artifacts.d.ts
+/**
+* Everything a consumer (mutation-tester, `flux`) needs from one artifact-
+* production run: the two distinct places, the coverage hit data, and the paths
+* of the sibling manifests, all sharing one `buildId`.
+*/
+interface ArtifactBundle {
+  buildId: string;
+  buildManifestPath: string;
+  cleanPlace: BuildManifestArtifact;
+  coverageData?: RawCoverageData;
+  coverageManifestPath: string;
+  coveragePlace: BuildManifestArtifact;
+  /** Per-project DataModel paths the kernel consumes, resolved from the run. */
+  projects: Array<BuildManifestProject>;
+}
+/**
+* The sole producer of a Clean Place. Builds the Coverage-Instrumented Place and
+* runs the instrumented suite once (via the shared single/multi core), builds an
+* uninstrumented Clean Place through the Place Builder, then emits the Build
+* Manifest with both places in a single atomic write. `runJestRoblox` / the CLI
+* never build a Clean Place — opting in is calling this entry point.
+*/
+declare function prepareArtifacts(config: ResolvedConfig): Promise<ArtifactBundle>;
 //#endregion
 //#region src/memory-store/sorted-map-client.d.ts
 /**
@@ -98,6 +239,7 @@ type SnapshotWrites = Record<string, string>;
 interface ParseResult {
   coverageData?: RawCoverageData;
   luauTiming?: Record<string, number>;
+  perTestCoverage?: Array<PerTestCoverageEntry>;
   result: JestResult;
   setupSeconds?: number;
   snapshotWrites?: SnapshotWrites;
@@ -305,6 +447,12 @@ interface ResolvedProjectConfig {
   config: ResolvedConfig;
   displayColor?: string;
   displayName: string;
+  /**
+  * Root-prefixed `exclude` globs subtracted from Runtime Test discovery.
+  * Optional on the public type (back-compat for external constructors);
+  * `resolveProjectConfig` always populates it (defaulting to `[]`).
+  */
+  exclude?: Array<string>;
   /** Original include patterns (with TS extensions) for filesystem discovery. */
   include: Array<string>;
   /**
@@ -320,6 +468,123 @@ interface ResolvedProjectConfig {
   rojoMounts: Array<Mount>;
   /** Luau-side testMatch patterns (extensions stripped). */
   testMatch: Array<string>;
+  /** Raw per-project `test.typecheck`, merged via `resolveTypecheckConfig`. */
+  typecheck?: TypecheckConfig;
+}
+//#endregion
+//#region src/utils/hash.d.ts
+/**
+* SHA-256 of a file's raw bytes. The canonical helper for recording and
+* re-verifying artifact hashes — reads the file as a buffer so the digest
+* matches `hashBuffer` of the same content regardless of encoding.
+*/
+declare function hashFile(filePath: string): string;
+//#endregion
+//#region src/coverage-pipeline/manifest-parse.d.ts
+/**
+* Shared read result for the sibling manifest readers. `BuildManifest`'s reader
+* extends this with artifact-rehash variants after a successful parse.
+*/
+type ParsedManifest<T> = {
+  actual: unknown;
+  expected: number;
+  kind: "version-mismatch";
+} | {
+  kind: "invalid";
+  summary: string;
+} | {
+  kind: "malformed-json";
+} | {
+  kind: "missing";
+} | {
+  kind: "ok";
+  manifest: T;
+};
+//#endregion
+//#region src/coverage-pipeline/manifest.d.ts
+/**
+* On-disk format version for `coverage-manifest.json`. Bump when the schema
+* below changes shape; `INSTRUMENTER_VERSION` is independent and tracks
+* probe-output compatibility (cache invalidation), not file format.
+*
+* The in-process `CollectorResult` contract between coverage-collector and
+* probe-inserter is intentionally not formalized here: it has no serialization
+* boundary, so the TypeScript interface is sufficient.
+*/
+declare const MANIFEST_VERSION: 3;
+interface InstrumentedFileRecord {
+  key: string;
+  branchCount?: number;
+  coverageMapPath: string;
+  /**
+  * Per-statement attribution: maps a Luau statement id (the probe index, same
+  * key space as the coverage-map sidecar) to the ids of the tests that covered
+  * it. Populated after a coverage run by the per-test attribution harvester;
+  * absent on a freshly-instrumented manifest (no run yet).
+  */
+  coveringTestIds?: Record<string, Array<string>>;
+  functionCount?: number;
+  instrumentedLuauPath: string;
+  originalLuauPath: string;
+  sourceHash: string;
+  sourceMapPath: string;
+  statementCount: number;
+}
+/**
+* One Jest test case's identity, recorded so Phase 3's differential cache can
+* key on which tests cover a mutant and whether their source changed.
+* `coveringTestIds` references these by `testId`.
+*/
+interface TestRecord {
+  /** Full test name (describe chain + leaf `it`). */
+  testCaseId: string;
+  /** The test file's DataModel path, as the runner observed it. */
+  testFilePath: string;
+  /** SHA-256 of the test file's source, for cache invalidation. */
+  testFileSourceHash: string;
+  /** Stable unique id for the test case; referenced by `coveringTestIds`. */
+  testId: string;
+}
+interface NonInstrumentedFileRecord {
+  shadowPath: string;
+  sourceHash: string;
+  sourcePath: string;
+}
+interface CoverageManifest {
+  /** Shared UUID linking this manifest to its sibling `BuildManifest`. */
+  buildId: string;
+  files: Record<string, InstrumentedFileRecord>;
+  generatedAt: string;
+  instrumenterVersion: number;
+  luauRoots: Array<string>;
+  nonInstrumentedFiles: Record<string, NonInstrumentedFileRecord>;
+  placeFilePath?: string;
+  /**
+  * SHA-256 over every rojo build input OUTSIDE the luauRoots (non-luauRoot
+  * `$path` mounts plus the rojo project files), per `computeRojoInputsHash`.
+  * The incremental cache rebuilds the place when it drifts. Absent on manifests
+  * written before this field existed; a missing value is treated as changed so
+  * the next run repopulates it.
+  */
+  rojoInputsHash?: string;
+  shadowDir: string;
+  /**
+  * Per-test attribution records, one per Jest test case that covered at least
+  * one statement. Populated by the harvester after a coverage run; absent on a
+  * freshly-instrumented manifest.
+  */
+  tests?: Array<TestRecord>;
+  version: typeof MANIFEST_VERSION;
+}
+type ReadManifestResult = ParsedManifest<CoverageManifest>;
+declare const manifestSchema: type<CoverageManifest>;
+declare function readManifest(filePath: string): ReadManifestResult;
+//#endregion
+//#region src/coverage-pipeline/attribution.d.ts
+interface AttributionResult {
+  /** Per Luau file: statement id → ids of the tests that covered it. */
+  coveringTestIds: Record<string, Record<string, Array<string>>>;
+  tests: Array<TestRecord>;
 }
 //#endregion
 //#region src/source-mapper/index.d.ts
@@ -377,6 +642,7 @@ interface TimingResult {
 //#endregion
 //#region src/executor.d.ts
 interface ExecuteResult {
+  attribution?: AttributionResult;
   coverageData?: RawCoverageData;
   exitCode: number;
   gameOutput?: string;
@@ -590,7 +856,7 @@ declare function formatJobSummary(result: JestResult, options: GitHubActionsOpti
 declare function formatJson(result: JestResult): string;
 declare function writeJsonFile(result: JestResult, filePath: string): Promise<void>;
 //#endregion
-//#region src/coverage/mapper.d.ts
+//#region src/coverage-pipeline/mapper.d.ts
 interface MappedFileCoverage {
   b: Record<string, Array<number>>;
   branchMap: Record<string, {
@@ -655,10 +921,17 @@ interface ProjectResult {
   result: ExecuteResult;
 }
 interface MultiProjectMerged {
+  attribution?: ExecuteResult["attribution"];
   coverageData?: ExecuteResult["coverageData"];
   sourceMapper?: SourceMapper;
 }
 interface SingleRunResult {
+  /**
+  * Producer record for the entry point to emit a Build Manifest from. Set only
+  * on a coverage run; an entry point reads it to write the manifest with the
+  * place set it has.
+  */
+  coverageArtifacts?: CoverageArtifacts;
   mode: "single";
   preCoverageMs: number;
   runtimeResult?: ExecuteResult;
@@ -667,6 +940,8 @@ interface SingleRunResult {
 }
 interface MultiRunResult {
   collectCoverageFrom?: Array<string>;
+  /** Producer record for the entry point to emit a Build Manifest from. */
+  coverageArtifacts?: CoverageArtifacts;
   merged: MultiProjectMerged;
   mode: "multi";
   preCoverageMs: number;
@@ -715,7 +990,7 @@ interface RunOptions {
 //#region src/run.d.ts
 declare function runJestRoblox(cli: CliOptions, config: ResolvedConfig): Promise<RunResult>;
 //#endregion
-//#region node_modules/.pnpm/@rbxts+jest@3.13.3-ts.1/node_modules/@rbxts/jest/src/config.d.ts
+//#region node_modules/.pnpm/@rbxts+jest@3.16.0-ts.1/node_modules/@rbxts/jest/src/config.d.ts
 interface ReporterConfig {
   reporter: string | ModuleScript;
   options?: Record<string, any>;
@@ -741,6 +1016,7 @@ type Argv = Partial<{
   json: boolean;
   maxWorkers: number | string;
   noStackTrace: boolean;
+  stackDepth: number;
   outputFile: string;
   preset: string | undefined;
   projects: Array<string>;
@@ -803,10 +1079,21 @@ interface TestDefinition {
 //#region src/typecheck/runner.d.ts
 interface TypecheckOptions {
   files: Array<string>;
+  /**
+  * When `false` (default), tsgo errors in non-test source files surface as
+  * source-level failures. When `true`, only errors inside the discovered Type
+  * Test files are reported.
+  */
+  ignoreSourceErrors?: boolean;
   rootDir: string;
+  /**
+  * Milliseconds the tsgo spawn may run before it is killed and the pass
+  * throws. Defaults to {@link DEFAULT_SPAWN_TIMEOUT}.
+  */
+  spawnTimeout?: number;
   tsconfig?: string;
 }
-declare function runTypecheck(options: TypecheckOptions): JestResult;
+declare function runTypecheck(options: TypecheckOptions): Promise<JestResult>;
 //#endregion
 //#region src/types/game-output.d.ts
 interface GameOutputEntry {
@@ -1105,4 +1392,4 @@ declare function visitExpression(expression: AstExpr, visitor: LuauVisitor): voi
 declare function visitStatement(statement: AstStat, visitor: LuauVisitor): void;
 declare function visitBlock(block: AstStatBlock, visitor: LuauVisitor): void; //#endregion
 //#endregion
-export { type AstExpr, type AstExprBinary, type AstExprCall, type AstExprFunction, type AstStat, type AstStatBlock, type Backend, type BackendOptions, type CliOptions, type Config, type ConfigInput, DEFAULT_CONFIG, type DisplayName, type ExecuteResult, type FormatOutputOptions, type FormatterEntry, GLOBAL_TEST_KEYS, type GameOutputEntry, type GitHubActionsFormatterOptions, type GlobalTestConfig, type InlineProjectConfig, JEST_ARGV_EXCLUDED_KEYS, type JestArgv, type JestResult, type LuauSpan, type LuauVisitor, type MultiProjectMerged, type MultiRunResult, OpenCloudBackend, type ProjectEntry, type ProjectInput, type ProjectResult, type ProjectTestConfig, ROOT_CLI_KEYS, type ResolvedConfig, type ResolvedProjectConfig, type RunMode, type RunOptions, type RunProjectsOptions, type RunProjectsResult, type RunResult, SHARED_TEST_KEYS, type SharedTestConfig, type SingleRunResult, StudioBackend, type TestCaseResult, type TestDefinition, type TestFileResult, type TestStatus, type TscErrorInfo, type TypecheckOptions, type WorkspaceConfig, type WorkspaceRunResult, buildJestArgv, createOpenCloudBackend, createStudioBackend, defineConfig, defineProject, extractJsonFromOutput, formatAnnotations, formatExecuteOutput, formatFailure, formatGameOutputNotice, formatJobSummary, formatJson, formatResult, formatTestSummary, generateTestScript, loadConfig, parseGameOutput, parseJestOutput, resolveConfig, runJestRoblox, runProjects, runTypecheck, visitBlock, visitExpression, visitStatement, writeGameOutput, writeJsonFile };
+export { type ArtifactBundle, type AstExpr, type AstExprBinary, type AstExprCall, type AstExprFunction, type AstStat, type AstStatBlock, BUILD_MANIFEST_VERSION, type Backend, type BackendOptions, type BuildManifest, type BuildManifestArtifact, type BuildManifestFileRecord, type BuildManifestProject, type CliOptions, type Config, type ConfigInput, type CoverageManifest, DEFAULT_CONFIG, type DisplayName, type ExecuteResult, type FormatOutputOptions, type FormatterEntry, GLOBAL_TEST_KEYS, type GameOutputEntry, type GitHubActionsFormatterOptions, type GlobalTestConfig, type InlineProjectConfig, type InstrumentedFileRecord, JEST_ARGV_EXCLUDED_KEYS, type JestArgv, type JestResult, type LuauSpan, type LuauVisitor, MANIFEST_VERSION, type MultiProjectMerged, type MultiRunResult, type NonInstrumentedFileRecord, OpenCloudBackend, type ProjectEntry, type ProjectInput, type ProjectResult, type ProjectTestConfig, ROOT_CLI_KEYS, type ReadBuildManifestOptions, type ReadBuildManifestResult, type ReadManifestResult as ReadCoverageManifestResult, type ResolvedConfig, type ResolvedProjectConfig, type RunMode, type RunOptions, type RunProjectsOptions, type RunProjectsResult, type RunResult, SHARED_TEST_KEYS, type SharedTestConfig, type SingleRunResult, StudioBackend, type TestCaseResult, type TestDefinition, type TestFileResult, type TestRecord, type TestStatus, type TscErrorInfo, type TypecheckOptions, type WorkspaceConfig, type WorkspaceRunResult, buildJestArgv, buildManifestSchema, manifestSchema as coverageManifestSchema, createOpenCloudBackend, createStudioBackend, defineConfig, defineProject, extractJsonFromOutput, formatAnnotations, formatExecuteOutput, formatFailure, formatGameOutputNotice, formatJobSummary, formatJson, formatResult, formatTestSummary, generateTestScript, hashFile, loadConfig, parseGameOutput, parseJestOutput, prepareArtifacts, readBuildManifest, readManifest as readCoverageManifest, resolveConfig, runJestRoblox, runProjects, runTypecheck, visitBlock, visitExpression, visitStatement, writeGameOutput, writeJsonFile };

package/dist/index.mjs

@@ -1,2 +1,84 @@
-import { A as extractJsonFromOutput, C as formatJson, D as formatTestSummary, E as formatResult, F as DEFAULT_CONFIG, H as defineProject, I as GLOBAL_TEST_KEYS, L as JEST_ARGV_EXCLUDED_KEYS, N as loadConfig, P as resolveConfig, R as ROOT_CLI_KEYS, S as writeGameOutput, T as formatFailure, V as defineConfig, _ as formatJobSummary, a as visitStatement, b as formatGameOutputNotice, c as OpenCloudBackend, f as buildJestArgv, g as formatAnnotations, i as visitExpression, j as parseJestOutput, l as createOpenCloudBackend, n as runTypecheck, o as StudioBackend, p as generateTestScript, r as visitBlock, s as createStudioBackend, t as runJestRoblox, v as formatExecuteOutput, w as writeJsonFile, x as parseGameOutput, y as runProjects, z as SHARED_TEST_KEYS } from "./run-CyHhajiY.mjs";
-export { DEFAULT_CONFIG, GLOBAL_TEST_KEYS, JEST_ARGV_EXCLUDED_KEYS, OpenCloudBackend, ROOT_CLI_KEYS, SHARED_TEST_KEYS, StudioBackend, buildJestArgv, createOpenCloudBackend, createStudioBackend, defineConfig, defineProject, extractJsonFromOutput, formatAnnotations, formatExecuteOutput, formatFailure, formatGameOutputNotice, formatJobSummary, formatJson, formatResult, formatTestSummary, generateTestScript, loadConfig, parseGameOutput, parseJestOutput, resolveConfig, runJestRoblox, runProjects, runTypecheck, visitBlock, visitExpression, visitStatement, writeGameOutput, writeJsonFile };
+import { $ as loadConfig, A as formatJobSummary, B as formatResult, C as BUILD_MANIFEST_VERSION, E as readBuildManifest, F as writeGameOutput, G as manifestSchema, I as createTimingCollector, J as applyAttribution, K as readManifest, L as formatJson, M as runProjects, N as formatGameOutputNotice, P as parseGameOutput, Q as mergeCliWithConfig, R as writeJsonFile, S as buildPlace, T as emitBuildManifest, U as hashFile, V as formatTestSummary, W as MANIFEST_VERSION, X as extractJsonFromOutput, Z as parseJestOutput, _ as COVERAGE_MANIFEST_PATH, a as loadRojoTree, at as SHARED_TEST_KEYS, b as visitExpression, c as StudioBackend, ct as defineProject, d as createOpenCloudBackend, et as resolveConfig, g as COVERAGE_BUILD_MANIFEST_PATH, h as generateTestScript, i as collectStubMounts, it as ROOT_CLI_KEYS, j as formatExecuteOutput, k as formatAnnotations, l as createStudioBackend, m as buildJestArgv, n as runJestRoblox, nt as GLOBAL_TEST_KEYS, o as runTypecheck, q as writeManifest, r as runSingleOrMulti, rt as JEST_ARGV_EXCLUDED_KEYS, s as resolveAllProjects, st as defineConfig, t as getRawProjects, tt as DEFAULT_CONFIG, u as OpenCloudBackend, v as findRojoProject, w as buildManifestSchema, x as visitStatement, y as visitBlock, z as formatFailure } from "./run-D20euZYa.mjs";
+import * as path$1 from "node:path";
+//#region src/artifacts/prepare-artifacts.ts
+const COVERAGE_DIR = path$1.dirname(COVERAGE_BUILD_MANIFEST_PATH);
+const CLEAN_PLACE_FILE = path$1.join(COVERAGE_DIR, "clean.rbxl");
+const CLEAN_PROJECT_FILE = path$1.join(COVERAGE_DIR, "clean.project.json");
+const CACHE_DIR = path$1.join(".jest-roblox", "cache");
+/**
+* The sole producer of a Clean Place. Builds the Coverage-Instrumented Place and
+* runs the instrumented suite once (via the shared single/multi core), builds an
+* uninstrumented Clean Place through the Place Builder, then emits the Build
+* Manifest with both places in a single atomic write. `runJestRoblox` / the CLI
+* never build a Clean Place — opting in is calling this entry point.
+*/
+async function prepareArtifacts(config) {
+	const cli = {};
+	const timing = createTimingCollector();
+	try {
+		const merged = mergeCliWithConfig(cli, {
+			...config,
+			collectCoverage: true,
+			collectPerTestCoverage: true
+		});
+		const result = await runSingleOrMulti(cli, merged, timing);
+		const { coverageArtifacts } = result;
+		if (coverageArtifacts === void 0) throw new Error("prepareArtifacts: the coverage run produced no artifacts. Ensure the project has runtime tests and that `typecheckOnly` is not set.");
+		const cleanPlace = await buildCleanPlace(merged);
+		emitBuildManifest(COVERAGE_BUILD_MANIFEST_PATH, coverageArtifacts, cleanPlace);
+		writeManifestAttribution(COVERAGE_MANIFEST_PATH, extractAttribution(result));
+		return {
+			buildId: coverageArtifacts.buildId,
+			buildManifestPath: COVERAGE_BUILD_MANIFEST_PATH,
+			cleanPlace,
+			coverageData: extractCoverageData(result),
+			coverageManifestPath: COVERAGE_MANIFEST_PATH,
+			coveragePlace: coverageArtifacts.coveragePlace,
+			projects: coverageArtifacts.projects
+		};
+	} finally {
+		timing.flushTimingReport();
+	}
+}
+function extractCoverageData(result) {
+	return result.mode === "single" ? result.runtimeResult?.coverageData : result.merged.coverageData;
+}
+function extractAttribution(result) {
+	return result.mode === "single" ? result.runtimeResult?.attribution : result.merged.attribution;
+}
+/**
+* Re-publish the coverage manifest with attribution folded in. A missing or
+* unreadable manifest, or a run that produced no attribution, is a no-op — the
+* file records the instrument step wrote stay as published.
+*/
+function writeManifestAttribution(manifestPath, attribution) {
+	if (attribution === void 0) return;
+	const read = readManifest(manifestPath);
+	if (read.kind === "ok") writeManifest(manifestPath, applyAttribution(read.manifest, attribution));
+}
+/**
+* Build the uninstrumented Clean Place from the same rojo project as the
+* Coverage-Instrumented Place, minus `coverageRoots`. In multi mode the place
+* carries the same `jest.config` stub mounts the coverage run already wrote to
+* the cache, so the Clean Place is runnable.
+*/
+async function buildCleanPlace(config) {
+	const descriptor = {
+		name: "jest-roblox-clean",
+		packageDirectory: path$1.resolve(config.rootDir),
+		rojoProjectPath: path$1.resolve(findRojoProject(config))
+	};
+	const rawProjects = getRawProjects(config);
+	if (rawProjects !== void 0 && rawProjects.length > 0) {
+		const cacheRoot = path$1.resolve(config.rootDir, CACHE_DIR);
+		descriptor.stubMounts = collectStubMounts(await resolveAllProjects(rawProjects, config, loadRojoTree(config), config.rootDir), config.rootDir, cacheRoot);
+	}
+	return buildPlace({
+		packages: [descriptor],
+		placeFile: CLEAN_PLACE_FILE,
+		projectFile: CLEAN_PROJECT_FILE,
+		wrap: false
+	});
+}
+//#endregion
+export { BUILD_MANIFEST_VERSION, DEFAULT_CONFIG, GLOBAL_TEST_KEYS, JEST_ARGV_EXCLUDED_KEYS, MANIFEST_VERSION, OpenCloudBackend, ROOT_CLI_KEYS, SHARED_TEST_KEYS, StudioBackend, buildJestArgv, buildManifestSchema, manifestSchema as coverageManifestSchema, createOpenCloudBackend, createStudioBackend, defineConfig, defineProject, extractJsonFromOutput, formatAnnotations, formatExecuteOutput, formatFailure, formatGameOutputNotice, formatJobSummary, formatJson, formatResult, formatTestSummary, generateTestScript, hashFile, loadConfig, parseGameOutput, parseJestOutput, prepareArtifacts, readBuildManifest, readManifest as readCoverageManifest, resolveConfig, runJestRoblox, runProjects, runTypecheck, visitBlock, visitExpression, visitStatement, writeGameOutput, writeJsonFile };