ts-jest 29.4.6 → 29.4.7

package/.opencode/plans/pr1.md

@@ -0,0 +1,337 @@
+# PR 1 — New Interfaces + Config Modules
+
+## Overview
+
+Introduces `ResolvedConfigInterface` and `DiagnosticsReporterInterface` as contracts for the new
+config layer, then implements them via focused single-responsibility modules under
+`src/experimental/config/`.
+
+**User-visible change**: NO
+**Depends on**: nothing
+**Invariant**: zero changes to any existing file
+
+---
+
+## Files to Create
+
+```
+src/experimental/
+  interfaces/
+    resolved-config.interface.ts
+    diagnostics-reporter.interface.ts
+  config/
+    options-resolver.ts
+    ts-config-resolver.ts
+    diagnostics-config.ts
+    babel-config-resolver.ts
+    ast-transformer-registry.ts
+    resolved-config.ts
+    cache-suffix.ts
+```
+
+---
+
+## Requirements
+
+### `src/experimental/interfaces/resolved-config.interface.ts`
+
+Read-only config contract consumed by compilers and the transformer. No dependency on `ConfigSet`.
+
+```ts
+interface ResolvedConfigInterface {
+  readonly cwd: string
+  readonly rootDir: string
+  readonly cacheSuffix: string
+  readonly tsCacheDir: string | undefined
+  readonly useESM: boolean
+  readonly isolatedModules: boolean
+  readonly diagnosticsMode: DiagnosticsMode // 'disabled' | 'syntactic' | 'full'
+  readonly diagnostics: NormalizedDiagnosticsConfig
+  readonly parsedTsConfig: ts.ParsedCommandLine
+  readonly resolvedTransformers: ResolvedAstTransformers
+  readonly babelJestTransformer: BabelTransformer | undefined
+  readonly compiler: string // module specifier, default 'typescript'
+  shouldReportDiagnostics(filePath: string): boolean
+  shouldStringifyContent(filePath: string): boolean
+  isTestFile(filePath: string): boolean
+  raiseDiagnostics(diagnostics: ts.Diagnostic[], filePath?: string, logger?: Logger): void
+  createTsError(diagnostics: readonly ts.Diagnostic[]): TSError
+  resolvePath(inputPath: string, opts?: ResolvePathOptions): string
+}
+```
+
+All properties are `readonly`. Methods are behaviourally pure (no mutation of config state).
+
+---
+
+### `src/experimental/interfaces/diagnostics-reporter.interface.ts`
+
+```ts
+interface DiagnosticsReporterInterface {
+  raise(diagnostics: ts.Diagnostic[], filePath?: string, logger?: Logger): void
+  shouldReport(filePath: string): boolean
+  createError(diagnostics: readonly ts.Diagnostic[]): TSError
+}
+```
+
+---
+
+### `src/experimental/config/options-resolver.ts`
+
+Normalises raw `TsJestTransformerOptions` into `NormalizedTsJestOptions`.
+
+**Requirements**:
+
+- Accept `TsJestTransformerOptions` (imported from `src/types.ts`)
+- Return plain `NormalizedTsJestOptions` with all fields resolved to concrete values
+- Defaults:
+  - `compiler`: `'typescript'`
+  - `useESM`: `false`
+  - `diagnostics`: `{ warnOnly: false, ignoreCodes: [6059, 18002, 18003], exclude: [], pretty: true }`
+  - `tsconfig`: `undefined` (resolved later by `ts-config-resolver`)
+  - `babelConfig`: `undefined`
+  - `stringifyContentPathRegex`: `undefined`
+- NO call to `backportJestConfig` — v30 reads from transform options directly, not from `globals`
+
+---
+
+### `src/experimental/config/ts-config-resolver.ts`
+
+Resolves and parses `tsconfig.json`, then applies all hard overrides.
+
+**Resolution**:
+
+- `string` → resolve path relative to `cwd`; throw if not found
+- `object` → use as inline compiler options (no file on disk)
+- `undefined` → `ts.findConfigFile(rootDir, ts.sys.fileExists, 'tsconfig.json')`; fall back to empty config
+
+**Parsing**:
+
+- `ts.parseJsonConfigFileContent(rawConfig, ts.sys, basePath, undefined, tsconfigFilePath)`
+- Raise parse errors immediately via `DiagnosticsReporterInterface.raise()`
+
+**Hard overrides applied after parsing** (non-negotiable):
+
+| Override               | Value                                         |
+| ---------------------- | --------------------------------------------- |
+| `target`               | `ES2015` if not set                           |
+| `sourceMap`            | `existing ?? true`                            |
+| `inlineSources`        | same as final `sourceMap` value               |
+| `module`               | `existing ?? CommonJS`                        |
+| `outDir`               | force `'$$ts-jest$$'` if `allowJs && !outDir` |
+| `inlineSourceMap`      | **removed**                                   |
+| `declaration`          | **removed**                                   |
+| `isolatedDeclarations` | **removed**                                   |
+| `noEmit`               | **removed**                                   |
+| `removeComments`       | **removed**                                   |
+| `out`                  | **removed**                                   |
+| `outFile`              | **removed**                                   |
+| `composite`            | **removed**                                   |
+| `declarationDir`       | **removed**                                   |
+| `declarationMap`       | **removed**                                   |
+| `emitDeclarationOnly`  | **removed**                                   |
+| `sourceRoot`           | **removed**                                   |
+| `tsBuildInfoFile`      | **removed**                                   |
+
+**ESM interop warning** (push `DiagnosticCategory.Message`, do NOT throw):
+
+- Condition: no babel config AND module NOT in `[CommonJS, Node16, NodeNext, ESNext, ES2015..ES2022]`
+  AND neither `esModuleInterop` nor `allowSyntheticDefaultImports`
+- ESNext/ES2015–ES2022 are excluded (false-positive fix vs legacy behavior in `config-set.ts`)
+
+**`isolatedModules` legacy option** (from `TsJestTransformerOptions.isolatedModules`):
+
+- If set: force `parsedTsConfig.options.isolatedModules = true` + emit deprecation warning pointing
+  to tsconfig `"isolatedModules": true`
+
+---
+
+### `src/experimental/config/diagnostics-config.ts`
+
+Normalises the `diagnostics` option and derives `DiagnosticsMode`.
+
+```ts
+type DiagnosticsMode = 'disabled' | 'syntactic' | 'full'
+```
+
+**Normalisation rules**:
+
+| Input                | `throws`    | `pretty` | `ignoreCodes` | `exclude`    | DiagnosticsMode |
+| -------------------- | ----------- | -------- | ------------- | ------------ | --------------- |
+| `true` / `undefined` | `true`      | `true`   | seed codes    | `[]`         | `'full'`        |
+| `false`              | `false`     | `false`  | `[]`          | `[]`         | see note below  |
+| object               | `!warnOnly` | `true`   | seed + user   | user exclude | `'full'`        |
+
+**`diagnostics: false` in v30**:
+
+- Accepted, but emit deprecation warning: _"diagnostics: false is deprecated. Use `noCheck: true` in
+  your tsconfig instead."_
+- Treat as `throws: false, ignoreCodes: [], _shouldIgnoreDiagnosticsForFile: () => true`
+
+**`DiagnosticsMode` derivation**:
+
+- `noCheck: true` in resolved tsconfig compiler options → `'disabled'`
+- `noCheck: false` (default) → `'full'`
+- `'syntactic'` reserved for future use; never set automatically
+
+**`noCheck: true` + `warnOnly`**: silent — no deprecation warning emitted for `diagnostics: false`
+
+**Seed codes**: `[6059, 18002, 18003]` — always included
+
+**Code parsing**: support `number | string | Array<number | string>`.
+Parse string codes: `'TS2322'` → `2322`, `'2322'` → `2322`
+
+---
+
+### `src/experimental/config/babel-config-resolver.ts`
+
+Resolves the `babelConfig` option into a `BabelConfig` object or `undefined`.
+
+| Input               | Behaviour                                                                                            |
+| ------------------- | ---------------------------------------------------------------------------------------------------- |
+| `undefined` / falsy | `undefined` (no babel)                                                                               |
+| `true`              | `{ cwd }`                                                                                            |
+| `string`            | resolve path relative to `cwd`, read: `.js`/`.cjs` → `require()`, else `json5.parse(readFileSync())` |
+| `object`            | spread as-is                                                                                         |
+
+If resolved: create `babelJestTransformer` using `babel-jest` (loaded via `importer.babelJest()`).
+
+---
+
+### `src/experimental/config/ast-transformer-registry.ts`
+
+Resolves `TsJestTransformerOptions.transform` into `ResolvedAstTransformers`.
+
+**Requirements**:
+
+- `before` always starts with `[hoistJestTransformer]` — user `before` transformers **appended** after
+  (not prepended before)
+- `.ts` / `.tsx` transformer file paths: compile with esbuild before `require()`
+- Each descriptor: `{ factory: Function, version: number, name: string, options?: unknown }`
+- Preserve order: `before`, `after`, `afterDeclarations`
+
+---
+
+### `src/experimental/config/cache-suffix.ts`
+
+Computes a deterministic sha1 cache suffix.
+
+**Inputs hashed in this exact order**:
+
+1. TypeScript version string
+2. `MY_DIGEST` — `readFileSync('.ts-jest-digest')` at module load time (module-level constant)
+3. Serialised babel config (or empty string)
+4. Serialised tsconfig compiler options
+5. Raw tsconfig JSON string
+6. `isolatedModules` boolean
+7. Serialised diagnostics config
+8. Transformer names + versions sorted by name
+
+**Output**: `sha1(inputs.join(''))` — 40 hex chars
+
+`tsCacheDir` derivation (computed in `resolved-config.ts`):
+
+```ts
+join(jestConfig.cacheDirectory, 'ts-jest', suffix.slice(0, 2), suffix.slice(2))
+```
+
+---
+
+### `src/experimental/config/resolved-config.ts`
+
+Assembles all config modules into `ResolvedConfig implements ResolvedConfigInterface`.
+
+**Constructor inputs**: `jestConfig: Config.ProjectConfig`, `transformerOptions: TsJestTransformerOptions`
+
+**Construction sequence**:
+
+1. `options-resolver` → `NormalizedTsJestOptions`
+2. `cwd = normalize(jestConfig.cwd ?? process.cwd())`
+3. `rootDir = normalize(jestConfig.rootDir ?? cwd)`
+4. `importer.typescript(reason, options.compiler)` → load TS module
+5. `babel-config-resolver` → `babelConfig + babelJestTransformer`
+6. `diagnostics-config` → `NormalizedDiagnosticsConfig + DiagnosticsMode`
+7. `ts-config-resolver` → `ParsedCommandLine` (passes diagnostics reporter for parse errors)
+8. `ast-transformer-registry` → `ResolvedAstTransformers`
+9. `cache-suffix` → `cacheSuffix`
+10. `tsCacheDir` — computed if `jestConfig.cache && jestConfig.cacheDirectory`
+11. `isolatedModules = parsedTsConfig.options.isolatedModules ?? false`
+
+**Method implementations**:
+
+`shouldReportDiagnostics(filePath)`:
+
+- JS/JSX → only if `checkJs: true` AND not matched by any exclude glob
+- all others → not matched by any exclude glob
+
+`shouldStringifyContent(filePath)`:
+
+- test against compiled `stringifyContentPathRegex`; `false` if option not set
+
+`isTestFile(filePath)`:
+
+- check against `testMatch`/`testRegex` from jest config; fall back to `DEFAULT_JEST_TEST_MATCH`
+
+`raiseDiagnostics(diagnostics, filePath?, logger?)`:
+
+- filter: `shouldReportDiagnostics(filePath)` AND code not in `ignoreCodes`
+- if any `Warning | Error` in filtered set AND `throws: true` → throw `TSError`
+- else → `logger.warn` each
+
+`createTsError(diagnostics)`:
+
+- format with `ts.formatDiagnosticsWithColorAndContext` (pretty) or `ts.formatDiagnostics` (plain)
+- return `new TSError(formatted)`
+
+`resolvePath(input, opts)`:
+
+1. `<rootDir>` prefix → `join(rootDir, input.slice('<rootDir>'.length))`
+2. relative without leading `.` AND `nodeResolve: true` → try `require.resolve(input)` first
+3. else → `resolve(cwd, input)`
+4. final `require.resolve` attempt if `nodeResolve: true` and not yet resolved
+5. if `throwIfMissing: true` (default) and file not found → throw
+
+---
+
+## Import Rules
+
+- `src/utils/*` — allowed (sha1, logger, importer, memoize, ts-error, messages, json, diagnostics)
+- `src/utils/backports.ts` — NOT imported (no legacy config backport in v30)
+- `src/types.ts` — allowed (TsJestTransformerOptions and related public types)
+- `src/constants.ts` — allowed
+- `src/legacy/**` — FORBIDDEN
+- `src/config/**` — FORBIDDEN
+- `src/transpilers/**` — FORBIDDEN
+- `src/transformers/**` — FORBIDDEN
+
+---
+
+## Test Requirements
+
+Each module gets its own unit test under `src/experimental/config/__tests__/`.
+
+| Test file                          | Key scenarios                                                                                                                             |
+| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `options-resolver.spec.ts`         | all defaults applied; each option normalised correctly                                                                                    |
+| `ts-config-resolver.spec.ts`       | string/object/undefined tsconfig; parse errors raised; each hard override; ESM interop warning conditions (incl. ESNext excluded)         |
+| `diagnostics-config.spec.ts`       | all input shapes; DiagnosticsMode derivation; noCheck:true → disabled; noCheck:true + warnOnly → silent; code parsing `'TS2322'` → `2322` |
+| `babel-config-resolver.spec.ts`    | each config shape; `.js` vs `.cjs` vs `.json` read paths                                                                                  |
+| `ast-transformer-registry.spec.ts` | hoistJest always first in before; user before appended not prepended; .ts compiled with esbuild                                           |
+| `cache-suffix.spec.ts`             | deterministic output; changes when any single input changes                                                                               |
+| `resolved-config.spec.ts`          | full construction; shouldReportDiagnostics; resolvePath all branches; raiseDiagnostics throw vs warn                                      |
+
+**Existing tests must remain green** (no changes to legacy):
+
+- `src/legacy/config/config-set.spec.ts`
+
+---
+
+## Acceptance Criteria
+
+- [ ] All new unit tests pass (`npm test -- --testPathPattern=experimental/config`)
+- [ ] `config-set.spec.ts` unmodified and green
+- [ ] `tsc --noEmit` passes over new files
+- [ ] No import from `src/legacy/`, `src/config/`, `src/transpilers/`, `src/transformers/`
+- [ ] `src/utils/backports.ts` not imported anywhere in `src/experimental/`
+- [ ] Every exported symbol has a TSDoc comment
+- [ ] No `any` types without explicit `// eslint-disable` justification

