@isentinel/jest-roblox 0.2.7 → 0.3.1

package/dist/index.d.mts

@@ -1,51 +1,268 @@
-import { A as defineConfig, C as FormatterEntry, D as ROOT_ONLY_KEYS, E as ProjectTestConfig, M as Argv, O as ResolvedConfig, S as DisplayName, T as ProjectEntry, _ as ResolvedProjectConfig, a as formatExecuteOutput, b as ConfigInput, c as Backend, d as extractJsonFromOutput, f as parseJestOutput, g as TestStatus, h as TestFileResult, i as execute, j as defineProject, k as SnapshotFormatOptions, l as BackendOptions, m as TestCaseResult, n as ExecuteResult, o as TimingResult, p as JestResult, r as FormatOutputOptions, s as SourceMapper, t as ExecuteOptions, u as BackendResult, v as CliOptions, w as InlineProjectConfig, x as DEFAULT_CONFIG, y as Config } from "./executor-COuwZJJX.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, y as defineConfig } from "./schema-BpjBo-Aw.mjs";
+import { type } from "arktype";
 import { WebSocket, WebSocketServer } from "ws";
-import buffer from "node:buffer";
+import { StorageClient } from "@bedrock-rbx/ocale/storage";
 
-//#region packages/roblox-runner/dist/index.d.mts
-//#region src/http-client.d.ts
-interface HttpResponse {
-  body: unknown;
-  headers?: Record<string, string | undefined>;
-  ok: boolean;
-  status: number;
+//#region src/coverage/types.d.ts
+/**
+* Raw hit counts for a single file, keyed by statement/function index.
+*/
+interface RawFileCoverage {
+  b?: Record<string, Array<number>>;
+  f?: Record<string, number>;
+  s: Record<string, number>;
+}
+/**
+* Raw coverage data for all files, keyed by original Luau-relative path.
+*/
+type RawCoverageData = Record<string, RawFileCoverage>;
+//#endregion
+//#region src/memory-store/sorted-map-client.d.ts
+/**
+* Slim per-package summary published mid-task via the MemoryStore SortedMap.
+* Intentionally compact — Roblox caps SortedMap items at 32 KB, so we leave
+* the full `jestOutput` JSON out of streaming and reconstruct it from the
+* task's final envelope. Streaming only needs enough fields to render a
+* one-line progress message.
+*/
+interface StreamingResultEntry {
+  elapsedMs: number;
+  numFailedTests: number;
+  numPassedTests: number;
+  numPendingTests: number;
+  pkg: string;
+  project: string;
+  success: boolean;
+}
+interface StreamingResultRecord {
+  id: string;
+  value: StreamingResultEntry;
 }
-interface RequestOptions {
-  body?: unknown;
-  headers?: Record<string, string>;
+/**
+* Minimal surface used by streaming polling — lets backends and tests
+* stand in a stub without depending on the SDK class hierarchy.
+*/
+interface StreamingResultReader {
+  delete(itemId: string): Promise<void>;
+  readAll(): Promise<Array<StreamingResultRecord>>;
 }
-interface HttpClient {
-  request(method: string, url: string, options?: RequestOptions): Promise<HttpResponse>;
+//#endregion
+//#region src/types/jest-result.d.ts
+type TestStatus = "disabled" | "failed" | "passed" | "pending" | "skipped" | "todo";
+interface TestCaseResult {
+  ancestorTitles: Array<string>;
+  duration?: number;
+  failureMessages: Array<string>;
+  fullName: string;
+  location?: {
+    column: number;
+    line: number;
+  };
+  numPassingAsserts?: number;
+  retryReasons?: Array<string>;
+  status: TestStatus;
+  title: string;
+}
+interface TestFileResult {
+  failureMessage?: string;
+  numFailingTests: number;
+  numPassingTests: number;
+  numPendingTests: number;
+  testFilePath: string;
+  testResults: Array<TestCaseResult>;
+}
+interface SnapshotSummary {
+  added: number;
+  didUpdate?: boolean;
+  filesRemoved?: number;
+  matched: number;
+  total: number;
+  unchecked?: number;
+  unmatched: number;
+  updated: number;
+}
+interface JestResult {
+  numFailedTests: number;
+  numPassedTests: number;
+  numPendingTests: number;
+  numTodoTests?: number;
+  numTotalTests: number;
+  snapshot?: SnapshotSummary;
+  startTime: number;
+  success: boolean;
+  testResults: Array<TestFileResult>;
 }
 //#endregion
-//#region src/backends/open-cloud.d.ts
-interface OpenCloudCredentials {
+//#region src/reporter/parser.d.ts
+type SnapshotWrites = Record<string, string>;
+interface ParseResult {
+  coverageData?: RawCoverageData;
+  luauTiming?: Record<string, number>;
+  result: JestResult;
+  setupSeconds?: number;
+  snapshotWrites?: SnapshotWrites;
+}
+declare function extractJsonFromOutput(output: string): string | undefined;
+declare function parseJestOutput(output: string): ParseResult;
+//#endregion
+//#region src/backends/interface.d.ts
+interface EnvelopeEntry {
+  bannerOutput?: string;
+  elapsedMs?: number;
+  gameOutput?: string;
+  jestOutput: string;
+  pkg?: string;
+  project?: string;
+  snapshotWrites?: SnapshotWrites;
+}
+interface ProjectJob {
+  config: ResolvedConfig;
+  displayColor?: string;
+  displayName: string;
+  /**
+  * Workspace-mode only: the npm package name (e.g. `@halcyon/foo`) that
+  * owns this project. Combined with `displayName` it forms the lookup key
+  * used by work-stealing to match Luau-emitted entries to jobs. Outside
+  * workspace mode this is undefined and the lookup falls back to
+  * `displayName` alone.
+  */
+  pkg?: string;
+  /**
+  * Studio-only: filtered list of DataModel paths that should receive
+  * runtime `jest.config` ModuleScript injection. The CLI excludes mount
+  * paths where a user-authored `jest.config.luau` already exists on
+  * disk (synced by Rojo); injecting over those would either overwrite
+  * the canonical config or trigger the plugin's structural collision
+  * check. The Studio backend forwards this array (parallel to
+  * `configs`) as `runtimeStubMounts[i]` in the WebSocket payload; the
+  * plugin's Run Mode runner iterates only this list, never the
+  * unfiltered `cfg.projects`. Empty is meaningful — the project has no
+  * mounts needing runtime injection. Open-cloud backend ignores this
+  * field; it bakes stubs into the place file via the synthesizer.
+  */
+  runtimeInjectionPaths?: Array<string>;
+  testFiles: Array<string>;
+}
+interface StreamingHooks {
+  /**
+  * Called once per newly-observed SortedMap entry, in the order the
+  * backend's poll loop drains them. Duplicates from work-stealing
+  * fault-recovery are NOT filtered here — consumers handle that
+  * (the StreamingAggregator drops repeat pkg/project keys).
+  */
+  onPackageResult: (entry: StreamingResultEntry) => void;
+  /**
+  * Optional poll cadence in milliseconds. Defaults to 250ms — fast
+  * enough to feel live without saturating the Open Cloud rate limit.
+  */
+  pollMs?: number;
+  reader: StreamingResultReader;
+}
+interface BackendOptions {
+  jobs: Array<ProjectJob>;
+  /**
+  * Open-Cloud-only: number of concurrent Open Cloud Luau execution sessions
+  * to fire. Unset or 1 means one session carrying all jobs. `"auto"` resolves
+  * to min(jobs.length, 3). Studio backend must error when this is set to
+  * anything other than undefined/1 (Phase 4 enforces at the CLI layer).
+  */
+  parallel?: "auto" | number;
+  /**
+  * Workspace mode: pre-built Luau script that the backend should send
+  * verbatim instead of generating one from `jobs`. Used by the staged
+  * materializer pipeline so the CLI layer chooses the script and the
+  * backend stays unaware of the difference.
+  */
+  scriptOverride?: string;
+  /**
+  * Open-Cloud-only, work-stealing only: when provided, the backend polls
+  * the SortedMap concurrently with executeScript and invokes
+  * `onPackageResult` per newly-observed entry. Consumed entries are
+  * deleted to avoid re-emission. Streaming is best-effort: failure to
+  * poll/delete does not affect the final results returned in the task
+  * envelope.
+  */
+  streaming?: StreamingHooks;
+  /**
+  * Open-Cloud-only: when true, fire `parallel` tasks all running the SAME
+  * `scriptOverride` (no static job-bucket split). Each task pulls work from
+  * a MemoryStore queue (set up upstream) and returns whatever subset of
+  * packages it processed. Backend aggregates entries across all task
+  * envelopes and maps each to the matching `ProjectJob.displayName` by the
+  * entry's `pkg` field. `scriptOverride` is required when this is true.
+  */
+  workStealing?: boolean;
+}
+interface BackendTiming {
+  executionMs: number;
+  uploadMs?: number;
+}
+interface RawBackendEntry {
+  entry: EnvelopeEntry;
+  fallbackGameOutput?: string;
+}
+interface BackendResult {
+  rawResults: Array<RawBackendEntry>;
+  timing: BackendTiming;
+}
+interface Backend {
+  close?(): Promise<void> | void;
+  readonly kind: BackendKind;
+  runTests(options: BackendOptions): Promise<BackendResult>;
+}
+type BackendKind = "open-cloud" | "studio";
+//#endregion
+//#region packages/roblox-runner/dist/index.d.mts
+//#endregion
+//#region src/types.d.ts
+interface RunnerCredentials {
   apiKey: string;
   placeId: string;
   universeId: string;
 }
+interface UploadPlaceOptions {
+  placeFilePath: string;
+}
+interface UploadPlaceResult {
+  uploadMs: number;
+  versionNumber: number;
+}
+interface ExecuteScriptOptions {
+  script: string;
+  timeout: number;
+}
+interface ScriptResult {
+  durationMs: number;
+  outputs: Array<string>;
+}
+interface RemoteRunner {
+  executeScript(options: ExecuteScriptOptions): Promise<ScriptResult>;
+  uploadPlace(options: UploadPlaceOptions): Promise<UploadPlaceResult>;
+} //#endregion
+//#region src/credentials.d.ts
+//#endregion
+//#region src/backends/open-cloud.d.ts
+type OpenCloudCredentials = RunnerCredentials;
 interface OpenCloudOptions {
-  http?: HttpClient;
-  readFile?: FileReader;
-  sleep?: (ms: number) => Promise<void>;
+  /**
+  * Inject a pre-built {@link RemoteRunner}. When provided, the
+  * `credentials` argument to {@link OpenCloudBackend} is ignored —
+  * the injected runner already owns its own credentials. Intended
+  * primarily as a test seam.
+  */
+  runner?: RemoteRunner;
 }
-type FileReader = (path: string) => buffer.Buffer;
 declare class OpenCloudBackend implements Backend {
-  private readonly baseUrl;
-  private readonly credentials;
-  private readonly http;
-  private readonly readFile;
-  private readonly sleepFn;
+  private readonly runner;
   readonly kind = "open-cloud";
   constructor(credentials: OpenCloudCredentials, options?: OpenCloudOptions);
   runTests(options: BackendOptions): Promise<BackendResult>;
-  private createExecutionTask;
-  private pollForCompletion;
   private runBucket;
-  private uploadOrReuseCached;
-  private uploadPlaceData;
+  private runStaticBuckets;
+  private runStealingTask;
+  private runWorkStealing;
 }
-declare function createOpenCloudBackend(): OpenCloudBackend;
+declare function createOpenCloudBackend(credentials: OpenCloudCredentials): OpenCloudBackend;
 //#endregion
 //#region src/backends/studio.d.ts
 interface PreConnected {
@@ -68,9 +285,7 @@ declare class StudioBackend implements Backend {
   constructor(options: StudioOptions);
   close(): void;
   runTests(options: BackendOptions): Promise<BackendResult>;
-  private buildProjectResult;
   private executeViaPlugin;
-  private parseEnvelope;
   private waitForResult;
 }
 declare function createStudioBackend(options: StudioOptions): StudioBackend;
@@ -79,6 +294,156 @@ declare function createStudioBackend(options: StudioOptions): StudioBackend;
 declare function resolveConfig(config: Config): ResolvedConfig;
 declare function loadConfig(configPath?: string, cwd?: string): Promise<ResolvedConfig>;
 //#endregion
+//#region packages/rojo-utils/dist/index.d.mts
+interface Mount {
+  dataModelPath: string;
+  fsPath: string;
+}
+//#endregion
+//#region src/config/projects.d.ts
+interface ResolvedProjectConfig {
+  config: ResolvedConfig;
+  displayColor?: string;
+  displayName: string;
+  /** Original include patterns (with TS extensions) for filesystem discovery. */
+  include: Array<string>;
+  /**
+  * Single resolved output directory (workspace-relative). Set only when
+  * resolution produced exactly one mount; undefined when the project spans
+  * multiple rojo mounts. Kept for back-compat; new code should consume
+  * `rojoMounts` instead.
+  */
+  outDir?: string;
+  /** DataModel paths Jest walks up from to discover test configs. */
+  projects: Array<string>;
+  /** Internal: FS↔DataModel pairs for stub generation and shadow sync. */
+  rojoMounts: Array<Mount>;
+  /** Luau-side testMatch patterns (extensions stripped). */
+  testMatch: Array<string>;
+}
+//#endregion
+//#region src/source-mapper/index.d.ts
+interface MappedLocation {
+  luauLine: number;
+  luauPath: string;
+  sourceContent?: string;
+  tsColumn?: number;
+  tsLine?: number;
+  tsPath?: string;
+}
+interface MappedFailure {
+  locations: Array<MappedLocation>;
+  message: string;
+}
+interface SourceMapper {
+  mapFailureMessage(message: string): string;
+  mapFailureWithLocations(message: string): MappedFailure;
+  resolveDisplayPath(testFilePath: string): string;
+  resolveTestFilePath(testFilePath: string): string | undefined;
+}
+//#endregion
+//#region src/timing/orchestration-collector.d.ts
+interface TimingCollector {
+  flushTimingReport: () => void;
+  profile: <T>(name: string, func: () => T extends Promise<unknown> ? never : T) => T;
+  profileAsync: <T>(name: string, func: () => Promise<T>) => Promise<T>;
+  /**
+  * Register a leaf span under the current stack frame whose `elapsedMs` is
+  * supplied directly. Used to surface durations the orchestrator did not
+  * measure itself — the backend reports `uploadMs` / `executionMs` from
+  * inside its own `runTests` call, and the Luau runner reports per-game
+  * phases inside the Roblox VM. Repeated calls with the same `name`
+  * accumulate, matching `profile`'s behavior.
+  *
+  * Stack-empty fallback: when called outside any `profile`/`profileAsync`
+  * frame the span lands at root and contributes to `TOTAL (host)` like
+  * any other root. Call inside the relevant frame to keep totals clean
+  * — recording a value at root that is ALSO captured by a sibling root
+  * `profile` span would double-count toward the host total.
+  */
+  record: (name: string, elapsedMs: number) => void;
+}
+//#endregion
+//#region src/types/timing.d.ts
+interface TimingResult {
+  coverageMs?: number;
+  executionMs: number;
+  setupMs?: number;
+  startTime: number;
+  testsMs: number;
+  totalMs: number;
+  uploadMs?: number;
+}
+//#endregion
+//#region src/executor.d.ts
+interface ExecuteResult {
+  coverageData?: RawCoverageData;
+  exitCode: number;
+  gameOutput?: string;
+  output: string;
+  result: JestResult;
+  snapshotWriteFailures?: number;
+  sourceMapper?: SourceMapper;
+  timing: TimingResult;
+}
+interface FormatOutputOptions {
+  config: ResolvedConfig;
+  result: JestResult;
+  snapshotWriteFailures?: number;
+  sourceMapper?: SourceMapper;
+  timing: TimingResult;
+  version: string;
+}
+interface ProjectInput {
+  config: ResolvedConfig;
+  displayColor?: string;
+  displayName?: string;
+  pkg?: string;
+  /** Studio-only: forwarded to `ProjectJob.runtimeInjectionPaths`. */
+  runtimeInjectionPaths?: Array<string>;
+  testFiles: Array<string>;
+}
+interface RunProjectsOptions {
+  backend: Backend;
+  deferFormatting?: boolean;
+  parallel?: "auto" | number;
+  projects: Array<ProjectInput>;
+  scriptOverride?: string;
+  startTime: number;
+  streaming?: StreamingHooks;
+  /**
+  * Span-tree profiler owned by the top-level run. Optional so existing
+  * test seams (which exercise the executor directly) keep working without
+  * threading a collector through; production callers pass one through so
+  * the host waterfall captures `backend.runTests` + per-project
+  * post-processing.
+  */
+  timing?: TimingCollector;
+  version: string;
+  workStealing?: boolean;
+}
+interface RunProjectsResult {
+  backendTiming: BackendTiming;
+  results: Array<ExecuteResult>;
+}
+declare function formatExecuteOutput(options: FormatOutputOptions): string;
+/**
+* Unified orchestration entry point: builds jobs for every input project,
+* dispatches them through the backend in one call, shapes each raw envelope
+* entry into a `ProjectBackendResult`, then maps each through per-project
+* post-processing. Single-, multi-, and workspace-run callers all funnel
+* through here so the build→execute→shape→process sequence lives in
+* exactly one place.
+*
+* Ordering contract: the returned `results` array is in the same order as
+* `options.projects`. Backends MUST return `rawResults` in the same order
+* as the submitted `jobs` envelope — `runProjects` indexes into `jobs[i]`
+* to recover each project's resolved config and pair it with the matching
+* raw entry, so out-of-order results would post-process with the wrong
+* config.
+*/
+declare function runProjects(options: RunProjectsOptions): Promise<RunProjectsResult>;
+//#endregion
 //#region src/formatters/formatter.d.ts
 interface FormatOptions {
   collectCoverage?: boolean;
@@ -88,6 +453,8 @@ interface FormatOptions {
   outputFile?: string;
   rootDir: string;
   showLuau?: boolean;
+  slowTestThreshold?: number;
+  snapshotWriteFailures?: number;
   sourceMapper?: SourceMapper;
   typeErrors?: number;
   verbose: boolean;
@@ -100,6 +467,10 @@ interface Styles {
     received: ColorFunc;
   };
   dim: ColorFunc;
+  duration: {
+    fast: ColorFunc;
+    slow: ColorFunc;
+  };
   failBadge: ColorFunc;
   lineNumber: ColorFunc;
   location: ColorFunc;
@@ -108,6 +479,7 @@ interface Styles {
     file: ColorFunc;
   };
   runBadge: ColorFunc;
+  slowTestThreshold: number;
   status: {
     fail: ColorFunc;
     pass: ColorFunc;
@@ -139,18 +511,12 @@ declare function formatFailure({
   useColor?: boolean;
 }): string;
 declare function formatTestSummary(result: JestResult, timing: TimingResult, styles?: Styles, options?: {
+  snapshotWriteFailures?: number;
   typeErrors?: number;
 }): string;
 declare function formatResult(result: JestResult, timing: TimingResult, options: FormatOptions): string;
 //#endregion
 //#region src/formatters/github-actions.d.ts
-interface GitHubActionsOptions {
-  repository?: string;
-  serverUrl?: string;
-  sha?: string;
-  sourceMapper?: SourceMapper;
-  workspace?: string;
-}
 interface GitHubActionsFormatterOptions {
   /**
   * Whether to emit `::error` workflow commands for test failures.
@@ -210,6 +576,13 @@ interface JobSummaryOptions {
   */
   outputPath: string | undefined;
 }
+interface GitHubActionsOptions {
+  repository?: string;
+  serverUrl?: string;
+  sha?: string;
+  sourceMapper?: SourceMapper;
+  workspace?: string;
+}
 declare function formatAnnotations(result: JestResult, options: GitHubActionsOptions): string;
 declare function formatJobSummary(result: JestResult, options: GitHubActionsOptions): string;
 //#endregion
@@ -217,6 +590,188 @@ 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
+interface MappedFileCoverage {
+  b: Record<string, Array<number>>;
+  branchMap: Record<string, {
+    loc: {
+      end: {
+        column: number;
+        line: number;
+      };
+      start: {
+        column: number;
+        line: number;
+      };
+    };
+    locations: Array<{
+      end: {
+        column: number;
+        line: number;
+      };
+      start: {
+        column: number;
+        line: number;
+      };
+    }>;
+    type: string;
+  }>;
+  f: Record<string, number>;
+  fnMap: Record<string, {
+    loc: {
+      end: {
+        column: number;
+        line: number;
+      };
+      start: {
+        column: number;
+        line: number;
+      };
+    };
+    name: string;
+  }>;
+  path: string;
+  s: Record<string, number>;
+  statementMap: Record<string, {
+    end: {
+      column: number;
+      line: number;
+    };
+    start: {
+      column: number;
+      line: number;
+    };
+  }>;
+}
+interface MappedCoverageResult {
+  files: Record<string, MappedFileCoverage>;
+}
+//#endregion
+//#region src/run/types.d.ts
+type RunMode = "multi" | "single" | "workspace";
+interface ProjectResult {
+  displayColor?: string;
+  displayName: string;
+  result: ExecuteResult;
+}
+interface MultiProjectMerged {
+  coverageData?: ExecuteResult["coverageData"];
+  sourceMapper?: SourceMapper;
+}
+interface SingleRunResult {
+  mode: "single";
+  preCoverageMs: number;
+  runtimeResult?: ExecuteResult;
+  typecheckResult?: JestResult;
+  validationExitCode?: 2;
+}
+interface MultiRunResult {
+  collectCoverageFrom?: Array<string>;
+  merged: MultiProjectMerged;
+  mode: "multi";
+  preCoverageMs: number;
+  projectResults: Array<ProjectResult>;
+  typecheckResult?: JestResult;
+  validationExitCode?: 2;
+  validationMessage?: string;
+}
+interface WorkspaceRunResult {
+  /**
+  * Pre-aggregated TS-coord coverage merged from every package's
+  * `coverageData + coverageManifest`. Skips the single-package
+  * `loadCoverageManifest(rootDir)` path entirely. Undefined when
+  * `collectCoverage` is off or no package produced coverage data.
+  */
+  coverageMapped?: MappedCoverageResult;
+  /**
+  * Consensus-resolved Aggregated Game Output path the runner wrote (if any).
+  * Surfaced so formatters point "View …" hints at the file that exists,
+  * rather than the workspace-root `config.gameOutput` (which the runner does
+  * not consult).
+  */
+  gameOutput?: string;
+  merged: MultiProjectMerged;
+  mode: "workspace";
+  /** Consensus-resolved aggregated result path the runner wrote (if any). */
+  outputFile?: string;
+  preCoverageMs: number;
+  projectResults: Array<ProjectResult>;
+  typecheckResult?: JestResult;
+  validationExitCode?: 2;
+  validationMessage?: string;
+}
+type RunResult = MultiRunResult | SingleRunResult | WorkspaceRunResult;
+interface RunOptions {
+  cli: CliOptions;
+  config: ResolvedConfig;
+  /**
+  * Span-tree profiler owned by `runJestRoblox`. Optional so direct test
+  * seams keep working with the existing two-property shape; production
+  * callers always pass one through.
+  */
+  timing?: TimingCollector;
+}
+//#endregion
+//#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
+interface ReporterConfig {
+  reporter: string | ModuleScript;
+  options?: Record<string, any>;
+}
+type Argv = Partial<{
+  all: boolean;
+  automock: boolean;
+  bail: boolean | number;
+  changedSince: string;
+  ci: boolean;
+  clearCache: boolean;
+  clearMocks: boolean;
+  color: boolean;
+  colors: boolean;
+  config: string;
+  coverage: boolean;
+  debug: boolean;
+  env: string;
+  expand: boolean;
+  globals: string;
+  init: boolean;
+  injectGlobals: boolean;
+  json: boolean;
+  maxWorkers: number | string;
+  noStackTrace: boolean;
+  outputFile: string;
+  preset: string | undefined;
+  projects: Array<string>;
+  reporters: Array<string | ModuleScript | ReporterConfig>;
+  resetMocks: boolean;
+  resetModules: boolean;
+  restoreMocks: boolean;
+  rootDir: Instance;
+  roots: Array<string>;
+  runInBand: boolean;
+  selectProjects: Array<string>;
+  setupFiles: Array<ModuleScript>;
+  setupFilesAfterEnv: Array<ModuleScript>;
+  showConfig: boolean;
+  silent: boolean;
+  snapshotSerializers: Array<string>;
+  testEnvironment: string;
+  testEnvironmentOptions: string;
+  testFailureExitCode: string | undefined;
+  testMatch: Array<string>;
+  testNamePattern: string;
+  testPathIgnorePatterns: Array<string>;
+  testPathPattern: Array<string>;
+  testRegex: string | Array<string>;
+  testTimeout: number | undefined;
+  timers: string;
+  updateSnapshot: boolean;
+  verbose: boolean;
+  version: boolean;
+}>;
+//#endregion
 //#region src/test-script.d.ts
 type JestArgv = Argv & {
   snapshotFormat?: SnapshotFormatOptions;
@@ -550,4 +1105,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 ExecuteOptions, type ExecuteResult, type FormatOutputOptions, type FormatterEntry, type GameOutputEntry, type GitHubActionsFormatterOptions, type InlineProjectConfig, type JestArgv, type JestResult, type LuauSpan, type LuauVisitor, OpenCloudBackend, type ProjectEntry, type ProjectTestConfig, ROOT_ONLY_KEYS, type ResolvedConfig, type ResolvedProjectConfig, StudioBackend, type TestCaseResult, type TestDefinition, type TestFileResult, type TestStatus, type TscErrorInfo, type TypecheckOptions, buildJestArgv, createOpenCloudBackend, createStudioBackend, defineConfig, defineProject, execute, extractJsonFromOutput, formatAnnotations, formatExecuteOutput, formatFailure, formatGameOutputNotice, formatJobSummary, formatJson, formatResult, formatTestSummary, generateTestScript, loadConfig, parseGameOutput, parseJestOutput, resolveConfig, runTypecheck, visitBlock, visitExpression, visitStatement, writeGameOutput, writeJsonFile };
+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 };