@depup/ts-jest 29.4.9-depup.0 → 29.4.14-depup.0

package/.ts-jest-digest

@@ -1 +1 @@
-58edfe49f3f9192570efa8fa26d9cbc324d1324e
+44df70f98f3cf89af95cce14fa68674b52acbfd3

package/CHANGELOG.md

@@ -1,3 +1,69 @@
+## [29.4.14](https://github.com/kulshekhar/ts-jest/compare/v29.4.13...v29.4.14) (2026-09-25)
+
+
+### Reverts
+
+* bring back prior changes of compiler util ([#5471](https://github.com/kulshekhar/ts-jest/issues/5471)) ([01e5a2e](https://github.com/kulshekhar/ts-jest/commit/01e5a2e17ac9c940880865d6a81751832dcc4184)), closes [#5469](https://github.com/kulshekhar/ts-jest/issues/5469)
+
+## [29.4.13](https://github.com/kulshekhar/ts-jest/compare/v29.4.12...v29.4.13) (2026-09-22)
+
+
+### Features
+
+* support Babel 8 ([#5466](https://github.com/kulshekhar/ts-jest/issues/5466)) ([c3a0b57](https://github.com/kulshekhar/ts-jest/commit/c3a0b57c00d8b6acfb72b020e2411752d39073e2)), closes [#5412](https://github.com/kulshekhar/ts-jest/issues/5412)
+
+
+### Performance Improvements
+
+* **compiler:** cache module resolution modes ([#5419](https://github.com/kulshekhar/ts-jest/issues/5419)) ([697d337](https://github.com/kulshekhar/ts-jest/commit/697d337c1b79a0804972a3d30c0875b02e73bf62)), closes [#5402](https://github.com/kulshekhar/ts-jest/issues/5402)
+
+## [29.4.12](https://github.com/kulshekhar/ts-jest/compare/v29.4.11...v29.4.12) (2026-07-22)
+
+
+### Features
+
+* **compiler:** support TypeScript 7 projects through compatibility aliases ([#5386](https://github.com/kulshekhar/ts-jest/pull/5386))
+
+## [29.4.11](https://github.com/kulshekhar/ts-jest/compare/v29.4.10...v29.4.11) (2026-05-21)
+
+
+### Bug Fixes
+
+* preserve Bundler on the CJS path under TypeScript >= 6 ([3941818](https://github.com/kulshekhar/ts-jest/commit/39418187515f11b6584d35a4e3ddf50231f74936)), closes [#4198](https://github.com/kulshekhar/ts-jest/issues/4198)
+
+
+
+## [29.4.10](https://github.com/kulshekhar/ts-jest/compare/v29.4.9...v29.4.10) (2026-05-18)
+
+
+### Bug Fixes
+
+* pass `resolutionMode` to `ts.resolveModuleName` for hybrid module support ([b557a85](https://github.com/kulshekhar/ts-jest/commit/b557a85f85c3fd34523ec3a15293afbdc9dea83c))
+* rebuild `Program` when consecutive compiles need different module kinds ([a82a2b3](https://github.com/kulshekhar/ts-jest/commit/a82a2b32c4987a5249fd5284283117dd2fa3be47)), closes [#4774](https://github.com/kulshekhar/ts-jest/issues/4774)
+* respect tsconfig `moduleResolution` instead of forcing `Node10` ([1bffffc](https://github.com/kulshekhar/ts-jest/commit/1bffffc667557c173ae0c1f93dd436920775dac4))
+* **transformer:** transpile `mjs` files from `node_modules` for CJS mode ([96d025d](https://github.com/kulshekhar/ts-jest/commit/96d025dd912ea2bceb18b67d2d509ada7a756d9d))
+* **transformer:** use a consistent comparator in hoist-jest sortStatements ([8a8fd2f](https://github.com/kulshekhar/ts-jest/commit/8a8fd2fb8446655bba18367db9306a1089490e62))
+
+
+
+## [29.4.9](https://github.com/kulshekhar/ts-jest/compare/v29.4.8...v29.4.9) (2026-04-01)
+
+
+### Bug Fixes
+
+* use correct registry for npm OIDC trusted publishing ([f8a9cc9](https://github.com/kulshekhar/ts-jest/commit/f8a9cc9892))
+
+
+
+## [29.4.8](https://github.com/kulshekhar/ts-jest/compare/v29.4.7...v29.4.8) (2026-04-01)
+
+
+### Bug Fixes
+
+* wrong published assets
+
+
+
 ## [29.4.7](https://github.com/kulshekhar/ts-jest/compare/v29.4.6...v29.4.7) (2026-04-01)
 
 
@@ -5,6 +71,8 @@
 
 * support TypeScript v6 ([eda517d](https://github.com/kulshekhar/ts-jest/commit/eda517d226389317d99572887d3c1aa93c81be87))
 
+
+
 ## [29.4.6](https://github.com/kulshekhar/ts-jest/compare/v29.4.5...v29.4.6) (2025-12-01)
 
 
@@ -2029,4 +2097,3 @@ For example
 # 0.0.0 (2016-08-30)
 
 
-

package/CONTRIBUTING.md

@@ -48,28 +48,14 @@ this is where you will write it in. Tests here usually don't require much if any
 
 ##### Integration tests
 
-There will be situations however where the work you have done cannot be tested alone using unit tests. In situations like this,
-you should write an integration test for your code. The integration tests reside within the `e2e` directory.
-Within this directory, there is a `__tests__` directory. This is where you will write the integration test itself.
-The tests within this directory execute jest itself using `run-jest.ts` and assertions are usually made on one if not all
-the output of the following `status`, `stdout` and `stderr`. The other subdirectories within the `e2e` directory are
-where you will write the files that jest will run for your integration tests. Feel free to take a look at any of the tests
-in the `__tests__` directory within `e2e` to have a better sense of how it is currently being done.
-
-It is possible to run the integration test itself manually to inspect that the new behaviour is indeed correct.
-Here is a small code snippet of how to do just that. This is useful when debugging a failing test.
+Integration tests reside in `e2e`. Controller tests under `e2e/__tests__` select isolated fixture projects and execute
+their local Jest configurations through `run-jest.ts`. Each fixture owns its package metadata, Jest configuration,
+TypeScript configuration, source files, and tests. Dependencies and lockfiles belong only to fixtures that require them.
 
 ```bash
-$ cd e2e/test-utils
-$ node ../../node_modules/jest/bin/jest.js # It is possible to use node --inspect or ndb
-PASS  __tests__/test-utils.spec.ts
-✓ stub (3ms)
-
-Test Suites: 1 passed, 1 total
-Tests:       1 passed, 1 total
-Snapshots:   0 total
-Time:        0.232 s, estimated 1 s
-Ran all test suites.
+npm run build
+npm run test-e2e
+npm run test-e2e -- --runTestsByPath e2e/__tests__/test-utils.test.ts
 ```
 
 ### Additional Workflow for any changes made to website or docs

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/ts-jest
 
 | Field | Value |
 |-------|-------|
-| Original | [ts-jest](https://www.npmjs.com/package/ts-jest) @ 29.4.9 |
-| Processed | 2026-04-01 |
+| Original | [ts-jest](https://www.npmjs.com/package/ts-jest) @ 29.4.14 |
+| Processed | 2026-09-27 |
 | Smoke test | passed |
 | Deps updated | 2 |
 
@@ -22,7 +22,7 @@ npm install @depup/ts-jest
 
 | Dependency | From | To |
 |------------|------|-----|
-| type-fest | ^4.41.0 | ^5.5.0 |
+| type-fest | ^4.41.0 | ^5.10.0 |
 | yargs-parser | ^21.1.1 | ^22.0.0 |
 
 ---

package/changes.json

@@ -2,13 +2,13 @@
   "bumped": {
     "type-fest": {
       "from": "^4.41.0",
-      "to": "^5.5.0"
+      "to": "^5.10.0"
     },
     "yargs-parser": {
       "from": "^21.1.1",
       "to": "^22.0.0"
     }
   },
-  "timestamp": "2026-04-01T16:26:12.292Z",
+  "timestamp": "2026-09-27T01:04:34.958Z",
   "totalUpdated": 2
 }

package/dist/cli/config/migrate.js

@@ -32,9 +32,9 @@ const migrateGlobalConfigToTransformConfig = (transformConfig, globalsTsJestConf
 };
 const migratePresetToTransformConfig = (transformConfig, preset, globalsTsJestConfig) => {
     if (preset) {
-        const transformConfigFromPreset = preset.name === "ts-jest/presets/js-with-ts" /* JestPresetNames.jsWithTs */
+        const transformConfigFromPreset = preset.name === presets_1.JestPresetNames.jsWithTs
             ? (0, create_jest_preset_1.createJsWithTsPreset)(globalsTsJestConfig)
-            : preset.name === "ts-jest/presets/js-with-babel" /* JestPresetNames.jsWIthBabel */
+            : preset.name === presets_1.JestPresetNames.jsWIthBabel
                 ? (0, create_jest_preset_1.createJsWithBabelPreset)(globalsTsJestConfig)
                 : (0, create_jest_preset_1.createDefaultPreset)(globalsTsJestConfig);
         return {
@@ -72,14 +72,14 @@ const run = async (args /* , logger: Logger*/) => {
     let preset;
     if (migratedConfig.preset) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        preset = presets_1.allPresets[migratedConfig.preset] ?? presets_1.allPresets["ts-jest/presets/default" /* JestPresetNames.default */];
+        preset = presets_1.allPresets[migratedConfig.preset] ?? presets_1.allPresets[presets_1.JestPresetNames.default];
     }
     else {
         if (args.js) {
-            preset = args.js === 'babel' ? presets_1.allPresets["ts-jest/presets/js-with-babel" /* JestPresetNames.jsWIthBabel */] : presets_1.allPresets["ts-jest/presets/js-with-ts" /* JestPresetNames.jsWithTs */];
+            preset = args.js === 'babel' ? presets_1.allPresets[presets_1.JestPresetNames.jsWIthBabel] : presets_1.allPresets[presets_1.JestPresetNames.jsWithTs];
         }
         else {
-            preset = presets_1.allPresets["ts-jest/presets/default" /* JestPresetNames.default */];
+            preset = presets_1.allPresets[presets_1.JestPresetNames.default];
         }
     }
     // check the extensions

package/dist/cli/helpers/presets.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsWIthBabel = exports.jsWithTs = exports.defaults = exports.allPresets = void 0;
+exports.jsWIthBabel = exports.jsWithTs = exports.defaults = exports.allPresets = exports.JestPresetNames = void 0;
+/** @internal */
+var JestPresetNames;
+(function (JestPresetNames) {
+    JestPresetNames["default"] = "ts-jest/presets/default";
+    JestPresetNames["jsWithTs"] = "ts-jest/presets/js-with-ts";
+    JestPresetNames["jsWIthBabel"] = "ts-jest/presets/js-with-babel";
+})(JestPresetNames || (exports.JestPresetNames = JestPresetNames = {}));
 const definePreset = (fullName) => ({
     fullName,
     get name() {
@@ -27,15 +34,15 @@ const definePreset = (fullName) => ({
         return `const { ${this.jsVarName}: ${varName} } = require('ts-jest/presets')`;
     },
     get isDefault() {
-        return fullName === "ts-jest/presets/default" /* JestPresetNames.default */;
+        return fullName === JestPresetNames.default;
     },
 });
 /** @internal */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 exports.allPresets = {};
 /** @internal */
-exports.defaults = (exports.allPresets["ts-jest/presets/default" /* JestPresetNames.default */] = definePreset("ts-jest/presets/default" /* JestPresetNames.default */));
+exports.defaults = (exports.allPresets[JestPresetNames.default] = definePreset(JestPresetNames.default));
 /** @internal */
-exports.jsWithTs = (exports.allPresets["ts-jest/presets/js-with-ts" /* JestPresetNames.jsWithTs */] = definePreset("ts-jest/presets/js-with-ts" /* JestPresetNames.jsWithTs */));
+exports.jsWithTs = (exports.allPresets[JestPresetNames.jsWithTs] = definePreset(JestPresetNames.jsWithTs));
 /** @internal */
-exports.jsWIthBabel = (exports.allPresets["ts-jest/presets/js-with-babel" /* JestPresetNames.jsWIthBabel */] = definePreset("ts-jest/presets/js-with-babel" /* JestPresetNames.jsWIthBabel */));
+exports.jsWIthBabel = (exports.allPresets[JestPresetNames.jsWIthBabel] = definePreset(JestPresetNames.jsWIthBabel));

package/dist/config/paths-to-module-name-mapper.js

@@ -14,7 +14,7 @@ const pathsToModuleNameMapper = (mapping, { prefix = '', useESM = false } = {})
         const toPaths = mapping[fromPath];
         // check that we have only one target path
         if (toPaths.length === 0) {
-            logger.warn((0, messages_1.interpolate)("Not mapping \"{{path}}\" because it has no target." /* Errors.NotMappingPathWithEmptyMap */, { path: fromPath }));
+            logger.warn((0, messages_1.interpolate)(messages_1.Errors.NotMappingPathWithEmptyMap, { path: fromPath }));
             continue;
         }
         // split with '*'
@@ -41,7 +41,7 @@ const pathsToModuleNameMapper = (mapping, { prefix = '', useESM = false } = {})
             jestMap[cjsPattern] = paths.length === 1 ? paths[0] : paths;
         }
         else {
-            logger.warn((0, messages_1.interpolate)("Not mapping \"{{path}}\" because it has more than one star (`*`)." /* Errors.NotMappingMultiStarPath */, { path: fromPath }));
+            logger.warn((0, messages_1.interpolate)(messages_1.Errors.NotMappingMultiStarPath, { path: fromPath }));
         }
     }
     if (useESM) {

package/dist/legacy/compiler/ts-compiler.d.ts

@@ -20,8 +20,116 @@ export declare class TsCompiler implements TsCompilerInstance {
     program: Program | undefined;
     constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);
     getResolvedModules(fileContent: string, fileName: string, runtimeCacheFS: StringMap): string[];
+    /**
+     * Apply ts-jest's runtime fixups on top of the user's compiler options before
+     * handing them to the language service or transpiler.
+     *
+     * Two compiler-options now flow through dedicated helpers so the produced
+     * options are always a TypeScript-valid combination:
+     *
+     *   - `moduleResolution` is delegated to `resolveCompatibleModuleResolution`,
+     *     which preserves the user's value when it is valid alongside the
+     *     `module` ts-jest forces at runtime (CommonJS on the CJS path, or
+     *     ESNext / the user's original `module` on the ESM path) and otherwise
+     *     substitutes a TypeScript-valid alternative. When the user has not set
+     *     a value the historical Node10 default is kept, so unchanged tsconfigs
+     *     see the exact same resolved options as before.
+     *
+     *   - `customConditions` is delegated to `preserveCustomConditionsIfCompatible`,
+     *     which keeps the user's value only when the resolved
+     *     `moduleResolution` supports it (`Bundler` / `Node16` / `NodeNext`)
+     *     and clears it otherwise. The pre-#4198 code unconditionally cleared
+     *     this option because the hardcoded `Node10` override always made it
+     *     incompatible; that is no longer true.
+     *
+     * @see https://github.com/kulshekhar/ts-jest/issues/4198
+     */
     private fixupCompilerOptionsForModuleKind;
+    /**
+     * Pick a `moduleResolution` value that is valid alongside the `module` ts-jest
+     * forces at runtime. Closes #4198: previously this was hardcoded to Node10 and
+     * silently overrode whatever the user set in tsconfig, even when the user value
+     * would have been valid (e.g. Bundler with module: ESNext, Classic with CommonJS).
+     *
+     * Substitution rules — each tied to a specific TypeScript diagnostic that the
+     * resulting combination would otherwise raise. The "Bundler-compatible" set is
+     * the one defined by `isBundlerCompatibleModuleKind` (ES2015 / ES2020 / ES2022
+     * / ESNext / Preserve); everything else (CommonJS / AMD / UMD / System / None)
+     * is treated as Bundler-incompatible across the full supported TS range.
+     *
+     *   - Node16 / NodeNext require `module: Node16` or `module: NodeNext` (TS5110).
+     *     ts-jest never emits those module kinds, so these user-supplied values are
+     *     substituted: to Bundler when the forced module is in the
+     *     Bundler-compatible set, or to Node10 otherwise. (Pairing Bundler with a
+     *     non-ES module raises TS5095, and Node10 is the only kind that has been
+     *     valid with non-ES modules across every TypeScript version ts-jest
+     *     supports.)
+     *
+     *   - User-supplied Bundler with a non-Bundler-compatible forced module is
+     *     TS5095, substitute Node10. (TypeScript 6 relaxed this for
+     *     `module: CommonJS` specifically; that relaxation is encoded inside
+     *     `isBundlerCompatibleModuleKind` via a runtime version check, so on
+     *     TS ≥ 6 user-supplied Bundler passes through unchanged on the CJS
+     *     path.)
+     *
+     *   - Anything else (Node10 / Classic / unset) passes through or falls back
+     *     to Node10. These pairings are valid with every forced module kind.
+     *
+     * Compatibility: `ModuleResolutionKind.Bundler` was introduced in
+     * TypeScript 5.0. ts-jest declares `peerDependencies: { typescript: ">=4.3 <7" }`,
+     * so the Bundler member is `undefined` at runtime on TypeScript 4.3 - 4.9.
+     * The Node16/NodeNext substitution falls back to Node10 in that case
+     * (`bundlerResolution` below) to keep the function deterministic across the
+     * full supported range. Users on TypeScript < 5 can never have set Bundler in
+     * tsconfig (the parser rejects it), so the user-supplied-Bundler branch is
+     * unreachable there and needs no separate guard.
+     */
+    private resolveCompatibleModuleResolution;
+    /**
+     * TypeScript pairs `moduleResolution: bundler` only with ES-module module
+     * kinds (`ES2015` / `ES2020` / `ES2022` / `ESNext`) or `Preserve` (added in
+     * TypeScript 5.4). Pairing `bundler` with `CommonJS`, `AMD`, `UMD`, `System`,
+     * or `None` raises TS5095. Used by `resolveCompatibleModuleResolution` to
+     * gate the `Node16` / `NodeNext` → `Bundler` substitution and the
+     * user-supplied-`Bundler` pass-through, so neither path emits an invalid
+     * pair when the user has selected a non-ES `module`.
+     *
+     * TypeScript 6.0 relaxed TS5095 for `module: CommonJS` specifically
+     * (`CommonJS` + `Bundler` is a valid pair on TS ≥ 6); the other non-ES
+     * module kinds (`AMD` / `UMD` / `System` / `None`) remain Bundler-incompatible
+     * on every TypeScript version. The version is detected at runtime from
+     * `this._ts.version` so the function stays correct across the full
+     * peerDependency range (`>=4.3 <7`).
+     *
+     * @see https://www.typescriptlang.org/tsconfig/#moduleResolution
+     */
+    private isBundlerCompatibleModuleKind;
+    /**
+     * Pass `customConditions` through unchanged when the resolved
+     * `moduleResolution` is one of the kinds that supports it (`Bundler`,
+     * `Node16`, `NodeNext`); strip it otherwise. TypeScript raises TS5098
+     * when `customConditions` is paired with any other resolution kind
+     * (verified empirically against TypeScript 5.9.3 with `tsc -p`).
+     *
+     * Before #4198 the surrounding `fixupCompilerOptionsForModuleKind`
+     * unconditionally cleared `customConditions` because the hardcoded
+     * `Node10` override always made it incompatible. After #4198 the
+     * resolved `moduleResolution` can be `Bundler` (e.g. when the user
+     * has `Node16`/`NodeNext` paired with an ES-family `module`), so we
+     * need to preserve the user's `customConditions` in that case rather
+     * than silently dropping it.
+     *
+     * @see https://www.typescriptlang.org/tsconfig/#customConditions
+     */
+    private preserveCustomConditionsIfCompatible;
     getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): CompiledOutput;
     protected _transpileOutput(fileContent: string, fileName: string): TranspileOutput;
+    /**
+     * TypeScript 6 reports TS5107 when ts-jest's historical default of
+     * `moduleResolution: Node10` is passed to `transpileModule`. The diagnostic
+     * is an implementation detail when ts-jest injected that value, but remains
+     * actionable when the user selected Node10 themselves.
+     */
+    private _filterDiagnosticsFromTsJestDefaults;
     protected _makeTransformers(customTransformers: TsJestAstTransformer): CustomTransformers;
 }

package/dist/legacy/compiler/ts-compiler.js

@@ -15,7 +15,7 @@ const messages_1 = require("../../utils/messages");
 const compiler_utils_1 = require("./compiler-utils");
 const assertCompilerOptionsWithJestTransformMode = (compilerOptions, isEsmMode, logger) => {
     if (isEsmMode && compilerOptions.module === typescript_1.default.ModuleKind.CommonJS) {
-        logger.error("The current compiler option \"module\" value is not suitable for Jest ESM mode. Please either use ES module kinds or Node16/NodeNext module kinds with \"type: module\" in package.json" /* Errors.InvalidModuleKindForEsm */);
+        logger.error(messages_1.Errors.InvalidModuleKindForEsm);
     }
 };
 class TsCompiler {
@@ -49,6 +49,10 @@ class TsCompiler {
      * @internal
      */
     _projectVersion = 1;
+    /**
+     * @internal
+     */
+    _previousCompiledModuleKind;
     /**
      * @internal
      */
@@ -107,17 +111,38 @@ class TsCompiler {
         });
         return importedModulePaths;
     }
+    /**
+     * Apply ts-jest's runtime fixups on top of the user's compiler options before
+     * handing them to the language service or transpiler.
+     *
+     * Two compiler-options now flow through dedicated helpers so the produced
+     * options are always a TypeScript-valid combination:
+     *
+     *   - `moduleResolution` is delegated to `resolveCompatibleModuleResolution`,
+     *     which preserves the user's value when it is valid alongside the
+     *     `module` ts-jest forces at runtime (CommonJS on the CJS path, or
+     *     ESNext / the user's original `module` on the ESM path) and otherwise
+     *     substitutes a TypeScript-valid alternative. When the user has not set
+     *     a value the historical Node10 default is kept, so unchanged tsconfigs
+     *     see the exact same resolved options as before.
+     *
+     *   - `customConditions` is delegated to `preserveCustomConditionsIfCompatible`,
+     *     which keeps the user's value only when the resolved
+     *     `moduleResolution` supports it (`Bundler` / `Node16` / `NodeNext`)
+     *     and clears it otherwise. The pre-#4198 code unconditionally cleared
+     *     this option because the hardcoded `Node10` override always made it
+     *     incompatible; that is no longer true.
+     *
+     * @see https://github.com/kulshekhar/ts-jest/issues/4198
+     */
     fixupCompilerOptionsForModuleKind(compilerOptions, isEsm) {
-        const moduleResolution = this._ts.ModuleResolutionKind.Node10 ?? this._ts.ModuleResolutionKind.NodeJs;
         if (!isEsm) {
+            const moduleResolution = this.resolveCompatibleModuleResolution(this._ts.ModuleKind.CommonJS, compilerOptions.moduleResolution);
             return {
                 ...compilerOptions,
                 module: this._ts.ModuleKind.CommonJS,
                 moduleResolution,
-                /**
-                 * This option is only supported in `Node16`/`NodeNext` and `Bundler` module, see https://www.typescriptlang.org/tsconfig/#customConditions
-                 */
-                customConditions: undefined,
+                customConditions: this.preserveCustomConditionsIfCompatible(moduleResolution, compilerOptions.customConditions),
             };
         }
         let moduleKind = compilerOptions.module ?? this._ts.ModuleKind.ESNext;
@@ -126,32 +151,148 @@ class TsCompiler {
             esModuleInterop = true;
             moduleKind = this._ts.ModuleKind.ESNext;
         }
+        const moduleResolution = this.resolveCompatibleModuleResolution(moduleKind, compilerOptions.moduleResolution);
         return {
             ...compilerOptions,
             module: moduleKind,
             esModuleInterop,
             moduleResolution,
-            /**
-             * This option is only supported in `Node16`/`NodeNext` and `Bundler` module, see https://www.typescriptlang.org/tsconfig/#customConditions
-             */
-            customConditions: undefined,
+            customConditions: this.preserveCustomConditionsIfCompatible(moduleResolution, compilerOptions.customConditions),
         };
     }
+    /**
+     * Pick a `moduleResolution` value that is valid alongside the `module` ts-jest
+     * forces at runtime. Closes #4198: previously this was hardcoded to Node10 and
+     * silently overrode whatever the user set in tsconfig, even when the user value
+     * would have been valid (e.g. Bundler with module: ESNext, Classic with CommonJS).
+     *
+     * Substitution rules — each tied to a specific TypeScript diagnostic that the
+     * resulting combination would otherwise raise. The "Bundler-compatible" set is
+     * the one defined by `isBundlerCompatibleModuleKind` (ES2015 / ES2020 / ES2022
+     * / ESNext / Preserve); everything else (CommonJS / AMD / UMD / System / None)
+     * is treated as Bundler-incompatible across the full supported TS range.
+     *
+     *   - Node16 / NodeNext require `module: Node16` or `module: NodeNext` (TS5110).
+     *     ts-jest never emits those module kinds, so these user-supplied values are
+     *     substituted: to Bundler when the forced module is in the
+     *     Bundler-compatible set, or to Node10 otherwise. (Pairing Bundler with a
+     *     non-ES module raises TS5095, and Node10 is the only kind that has been
+     *     valid with non-ES modules across every TypeScript version ts-jest
+     *     supports.)
+     *
+     *   - User-supplied Bundler with a non-Bundler-compatible forced module is
+     *     TS5095, substitute Node10. (TypeScript 6 relaxed this for
+     *     `module: CommonJS` specifically; that relaxation is encoded inside
+     *     `isBundlerCompatibleModuleKind` via a runtime version check, so on
+     *     TS ≥ 6 user-supplied Bundler passes through unchanged on the CJS
+     *     path.)
+     *
+     *   - Anything else (Node10 / Classic / unset) passes through or falls back
+     *     to Node10. These pairings are valid with every forced module kind.
+     *
+     * Compatibility: `ModuleResolutionKind.Bundler` was introduced in
+     * TypeScript 5.0. ts-jest declares `peerDependencies: { typescript: ">=4.3 <7" }`,
+     * so the Bundler member is `undefined` at runtime on TypeScript 4.3 - 4.9.
+     * The Node16/NodeNext substitution falls back to Node10 in that case
+     * (`bundlerResolution` below) to keep the function deterministic across the
+     * full supported range. Users on TypeScript < 5 can never have set Bundler in
+     * tsconfig (the parser rejects it), so the user-supplied-Bundler branch is
+     * unreachable there and needs no separate guard.
+     */
+    resolveCompatibleModuleResolution(forcedModule, userResolution) {
+        const node10Default = this._ts.ModuleResolutionKind.Node10 ?? this._ts.ModuleResolutionKind.NodeJs;
+        if (userResolution === undefined) {
+            return node10Default;
+        }
+        const { Node16, NodeNext, Bundler } = this._ts.ModuleResolutionKind;
+        const bundlerResolution = Bundler ?? node10Default;
+        const canUseBundler = this.isBundlerCompatibleModuleKind(forcedModule);
+        if (userResolution === Node16 || userResolution === NodeNext) {
+            return canUseBundler ? bundlerResolution : node10Default;
+        }
+        if (userResolution === Bundler && !canUseBundler) {
+            return node10Default;
+        }
+        return userResolution;
+    }
+    /**
+     * TypeScript pairs `moduleResolution: bundler` only with ES-module module
+     * kinds (`ES2015` / `ES2020` / `ES2022` / `ESNext`) or `Preserve` (added in
+     * TypeScript 5.4). Pairing `bundler` with `CommonJS`, `AMD`, `UMD`, `System`,
+     * or `None` raises TS5095. Used by `resolveCompatibleModuleResolution` to
+     * gate the `Node16` / `NodeNext` → `Bundler` substitution and the
+     * user-supplied-`Bundler` pass-through, so neither path emits an invalid
+     * pair when the user has selected a non-ES `module`.
+     *
+     * TypeScript 6.0 relaxed TS5095 for `module: CommonJS` specifically
+     * (`CommonJS` + `Bundler` is a valid pair on TS ≥ 6); the other non-ES
+     * module kinds (`AMD` / `UMD` / `System` / `None`) remain Bundler-incompatible
+     * on every TypeScript version. The version is detected at runtime from
+     * `this._ts.version` so the function stays correct across the full
+     * peerDependency range (`>=4.3 <7`).
+     *
+     * @see https://www.typescriptlang.org/tsconfig/#moduleResolution
+     */
+    isBundlerCompatibleModuleKind(moduleKind) {
+        const M = this._ts.ModuleKind;
+        if (moduleKind === M.ESNext || moduleKind === M.ES2015 || moduleKind === M.ES2020 || moduleKind === M.ES2022) {
+            return true;
+        }
+        // `ModuleKind.Preserve` was introduced in TypeScript 5.4; on older
+        // TypeScript versions the property is `undefined` at runtime.
+        if (M.Preserve !== undefined && moduleKind === M.Preserve) {
+            return true;
+        }
+        // TS 6 made `CommonJS` + `Bundler` a valid pair.
+        if (moduleKind === M.CommonJS) {
+            const tsMajor = parseInt(this._ts.version.split('.')[0], 10);
+            return tsMajor >= 6;
+        }
+        return false;
+    }
+    /**
+     * Pass `customConditions` through unchanged when the resolved
+     * `moduleResolution` is one of the kinds that supports it (`Bundler`,
+     * `Node16`, `NodeNext`); strip it otherwise. TypeScript raises TS5098
+     * when `customConditions` is paired with any other resolution kind
+     * (verified empirically against TypeScript 5.9.3 with `tsc -p`).
+     *
+     * Before #4198 the surrounding `fixupCompilerOptionsForModuleKind`
+     * unconditionally cleared `customConditions` because the hardcoded
+     * `Node10` override always made it incompatible. After #4198 the
+     * resolved `moduleResolution` can be `Bundler` (e.g. when the user
+     * has `Node16`/`NodeNext` paired with an ES-family `module`), so we
+     * need to preserve the user's `customConditions` in that case rather
+     * than silently dropping it.
+     *
+     * @see https://www.typescriptlang.org/tsconfig/#customConditions
+     */
+    preserveCustomConditionsIfCompatible(resolvedModuleResolution, userCustomConditions) {
+        const R = this._ts.ModuleResolutionKind;
+        const supportsCustomConditions = resolvedModuleResolution === R.Bundler ||
+            resolvedModuleResolution === R.Node16 ||
+            resolvedModuleResolution === R.NodeNext;
+        return supportsCustomConditions ? userCustomConditions : undefined;
+    }
     getCompiledOutput(fileContent, fileName, options) {
         const isEsmMode = this.configSet.useESM && options.supportsStaticESM;
         this._compilerOptions = this.fixupCompilerOptionsForModuleKind(this._initialCompilerOptions, isEsmMode);
         const moduleKind = this._initialCompilerOptions.module;
         const currentModuleKind = this._compilerOptions.module;
+        // Without this, a Program rebuilt for one compile's module kind would be
+        // reused on the next compile when that compile expects a different kind.
+        const moduleKindChangedSinceLastCompile = this._previousCompiledModuleKind !== undefined && this._previousCompiledModuleKind !== currentModuleKind;
+        this._previousCompiledModuleKind = currentModuleKind;
         if (this._languageService) {
             if (constants_1.JS_JSX_REGEX.test(fileName) && !this._compilerOptions.allowJs) {
-                this._logger.warn({ fileName: fileName }, (0, messages_1.interpolate)("Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore" /* Errors.GotJsFileButAllowJsFalse */, { path: fileName }));
+                this._logger.warn({ fileName: fileName }, (0, messages_1.interpolate)(messages_1.Errors.GotJsFileButAllowJsFalse, { path: fileName }));
                 return {
                     code: fileContent,
                 };
             }
             this._logger.debug({ fileName }, 'getCompiledOutput(): compiling using language service');
             // Must set memory cache before attempting to compile
-            this._updateMemoryCache(fileContent, fileName, currentModuleKind === moduleKind);
+            this._updateMemoryCache(fileContent, fileName, currentModuleKind === moduleKind && !moduleKindChangedSinceLastCompile);
             const output = this._languageService.getEmitOutput(fileName);
             const diagnostics = this.getDiagnostics(fileName);
             if ((0, transpile_module_1.isModernNodeModuleKind)(this._initialCompilerOptions.module)) {
@@ -190,10 +331,10 @@ class TsCompiler {
             }
             if (output.emitSkipped) {
                 if (constants_1.TS_TSX_REGEX.test(fileName)) {
-                    throw new Error((0, messages_1.interpolate)("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}" /* Errors.CannotProcessFile */, { file: fileName }));
+                    throw new Error((0, messages_1.interpolate)(messages_1.Errors.CannotProcessFile, { file: fileName }));
                 }
                 else {
-                    this._logger.warn((0, messages_1.interpolate)("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`" /* Errors.CannotProcessFileReturnOriginal */, { file: fileName }));
+                    this._logger.warn((0, messages_1.interpolate)(messages_1.Errors.CannotProcessFileReturnOriginal, { file: fileName }));
                     return {
                         code: fileContent,
                     };
@@ -201,7 +342,7 @@ class TsCompiler {
             }
             // Throw an error when requiring `.d.ts` files.
             if (!output.outputFiles.length) {
-                throw new TypeError((0, messages_1.interpolate)("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`." /* Errors.UnableToRequireDefinitionFile */, {
+                throw new TypeError((0, messages_1.interpolate)(messages_1.Errors.UnableToRequireDefinitionFile, {
                     file: (0, path_1.basename)(fileName),
                 }));
             }
@@ -235,12 +376,14 @@ class TsCompiler {
          * This code path should be removed in the next major version to benefit from checking on compiler options
          */
         if (!(0, transpile_module_1.isModernNodeModuleKind)(this._initialCompilerOptions.module)) {
-            return this._ts.transpileModule(fileContent, {
+            const result = this._ts.transpileModule(fileContent, {
                 fileName,
                 transformers: this._makeTransformers(this.configSet.resolvedTransformers),
                 compilerOptions: this._compilerOptions,
                 reportDiagnostics: this.configSet.shouldReportDiagnostics(fileName),
             });
+            const diagnostics = this._filterDiagnosticsFromTsJestDefaults(result.diagnostics);
+            return diagnostics === result.diagnostics ? result : { ...result, diagnostics };
         }
         return (0, transpile_module_1.tsTranspileModule)(fileContent, {
             fileName,
@@ -252,6 +395,24 @@ class TsCompiler {
             reportDiagnostics: fileName ? this.configSet.shouldReportDiagnostics(fileName) : false,
         });
     }
+    /**
+     * TypeScript 6 reports TS5107 when ts-jest's historical default of
+     * `moduleResolution: Node10` is passed to `transpileModule`. The diagnostic
+     * is an implementation detail when ts-jest injected that value, but remains
+     * actionable when the user selected Node10 themselves.
+     */
+    _filterDiagnosticsFromTsJestDefaults(diagnostics) {
+        // `Node10` was exposed as `NodeJs` (with the same value) by older supported TypeScript releases.
+        const node10 = this._ts.ModuleResolutionKind.Node10 ?? 2;
+        const tsMajor = Number.parseInt(this._ts.version.split('.')[0], 10);
+        const hasInjectedNode10 = tsMajor >= 6 &&
+            this._initialCompilerOptions.moduleResolution === undefined &&
+            this._compilerOptions.moduleResolution === node10;
+        if (!hasInjectedNode10 || !diagnostics?.some((diagnostic) => diagnostic.code === 5107)) {
+            return diagnostics;
+        }
+        return diagnostics.filter((diagnostic) => diagnostic.code !== 5107);
+    }
     _makeTransformers(customTransformers) {
         return {
             before: customTransformers.before.map((beforeTransformer) => beforeTransformer.factory(this, beforeTransformer.options)),
@@ -322,7 +483,13 @@ class TsCompiler {
             getCompilationSettings: () => this._compilerOptions,
             getDefaultLibFileName: () => this._ts.getDefaultLibFilePath(this._compilerOptions),
             getCustomTransformers: () => this._makeTransformers(this.configSet.resolvedTransformers),
-            resolveModuleNames: (moduleNames, containingFile) => moduleNames.map((moduleName) => this._resolveModuleName(moduleName, containingFile).resolvedModule),
+            resolveModuleNames: (moduleNames, containingFile) => {
+                if (moduleNames.length === 0) {
+                    return [];
+                }
+                const resolutionMode = this._getResolutionMode(containingFile);
+                return moduleNames.map((moduleName) => this._resolveModuleName(moduleName, containingFile, resolutionMode).resolvedModule);
+            },
         };
         this._logger.debug('created language service');
         this._languageService = this._ts.createLanguageService(serviceHost, this._ts.createDocumentRegistry(this._ts.sys.useCaseSensitiveFileNames, this.configSet.cwd));
@@ -345,10 +512,14 @@ class TsCompiler {
      * @internal
      */
     _getImportedModulePaths(resolvedFileContent, containingFile) {
-        return this._ts
-            .preProcessFile(resolvedFileContent, true, true)
-            .importedFiles.map((importedFile) => {
-            const { resolvedModule } = this._resolveModuleName(importedFile.fileName, containingFile);
+        const importedFiles = this._ts.preProcessFile(resolvedFileContent, true, true).importedFiles;
+        if (importedFiles.length === 0) {
+            return [];
+        }
+        const resolutionMode = this._getResolutionMode(containingFile);
+        return importedFiles
+            .map((importedFile) => {
+            const { resolvedModule } = this._resolveModuleName(importedFile.fileName, containingFile, resolutionMode);
             /* istanbul ignore next already covered  */
             const resolvedFileName = resolvedModule?.resolvedFileName;
             /* istanbul ignore next already covered  */
@@ -359,12 +530,30 @@ class TsCompiler {
     /**
      * @internal
      */
-    _resolveModuleName(moduleNameToResolve, containingFile) {
+    _getResolutionMode(containingFile) {
+        const getImpliedNodeFormat = this._ts.getImpliedNodeFormatForFile;
+        if (typeof getImpliedNodeFormat !== 'function') {
+            return undefined;
+        }
+        // @ts-expect-error internal TypeScript API
+        const moduleResolution = this._ts.getEmitModuleResolutionKind(this._compilerOptions);
+        const { Classic, Node10, NodeJs } = this._ts.ModuleResolutionKind;
+        if (moduleResolution === (Node10 ?? NodeJs) || moduleResolution === Classic) {
+            return undefined;
+        }
+        return getImpliedNodeFormat(containingFile, this._moduleResolutionCache?.getPackageJsonInfoCache?.(), 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._moduleResolutionHost, this._compilerOptions);
+    }
+    /**
+     * @internal
+     */
+    _resolveModuleName(moduleNameToResolve, containingFile, resolutionMode) {
         return this._ts.resolveModuleName(moduleNameToResolve, containingFile, this._compilerOptions, 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this._moduleResolutionHost, 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        this._moduleResolutionCache);
+        this._moduleResolutionCache, undefined, resolutionMode);
     }
     /**
      * @internal

package/dist/legacy/config/config-set.js

@@ -200,7 +200,7 @@ class ConfigSet {
         const tsJestCfg = this._jestCfg.globals && this._jestCfg.globals['ts-jest'];
         const options = tsJestCfg ?? Object.create(null);
         // compiler module
-        this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed." /* ImportReasons.TsJest */, options.compiler ?? 'typescript');
+        this.compilerModule = importer_1.importer.typescript(messages_1.ImportReasons.TsJest, options.compiler ?? 'typescript');
         this.logger.debug({ compilerModule: this.compilerModule }, 'normalized compiler module config via ts-jest option');
         this._setupConfigSet(options);
         this._matchablePatterns = [...this._jestCfg.testMatch, ...this._jestCfg.testRegex].filter((pattern) => 
@@ -217,12 +217,12 @@ class ConfigSet {
         if (options.isolatedModules) {
             this.parsedTsConfig.options.isolatedModules = true;
             if (this.tsconfigFilePath) {
-                this.logger.warn((0, messages_1.interpolate)("\n    The \"ts-jest\" config option \"isolatedModules\" is deprecated and will be removed in v30.0.0. Please use \"isolatedModules: true\" in {{tsconfigFilePath}} instead, see https://www.typescriptlang.org/tsconfig/#isolatedModules\n  " /* Deprecations.IsolatedModulesWithTsconfigPath */, {
+                this.logger.warn((0, messages_1.interpolate)(messages_1.Deprecations.IsolatedModulesWithTsconfigPath, {
                     tsconfigFilePath: this.tsconfigFilePath,
                 }));
             }
             else {
-                this.logger.warn("\n    The \"ts-jest\" config option \"isolatedModules\" is deprecated and will be removed in v30.0.0. Please use \"isolatedModules: true\", see https://www.typescriptlang.org/tsconfig/#isolatedModules\n  " /* Deprecations.IsolatedModulesWithoutTsconfigPath */);
+                this.logger.warn(messages_1.Deprecations.IsolatedModulesWithoutTsconfigPath);
             }
         }
         this.isolatedModules = this.parsedTsConfig.options.isolatedModules ?? false;
@@ -279,7 +279,7 @@ class ConfigSet {
             }
             this.logger.debug({ babelConfig: this.babelConfig }, 'normalized babel config via ts-jest option');
             this.babelJestTransformer = importer_1.importer
-                .babelJest("Using \"babel-jest\" requires this package to be installed." /* ImportReasons.BabelJest */)
+                .babelJest(messages_1.ImportReasons.BabelJest)
                 .createTransformer(this.babelConfig);
             this.logger.debug('created babel-jest transformer');
         }
@@ -337,7 +337,7 @@ class ConfigSet {
                 let transformerFunc;
                 if ((0, path_1.extname)(transformerPath) === '.ts') {
                     const compiledTransformer = importer_1.importer
-                        .esBuild("Using \"esbuild\" requires this package to be installed." /* ImportReasons.EsBuild */)
+                        .esBuild(messages_1.ImportReasons.EsBuild)
                         .transformSync((0, fs_1.readFileSync)(transformerPath, 'utf-8'), {
                         loader: 'ts',
                         format: 'cjs',
@@ -349,10 +349,10 @@ class ConfigSet {
                     transformerFunc = require(transformerPath);
                 }
                 if (!transformerFunc.version) {
-                    this.logger.warn("The AST transformer {{file}} must have an `export const version = <your_transformer_version>`" /* Errors.MissingTransformerVersion */, { file: transformerPath });
+                    this.logger.warn(messages_1.Errors.MissingTransformerVersion, { file: transformerPath });
                 }
                 if (!transformerFunc.name) {
-                    this.logger.warn("The AST transformer {{file}} must have an `export const name = <your_transformer_name>`" /* Errors.MissingTransformerName */, { file: transformerPath });
+                    this.logger.warn(messages_1.Errors.MissingTransformerName, { file: transformerPath });
                 }
                 return transformerFunc;
             };
@@ -449,7 +449,7 @@ class ConfigSet {
             !(finalOptions.esModuleInterop || finalOptions.allowSyntheticDefaultImports)) {
             result.errors.push({
                 code: utils_1.TsJestDiagnosticCodes.ConfigModuleOption,
-                messageText: "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information." /* Errors.ConfigNoModuleInterop */,
+                messageText: messages_1.Errors.ConfigNoModuleInterop,
                 category: this.compilerModule.DiagnosticCategory.Message,
                 file: undefined,
                 start: undefined,
@@ -488,7 +488,7 @@ class ConfigSet {
             !this.babelConfig &&
             nodeJsVer.startsWith('v12') &&
             compilationTarget > this.compilerModule.ScriptTarget.ES2019) {
-            const message = (0, messages_1.interpolate)("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping" /* Errors.MismatchNodeTargetMapping */, {
+            const message = (0, messages_1.interpolate)(messages_1.Errors.MismatchNodeTargetMapping, {
                 nodeJsVer: process.version,
                 compilationTarget: TARGET_TO_VERSION_MAPPING[compilationTarget],
             });
@@ -612,7 +612,7 @@ class ConfigSet {
             }
         }
         if (throwIfMissing && !(0, fs_1.existsSync)(path)) {
-            throw new Error((0, messages_1.interpolate)("File not found: {{inputPath}} (resolved as: {{resolvedPath}})" /* Errors.FileNotFound */, { inputPath, resolvedPath: path }));
+            throw new Error((0, messages_1.interpolate)(messages_1.Errors.FileNotFound, { inputPath, resolvedPath: path }));
         }
         this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
         return path;

package/dist/legacy/ts-jest-transformer.js

@@ -79,7 +79,7 @@ class TsJestTransformer {
                 // create the new record in the index
                 this._logger.info('no matching config-set found, creating a new one');
                 if (config.globals?.['ts-jest']) {
-                    this._logger.warn("Define `ts-jest` config under `globals` is deprecated. Please do\ntransform: {\n    <transform_regex>: ['ts-jest', { /* ts-jest config goes here in Jest */ }],\n},\nSee more at https://kulshekhar.github.io/ts-jest/docs/getting-started/presets#advanced" /* Deprecations.GlobalsTsJestConfigOption */);
+                    this._logger.warn(messages_1.Deprecations.GlobalsTsJestConfigOption);
                 }
                 const jestGlobalsConfig = config.globals ?? {};
                 const tsJestGlobalsConfig = jestGlobalsConfig['ts-jest'] ?? {};
@@ -189,11 +189,14 @@ class TsJestTransformer {
                 const transpiledResult = typescript_1.default.transpileModule(sourceText, {
                     compilerOptions: {
                         ...configs.parsedTsConfig.options,
-                        module: transformOptions.supportsStaticESM && transformOptions.transformerConfig.useESM
+                        module: transformOptions.supportsStaticESM && transformOptions.transformerConfig?.useESM
                             ? typescript_1.default.ModuleKind.ESNext
                             : typescript_1.default.ModuleKind.CommonJS,
                     },
-                    fileName: sourcePath,
+                    // .mjs fileName causes ts.transpileModule to preserve ESM syntax even with module: CommonJS
+                    fileName: transformOptions.supportsStaticESM && transformOptions.transformerConfig?.useESM
+                        ? sourcePath
+                        : sourcePath.replace(/\.mjs$/, '.js'),
                 });
                 result = {
                     code: (0, compiler_utils_1.updateOutput)(transpiledResult.outputText, sourcePath, transpiledResult.sourceMapText),
@@ -212,7 +215,7 @@ class TsJestTransformer {
             // we should not get called for files with other extension than js[x], ts[x] and d.ts,
             // TypeScript will bail if we try to compile, and if it was to call babel, users can
             // define the transform value with `babel-jest` for this extension instead
-            const message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." /* Errors.GotUnknownFileTypeWithBabel */ : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore." /* Errors.GotUnknownFileTypeWithoutBabel */;
+            const message = babelJest ? messages_1.Errors.GotUnknownFileTypeWithBabel : messages_1.Errors.GotUnknownFileTypeWithoutBabel;
             this._logger.warn({ fileName: sourcePath }, (0, messages_1.interpolate)(message, { path: sourcePath }));
             result = {
                 code: sourceText,

package/dist/transformers/hoist-jest.js

@@ -62,10 +62,17 @@ function factory({ configSet }) {
         if (statements.length <= 1) {
             return statements;
         }
-        return statements.sort((stmtA, stmtB) => isJestGlobalImport(stmtA) ||
-            (isHoistableStatement(stmtA) && !isHoistableStatement(stmtB) && !isJestGlobalImport(stmtB))
-            ? -1
-            : 1);
+        // Return 0 for same-category statements so stable sort preserves source
+        // order, the previous `-1 | 1`-only comparator violated ECMA's consistent
+        // comparison contract and let V8 reorder same-category pairs.
+        const priority = (stmt) => {
+            if (isJestGlobalImport(stmt))
+                return 0;
+            if (isHoistableStatement(stmt))
+                return 1;
+            return 2;
+        };
+        return statements.sort((a, b) => priority(a) - priority(b));
     };
     const createVisitor = (ctx, _) => {
         const visitor = (node) => {

package/dist/utils/backports.js

@@ -17,7 +17,7 @@ const backportJestConfig = (logger, config) => {
     let hadWarnings = false;
     const warnConfig = (oldPath, newPath, note) => {
         hadWarnings = true;
-        logger.warn(context, (0, messages_1.interpolate)(note ? "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n    \u21B3 {{note}}" /* Deprecations.ConfigOptionWithNote */ : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead." /* Deprecations.ConfigOption */, {
+        logger.warn(context, (0, messages_1.interpolate)(note ? messages_1.Deprecations.ConfigOptionWithNote : messages_1.Deprecations.ConfigOption, {
             oldPath,
             newPath,
             note,
@@ -69,7 +69,7 @@ const backportJestConfig = (logger, config) => {
         delete tsJest.enableTsDiagnostics;
     }
     if ('useBabelrc' in tsJest) {
-        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845" /* Deprecations.ConfigOptionUseBabelRcNote */);
+        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', messages_1.Deprecations.ConfigOptionUseBabelRcNote);
         if (tsJest.useBabelrc != null) {
             mergeTsJest.babelConfig = tsJest.useBabelrc ? true : {};
         }
@@ -109,7 +109,7 @@ const backportTsJestDebugEnvVar = (logger) => {
         if (shouldLog) {
             process.env.TS_JEST_LOG = 'ts-jest.log,stderr:warn';
         }
-        logger.warn(context, (0, messages_1.interpolate)("Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead." /* Deprecations.EnvVar */, {
+        logger.warn(context, (0, messages_1.interpolate)(messages_1.Deprecations.EnvVar, {
             old: 'TS_JEST_DEBUG',
             new: 'TS_JEST_LOG',
         }));

package/dist/utils/importer.js

@@ -27,7 +27,17 @@ class Importer {
         return this._import(why, '@babel/core');
     }
     typescript(why, which) {
-        return this._import(why, which);
+        const compilerModule = this._import(why, which);
+        const hasRequiredCompilerApi = typeof compilerModule.createLanguageService === 'function' &&
+            typeof compilerModule.parseJsonConfigFileContent === 'function' &&
+            typeof compilerModule.transpileModule === 'function';
+        if (!hasRequiredCompilerApi) {
+            throw new Error((0, messages_1.interpolate)(messages_1.Errors.TypeScriptCompilerApiUnavailable, {
+                module: which,
+                version: compilerModule.version ?? 'unknown',
+            }));
+        }
+        return compilerModule;
     }
     esBuild(why) {
         return this._import(why, 'esbuild');
@@ -81,10 +91,10 @@ class Importer {
             if (!res.error)
                 return res.exports;
             // it could not load because of a failure while importing, but it exists
-            throw new Error((0, messages_1.interpolate)("Loading module {{module}} failed with error: {{error}}" /* Errors.LoadingModuleFailed */, { module: res.given, error: res.error.message }));
+            throw new Error((0, messages_1.interpolate)(messages_1.Errors.LoadingModuleFailed, { module: res.given, error: res.error.message }));
         }
         // if it couldn't load, build a nice error message so the user can fix it by himself
-        const msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" /* Errors.UnableToLoadAnyModule */ : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}" /* Errors.UnableToLoadOneModule */;
+        const msg = alternatives.length ? messages_1.Errors.UnableToLoadAnyModule : messages_1.Errors.UnableToLoadOneModule;
         const loadModule = [moduleName, ...alternatives].map((m) => `"${m}"`).join(', ');
         if (typeof installTip === 'string') {
             installTip = [{ module: installTip, label: `install "${installTip}"` }];

package/dist/utils/messages.js

@@ -1,8 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Helps = void 0;
+exports.ImportReasons = exports.Deprecations = exports.Helps = exports.Errors = void 0;
 exports.interpolate = interpolate;
 const diagnostics_1 = require("./diagnostics");
+/**
+ * @internal
+ */
+var Errors;
+(function (Errors) {
+    Errors["LoadingModuleFailed"] = "Loading module {{module}} failed with error: {{error}}";
+    Errors["TypeScriptCompilerApiUnavailable"] = "The TypeScript compiler \"{{module}}\" (version {{version}}) does not expose the JavaScript compiler API required by ts-jest. To use TypeScript 7 for project type-checking, install it as \"@typescript/native\" and alias \"@typescript/typescript6\" as \"typescript\" for ts-jest.";
+    Errors["UnableToLoadOneModule"] = "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
+    Errors["UnableToLoadAnyModule"] = "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}";
+    Errors["UnableToRequireDefinitionFile"] = "Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`.";
+    Errors["FileNotFound"] = "File not found: {{inputPath}} (resolved as: {{resolvedPath}})";
+    Errors["UnableToCompileTypeScript"] = "{{diagnostics}}";
+    Errors["NotMappingMultiStarPath"] = "Not mapping \"{{path}}\" because it has more than one star (`*`).";
+    Errors["NotMappingPathWithEmptyMap"] = "Not mapping \"{{path}}\" because it has no target.";
+    Errors["GotJsFileButAllowJsFalse"] = "Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore";
+    Errors["GotUnknownFileTypeWithoutBabel"] = "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
+    Errors["GotUnknownFileTypeWithBabel"] = "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files.";
+    Errors["ConfigNoModuleInterop"] = "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.";
+    Errors["MismatchNodeTargetMapping"] = "There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping";
+    Errors["CannotProcessFileReturnOriginal"] = "Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`";
+    Errors["CannotProcessFile"] = "Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}";
+    Errors["MissingTransformerName"] = "The AST transformer {{file}} must have an `export const name = <your_transformer_name>`";
+    Errors["MissingTransformerVersion"] = "The AST transformer {{file}} must have an `export const version = <your_transformer_version>`";
+    Errors["InvalidModuleKindForEsm"] = "The current compiler option \"module\" value is not suitable for Jest ESM mode. Please either use ES module kinds or Node16/NodeNext module kinds with \"type: module\" in package.json";
+})(Errors || (exports.Errors = Errors = {}));
 /**
  * @internal
  */
@@ -11,6 +36,29 @@ exports.Helps = {
     MigrateConfigUsingCLI: 'Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.',
     UsingModernNodeResolution: `Using hybrid module kind (Node16/18/Next) is only supported in "isolatedModules: true". Please set "isolatedModules: true" in your tsconfig.json. To disable this message, you can set "diagnostics.ignoreCodes" to include ${diagnostics_1.TsJestDiagnosticCodes.ModernNodeModule} in your ts-jest config. See more at https://kulshekhar.github.io/ts-jest/docs/getting-started/options/diagnostics`,
 };
+/**
+ * @internal
+ */
+var Deprecations;
+(function (Deprecations) {
+    Deprecations["EnvVar"] = "Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead.";
+    Deprecations["ConfigOption"] = "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.";
+    Deprecations["ConfigOptionWithNote"] = "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n    \u21B3 {{note}}";
+    Deprecations["ConfigOptionUseBabelRcNote"] = "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845";
+    // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+    Deprecations["GlobalsTsJestConfigOption"] = "Define `ts-jest` config under `globals` is deprecated. Please do\ntransform: {\n    <transform_regex>: ['ts-jest', { /* ts-jest config goes here in Jest */ }],\n},\nSee more at https://kulshekhar.github.io/ts-jest/docs/getting-started/presets#advanced";
+    Deprecations["IsolatedModulesWithTsconfigPath"] = "\n    The \"ts-jest\" config option \"isolatedModules\" is deprecated and will be removed in v30.0.0. Please use \"isolatedModules: true\" in {{tsconfigFilePath}} instead, see https://www.typescriptlang.org/tsconfig/#isolatedModules\n  ";
+    Deprecations["IsolatedModulesWithoutTsconfigPath"] = "\n    The \"ts-jest\" config option \"isolatedModules\" is deprecated and will be removed in v30.0.0. Please use \"isolatedModules: true\", see https://www.typescriptlang.org/tsconfig/#isolatedModules\n  ";
+})(Deprecations || (exports.Deprecations = Deprecations = {}));
+/**
+ * @internal
+ */
+var ImportReasons;
+(function (ImportReasons) {
+    ImportReasons["TsJest"] = "Using \"ts-jest\" requires this package to be installed.";
+    ImportReasons["BabelJest"] = "Using \"babel-jest\" requires this package to be installed.";
+    ImportReasons["EsBuild"] = "Using \"esbuild\" requires this package to be installed.";
+})(ImportReasons || (exports.ImportReasons = ImportReasons = {}));
 /**
  * @internal
  */

package/dist/utils/ts-error.js

@@ -20,7 +20,7 @@ class TSError extends make_error_1.BaseError {
     diagnosticCodes;
     name = 'TSError';
     constructor(diagnosticText, diagnosticCodes) {
-        super((0, messages_1.interpolate)("{{diagnostics}}" /* Errors.UnableToCompileTypeScript */, {
+        super((0, messages_1.interpolate)(messages_1.Errors.UnableToCompileTypeScript, {
             diagnostics: diagnosticText.trim(),
         }));
         this.diagnosticText = diagnosticText;

package/npm-view.err

@@ -0,0 +1,9 @@
+npm warn Unknown user config "always-auth". This will stop working in the next major version of npm. See `npm help npmrc` for supported config options.
+npm error code E404
+npm error 404 No match found for version 29.4.14
+npm error 404
+npm error 404  The requested resource 'ts-jest@29.4.14' could not be found or you do not have permission to access it.
+npm error 404
+npm error 404 Note that you can also install from a
+npm error 404 tarball, folder, http url, or git url.
+npm error A complete log of this run can be found in: /home/runner/.npm/_logs/2026-09-25T10_37_31_775Z-debug-0.log

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/ts-jest",
-  "version": "29.4.9-depup.0",
+  "version": "29.4.14-depup.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "commonjs",
@@ -13,8 +13,7 @@
     "build": "tsc -p tsconfig.build.json",
     "postbuild": "node scripts/post-build.js",
     "test": "jest -c=jest.config.ts",
-    "test-e2e-cjs": "jest -c=jest-e2e-cjs.config.ts --no-cache",
-    "test-e2e-esm": "node --experimental-vm-modules --no-warnings node_modules/jest/bin/jest.js -c=jest-e2e-esm.config.ts --no-cache",
+    "test-e2e": "jest -c=e2e/jest.config.cts",
     "test-examples": "node scripts/test-examples.js",
     "lint": "eslint .",
     "lint-fix": "eslint --fix .",
@@ -61,12 +60,12 @@
     "json5": "^2.2.3",
     "lodash.memoize": "^4.1.2",
     "make-error": "^1.3.6",
-    "semver": "^7.7.4",
-    "type-fest": "^5.5.0",
+    "semver": "^7.8.5",
+    "type-fest": "^5.10.0",
     "yargs-parser": "^22.0.0"
   },
   "peerDependencies": {
-    "@babel/core": ">=7.0.0-beta.0 <8",
+    "@babel/core": ">=7.0.0-beta.0 <9",
     "@jest/transform": "^29.0.0 || ^30.0.0",
     "@jest/types": "^29.0.0 || ^30.0.0",
     "babel-jest": "^29.0.0 || ^30.0.0",
@@ -98,11 +97,11 @@
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-angular": "^19.8.1",
     "@eslint/compat": "^1.4.1",
-    "@eslint/eslintrc": "^3.3.5",
-    "@eslint/js": "^9.39.4",
-    "@jest/globals": "^30.3.0",
-    "@jest/transform": "^30.3.0",
-    "@jest/types": "^30.3.0",
+    "@eslint/eslintrc": "^3.3.7",
+    "@eslint/js": "^9.39.5",
+    "@jest/globals": "^30.5.2",
+    "@jest/transform": "^30.5.2",
+    "@jest/types": "^30.5.1",
     "@types/babel__core": "^7.20.5",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.14",
@@ -111,17 +110,15 @@
     "@types/lodash.memoize": "^4.1.9",
     "@types/lodash.set": "^4.3.9",
     "@types/micromatch": "^4.0.10",
-    "@types/node": "20.19.37",
-    "@types/semver": "^7.7.1",
+    "@types/node": "20.19.43",
+    "@types/semver": "^7.8.0",
     "@types/yargs": "^17.0.35",
     "@types/yargs-parser": "21.0.3",
-    "@typescript-eslint/eslint-plugin": "^8.57.2",
-    "@typescript-eslint/parser": "^8.57.2",
-    "babel-jest": "^30.3.0",
-    "conventional-changelog-angular": "^8.3.0",
-    "conventional-changelog": "^7.2.0",
-    "esbuild": "~0.27.4",
-    "eslint": "^9.39.4",
+    "babel-jest": "^30.5.2",
+    "conventional-changelog-angular": "^8.3.1",
+    "conventional-changelog": "^7.2.1",
+    "esbuild": "~0.28.2",
+    "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jest": "^28.14.0",
@@ -129,18 +126,18 @@
     "eslint-plugin-prettier": "^4.2.5",
     "execa": "5.1.1",
     "fast-glob": "^3.3.3",
-    "fs-extra": "^11.3.4",
+    "fs-extra": "^11.4.0",
     "globals": "^16.5.0",
     "husky": "^9.1.7",
-    "jest": "^30.3.0",
-    "js-yaml": "^4.1.1",
+    "jest": "^30.5.2",
+    "js-yaml": "^4.3.2",
     "lint-staged": "^15.5.2",
-    "memfs": "^4.57.1",
+    "memfs": "^4.78.1",
     "prettier": "^2.8.8",
     "rimraf": "^5.0.10",
     "ts-node": "^10.9.2",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.57.2"
+    "typescript-eslint": "^8.70.1"
   },
   "engines": {
     "node": "^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0"
@@ -149,7 +146,7 @@
     "changes": {
       "type-fest": {
         "from": "^4.41.0",
-        "to": "^5.5.0"
+        "to": "^5.10.0"
       },
       "yargs-parser": {
         "from": "^21.1.1",
@@ -158,8 +155,8 @@
     },
     "depsUpdated": 2,
     "originalPackage": "ts-jest",
-    "originalVersion": "29.4.9",
-    "processedAt": "2026-04-01T16:26:24.879Z",
+    "originalVersion": "29.4.14",
+    "processedAt": "2026-09-27T01:04:44.063Z",
     "smokeTest": "passed"
   }
 }