package/.opencode/plans/pr2.md

@@ -0,0 +1,280 @@
+# PR 2 — New Compiler Implementations + CompilerInterface
+
+## Overview
+
+Introduces `CompilerInterface` and two clean-room compiler implementations:
+
+- `LanguageServiceCompiler` — full `ts.Program` with type checking
+- `FastTranspileCompiler` — `ts.transpileModule`, used only when type checking is explicitly disabled
+
+**User-visible change**: NO
+**Depends on**: PR 1 (`ResolvedConfigInterface`, `DiagnosticsMode`)
+**Invariant**: zero changes to any existing file
+
+---
+
+## Files to Create
+
+```
+src/experimental/
+  interfaces/
+    compiler.interface.ts
+  compiler/
+    memory-cache.ts
+    language-service-compiler.ts
+    fast-transpile-compiler.ts
+    module-kind-fixup.ts
+    transformer-factory.ts
+```
+
+---
+
+## Requirements
+
+### `src/experimental/interfaces/compiler.interface.ts`
+
+```ts
+interface CompilerInterface {
+  getCompiledOutput(fileContent: string, filePath: string, options: TsJestCompileOptions): CompiledOutput
+
+  getResolvedModules(fileContent: string, filePath: string, runtimeCacheFS: Map<string, string>): string[]
+}
+```
+
+`TsJestCompileOptions` and `CompiledOutput` imported from `src/types.ts`.
+
+---
+
+### `src/experimental/compiler/memory-cache.ts`
+
+Extracted from `TsCompiler` lines 59–91, 486–518. Manages per-file content/version tracking used
+by the Language Service host.
+
+**Exported types/functions**:
+
+```ts
+interface MemoryCacheEntry {
+  version: number
+  content: string | undefined
+}
+
+class MemoryCache {
+  private _files: Map<string, MemoryCacheEntry>
+  private _projectVersion: number
+
+  constructor(initialFiles: string[])
+
+  // Seed version=0 for all initial files (non-test TS/TSX from fileNames)
+  // getScriptVersion returns `undefined` (not "undefined") for unknown files
+  getScriptVersion(filePath: string): number | undefined
+  getContent(filePath: string): string | undefined
+
+  update(filePath: string, content: string, moduleKind: ts.ModuleKind): boolean
+  // Returns true and increments _projectVersion ONLY when:
+  // - file is new
+  // - content changed
+  // - file was not previously in fileNames
+  // - module kind changed
+
+  getProjectVersion(): string // cast to string for LS host protocol
+  list(): string[]
+}
+```
+
+**Critical**: `getScriptVersion` must return `undefined` (the value), NOT `"undefined"` (string),
+for unknown files. Returning the string causes spurious `createProgram` calls in the LS.
+
+---
+
+### `src/experimental/compiler/module-kind-fixup.ts`
+
+Pure function — no side effects. Normalises `ts.CompilerOptions` based on CJS vs ESM target.
+
+```ts
+function fixupModuleKind(options: ts.CompilerOptions, useESM: boolean, supportsStaticESM: boolean): ts.CompilerOptions
+```
+
+**CJS path** (`!useESM || !supportsStaticESM`):
+
+```ts
+{ ...options, module: ts.ModuleKind.CommonJS, moduleResolution: ts.ModuleResolutionKind.Node10, customConditions: undefined }
+```
+
+**ESM path**:
+
+- Keep `module` as ESNext (or existing if already ESNext)
+- If original `module` was Node16 or NodeNext: force `esModuleInterop: true`, coerce module to ESNext
+- Keep `moduleResolution` as-is for ESM
+
+---
+
+### `src/experimental/compiler/transformer-factory.ts`
+
+Maps `ResolvedAstTransformers` → `ts.CustomTransformers`.
+
+```ts
+function makeTransformers(
+  transformers: ResolvedAstTransformers,
+  compilerInstance: CompilerInterface,
+): ts.CustomTransformers
+```
+
+- Calls each `AstTransformerDesc.factory(compilerInstance, options)` to produce transformer functions
+- Returns `{ before: [...], after: [...], afterDeclarations: [...] }`
+
+---
+
+### `src/experimental/compiler/language-service-compiler.ts`
+
+Full TypeScript Language Service path. Used when `diagnosticsMode !== 'disabled'`.
+
+**Constructor**:
+
+```ts
+constructor(config: ResolvedConfigInterface, runtimeCacheFS: Map<string, string>)
+```
+
+**Initialisation sequence**:
+
+1. Assign `_config`, `_runtimeCacheFS`
+2. `_memoryCache = new MemoryCache(config.parsedTsConfig.fileNames)` — seed non-test TS/TSX files
+3. `_moduleResolutionCache = ts.createModuleResolutionCache(...)`
+4. `_cachedReadFile = memoize(ts.sys.readFile)` — from `src/utils/memoize.ts`
+5. `_createLanguageService()` — builds LS host + creates service
+
+**Language Service Host** (`ts.LanguageServiceHost`):
+
+- `getScriptVersion(file)` → `_memoryCache.getScriptVersion(file)?.toString() ?? undefined`
+- `getScriptSnapshot(file)`:
+  1. Check `_memoryCache.getContent(file)`
+  2. Check `_runtimeCacheFS.get(file)`
+  3. Fall back to `_cachedReadFile(file)`
+  - Return `ts.ScriptSnapshot.fromString(content)` or `undefined`
+- `getProjectVersion()` → `_memoryCache.getProjectVersion()`
+- `resolveModuleNames()` → use `_moduleResolutionCache` for perf
+
+**`getCompiledOutput(fileContent, filePath, options)`**:
+
+1. `_memoryCache.update(filePath, fileContent, moduleKind)`
+2. Apply `fixupModuleKind` to compiler options based on `options.supportsStaticESM`
+3. `customTransformers = makeTransformers(config.resolvedTransformers, this)`
+4. Emit via `_languageService.getEmitOutput(filePath, false)`
+5. Collect diagnostics: `getSemanticDiagnostics` + `getSyntacticDiagnostics`
+6. In watch mode: also re-check all files that import `filePath`
+7. Handle emit results:
+   - `emitSkipped && isTs/Tsx` → throw `Error('emit skipped for TS file')`
+   - `emitSkipped && !isTs/Tsx` → warn + return original `fileContent`
+   - `outputFiles.length === 0` → throw `TypeError` (catches `.d.ts` require attempts)
+   - `sourceMap enabled`: `code = outputFiles[1].text`, map from `outputFiles[0].text`
+   - `sourceMap disabled`: `code = outputFiles[0].text`
+8. Apply `updateOutput(code, filePath, sourceMap)` from `src/legacy/compiler/compiler-utils.ts`
+   - **Exception**: `compiler-utils.ts` is in `src/legacy/` — reimplement `updateOutput` logic inline
+     or in `src/experimental/compiler/output-utils.ts`
+9. If `ModernNodeModule` kind: emit info diagnostic
+10. JS file + `!allowJs`: passthrough with warning
+
+**`getResolvedModules(fileContent, filePath, runtimeCacheFS)`**:
+
+1. `ts.preProcessFile(fileContent)` → `importedFiles`
+2. Resolve each import relative to `filePath` using TS module resolution
+3. Recurse into resolved paths
+4. Deduplicate
+5. Filter out `isExternalLibraryImport: true`
+6. Return array of absolute file paths
+
+---
+
+### `src/experimental/compiler/fast-transpile-compiler.ts`
+
+`ts.transpileModule`-based path. Used only when `diagnosticsMode === 'disabled'` (i.e. `noCheck: true`
+in tsconfig).
+
+**Constructor**:
+
+```ts
+constructor(config: ResolvedConfigInterface)
+```
+
+**`getCompiledOutput(fileContent, filePath, options)`**:
+
+1. Apply `fixupModuleKind` to compiler options
+2. `customTransformers = makeTransformers(config.resolvedTransformers, this)`
+3. Choose transpile path based on module kind:
+   - Non-modern (not Node16/NodeNext/Node18/Node20): native `ts.transpileModule(fileContent, { compilerOptions, transformers, fileName: filePath })`
+   - Modern node module kind: `tsTranspileModule(...)` from `src/transpilers/typescript/transpile-module.ts`
+     — exposes Program to custom transformers
+4. Apply `updateOutput` to result
+5. Return `CompiledOutput`
+
+**`getResolvedModules()`**: always returns `[]`
+
+**Guard**: if `config.diagnosticsMode !== 'disabled'`:
+
+```
+throw new Error(
+  'FastTranspileCompiler requires diagnosticsMode: disabled (noCheck: true in tsconfig). ' +
+  'Remove noCheck from your tsconfig to use full type checking.'
+)
+```
+
+---
+
+### `src/experimental/compiler/output-utils.ts`
+
+Reimplementation of `updateOutput` logic (avoids importing from `src/legacy/`).
+
+```ts
+function updateOutput(outputText: string, fileName: string, sourceMap?: string): string
+```
+
+If `sourceMap`:
+
+- Inline as base64 data URI
+- Replace last `sourceMappingURL=` occurrence in `outputText`
+
+Mirrors behavior of `src/legacy/compiler/compiler-utils.ts:updateOutput`.
+
+---
+
+## Import Rules
+
+- `src/utils/*` — allowed
+- `src/transpilers/typescript/transpile-module.ts` — allowed for `fast-transpile-compiler.ts` only
+- `src/types.ts` — allowed (`TsJestCompileOptions`, `CompiledOutput`, `AstTransformerDesc`)
+- `src/experimental/interfaces/*` — allowed
+- `src/experimental/config/*` — allowed
+- `src/legacy/**` — FORBIDDEN (including `compiler-utils.ts`)
+- `src/config/**` — FORBIDDEN
+- `src/transformers/**` — FORBIDDEN
+
+---
+
+## Test Requirements
+
+Unit tests under `src/experimental/compiler/__tests__/`.
+
+| Test file                           | Key scenarios                                                                                                                                                                                                            |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `memory-cache.spec.ts`              | seed version=0; getScriptVersion returns `undefined` (not `"undefined"`) for unknown file; update increments projectVersion only on change; module kind change triggers increment                                        |
+| `module-kind-fixup.spec.ts`         | CJS: forces CommonJS + Node10 + clears customConditions; ESM Node16/NodeNext: coerces to ESNext + forces esModuleInterop; ESM other: keeps as-is                                                                         |
+| `transformer-factory.spec.ts`       | calls factory with compiler instance; returns correct CustomTransformers shape                                                                                                                                           |
+| `language-service-compiler.spec.ts` | emitSkipped + TS → throws; emitSkipped + JS → warns + returns original; no outputFiles → throws TypeError; sourceMap enabled → outputFiles[1]; getResolvedModules deduplicates; JS + !allowJs → passthrough with warning |
+| `fast-transpile-compiler.spec.ts`   | non-modern module → native transpileModule; modern module → tsTranspileModule; getResolvedModules → []; diagnosticsMode !== disabled → throws                                                                            |
+| `output-utils.spec.ts`              | no sourceMap → returns as-is; with sourceMap → inlines base64; replaces last sourceMappingURL only                                                                                                                       |
+
+**Existing tests must remain green** (no changes to legacy):
+
+- `src/legacy/compiler/ts-compiler.spec.ts`
+- `src/legacy/compiler/ts-jest-compiler.spec.ts`
+
+---
+
+## Acceptance Criteria
+
+- [ ] All new unit tests pass
+- [ ] `ts-compiler.spec.ts` and `ts-jest-compiler.spec.ts` unmodified and green
+- [ ] `tsc --noEmit` passes
+- [ ] No import from `src/legacy/`
+- [ ] `FastTranspileCompiler.getResolvedModules()` returns `[]`
+- [ ] `MemoryCache.getScriptVersion()` returns `undefined` (value) not `"undefined"` (string) for unknown files
+- [ ] Every exported symbol has TSDoc