@exodus/test 1.0.0-rc.104 → 1.0.0-rc.106

package/README.md

@@ -168,11 +168,17 @@ Just use `"test": "exodus-test"`
 
 - `--test-force-exit` — force exit after tests are done
 
-## Jest compatibility
+## Module mocking in ESM
 
-The `--jest` mode is mostly compatible with Jest. There are some noteworthy differences though.
-This tool does not hoist mocks, so it is important that a mock is defined before the module that uses it is imported.
-In ESM, this can be achieved with dynamic imports:
+Module mocks in ESM is a common source of confusion, as Jest in most old setups does not run real ESM,
+and instead uses Babel to transform ESM into CJS, and then hoists mocks on top of `require()` calls.
+
+That hoisting is not possible in ESM world, as static import statements are always resolved before
+any other code.
+
+Also see [Jest documentation](https://jestjs.io/docs/ecmascript-modules#module-mocking-in-esm) on that.
+
+To port code from CJS or Babel, e.g. the following approach with dynamic imports can be used:
 
 ```js
 jest.doMock('./hogwarts.js', () => ({

package/benchmark.js

@@ -0,0 +1 @@
+export * from './src/benchmark.js'

package/bin/find-binary.js

@@ -4,7 +4,7 @@ import { join } from 'node:path'
 import { createRequire } from 'node:module'
 
 const require = createRequire(import.meta.url)
-const nvm = process.env.NVM_BIN ? (x) => join(process.env.NVM_BIN, '../lib/node_modules', x) : null
+// const nvm = process.env.NVM_BIN ? (x) => join(process.env.NVM_BIN, '../lib/node_modules', x) : null
 const jsvu = (x) => join(homedir(), '.jsvu/bin', x)
 const esvu = (x) => join(homedir(), '.esvu/bin', x)
 
@@ -38,10 +38,9 @@ function findBinaryOnce(name) {
       const flavor = Object.hasOwn(flavors, process.platform) ? flavors[process.platform] : null
       return findFile([
         (bin) => flavor && require.resolve(`react-native/sdks/hermesc/${flavor}/${bin}`), // 1. Locally installed react-native dep (works only for osx)
-        (bin) => flavor && require.resolve(`hermes-engine-cli/${flavor}/${bin}`), // 2. Locally installed hermes-engine-cli
-        (bin) => jsvu(bin), // 3. jsvu
-        (bin) => nvm(`hermes-engine-cli/${flavor}/${bin}`), // 4. hermes-engine-cli installed in .nvm dir with npm i -g
-      ]) // 5. hermes installed in the system
+        (bin) => jsvu(bin), // 2. jsvu
+        (bin) => esvu(bin), // 3. esvu
+      ]) // 4. hermes installed in the system
     }
 
     case 'jsc':
@@ -67,6 +66,9 @@ function findBinaryOnce(name) {
       return require('electron')
     case 'workerd':
       return require.resolve('workerd/bin/workerd')
+    case 'jerryscript':
+      name = 'jerry' // look under this name, including in global
+      return findFile([jsvu, esvu])
     case 'c8':
       return require.resolve('c8/bin/c8.js')
     case 'chrome':

package/bin/index.js

@@ -19,7 +19,7 @@ import { glob as globImplementation } from '../src/glob.cjs'
 const DEFAULT_PATTERNS = [`**/?(*.)+(spec|test).?([cm])[jt]s?(x)`] // do not trust magic dirs by default
 const bundleOpts = { pure: true, bundle: true, esbuild: true, ts: 'auto' }
 const bareboneOpts = { ...bundleOpts, barebone: true }
-const hermesA = ['-Og', '-Xmicrotask-queue']
+const hermesA = ['-w', '-Xmicrotask-queue'] // -Xes6-class fails with -O0 / -Og, --block-scoping fails in default, any of that is bad
 const denoA = ['run', '--allow-all'] // also will set DENO_COMPAT=1 env flag below
 const denoT = ['test', '--allow-all']
 const nodeTS = process.features.typescript ? 'auto' : 'flag'
@@ -49,6 +49,7 @@ const ENGINES = new Map(
     'graaljs:bundle': { binary: 'graaljs', ...bareboneOpts },
     'escargot:bundle': { binary: 'escargot', ...bareboneOpts },
     'boa:bundle': { binary: 'boa', binaryArgs: ['-m'], ...bareboneOpts },
+    'jerryscript:bundle': { binary: 'jerryscript', ...bareboneOpts },
     // Browser engines
     'chrome:puppeteer': { binary: 'chrome', browsers: 'puppeteer', ...bundleOpts },
     'firefox:puppeteer': { binary: 'firefox', browsers: 'puppeteer', ...bundleOpts },
@@ -62,7 +63,7 @@ const ENGINES = new Map(
   })
 )
 const barebonesOk = ['v8', 'd8', 'spidermonkey', 'quickjs', 'xs', 'hermes']
-const barebonesUnhandled = ['jsc', 'escargot', 'boa', 'graaljs', 'engine262']
+const barebonesUnhandled = ['jsc', 'escargot', 'boa', 'graaljs', 'jerry', 'engine262']
 
 const getEnvFlag = (name) => {
   if (!Object.hasOwn(process.env, name)) return
@@ -294,9 +295,7 @@ assert(!options.throttle || options.browsers, engineFlagError('throttle-cpu'))
 
 const args = []
 
-if (have.haveModuleMocks && engineOptions.haveIsOk) {
-  args.push('--experimental-test-module-mocks')
-}
+if (engineOptions.haveIsOk) args.push('--experimental-test-module-mocks')
 
 if (options.pure) {
   if (options.bundle) {
@@ -322,11 +321,7 @@ if (options.pure) {
     args.push('--test-update-snapshots')
   }
 
-  if (options.forceExit) {
-    assert(have.haveForceExit && engineOptions.haveIsOk, 'For forceExit, use Node.js >= 20.14.0')
-    args.push('--test-force-exit')
-  }
-
+  if (options.forceExit) args.push('--test-force-exit')
   if (options.watch) args.push('--watch')
   if (options.only) args.push('--test-only')
 
@@ -766,8 +761,7 @@ if (options.pure) {
   assert(files.length > 0) // otherwise we can run recursively
   if (options.concurrency) args.push('--test-concurrency', options.concurrency)
   if (['--inspect', '--inspect-brk', '--inspect-wait'].includes(options.devtools)) {
-    args.push(options.devtools)
-    if (have.haveNetworkInspection) args.push('--experimental-network-inspection')
+    args.push(options.devtools, '--experimental-network-inspection')
     console.warn(
       ['--inspect-brk', '--inspect-wait'].includes(options.devtools)
         ? 'Open chrome://inspect/ to connect devtools, waiting'

package/mock.js

@@ -0,0 +1 @@
+export * from './src/mock.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.104",
+  "version": "1.0.0-rc.106",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -19,7 +19,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": "^18.19.0 || ^20.8.0 || >=22.0.0"
+    "node": "^20.18.0 || >=22.6.0"
   },
   "type": "module",
   "bin": {
@@ -31,6 +31,7 @@
     "./benchmark": "./src/benchmark.js",
     "./expect": "./src/expect.cjs",
     "./jest": "./src/jest.js",
+    "./mock": "./src/mock.js",
     "./node": "./src/node.js",
     "./tape": {
       "import": "./src/tape.js",
@@ -74,6 +75,7 @@
     "src/jest.setup.js",
     "src/jest.snapshot.js",
     "src/jest.timers.js",
+    "src/mock.js",
     "src/node.js",
     "src/pretty-format.cjs",
     "src/replay.js",
@@ -81,8 +83,10 @@
     "src/tape.cjs",
     "src/timers-track.js",
     "src/version.js",
+    "benchmark.js",
     "expect.cjs",
     "jest.js",
+    "mock.js",
     "node.js",
     "tape.js",
     "CHANGELOG.md"
@@ -125,6 +129,7 @@
     "test:graaljs": "EXODUS_TEST_ENGINE=graaljs:bundle npm run test:_bundle --",
     "test:escargot": "EXODUS_TEST_ENGINE=escargot:bundle npm run test:_bundle --",
     "test:boa": "EXODUS_TEST_ENGINE=boa:bundle npm run test:_bundle --",
+    "test:jerryscript": "EXODUS_TEST_ENGINE=jerryscript:bundle npm run test:_bundle -- --bundle-entropy-size 128",
     "test:fetch": "node ./bin/index.js --jest --drop-network --engine node:pure 'tests/replay/*.test.js'",
     "test:jsdom": "EXODUS_TEST_JEST_CONFIG='{\"testMatch\":[\"**/*.jsdom-test.js\"],\"testEnvironment\":\"jsdom\", \"rootDir\": \".\"}' ./bin/index.js --jest",
     "coverage": "node ./bin/index.js --jest --esbuild --coverage",
@@ -138,15 +143,15 @@
   "optionalDependencies": {
     "@chalker/queue": "^1.0.1",
     "@exodus/replay": "^1.0.0-rc.9",
-    "@exodus/test-bundler": "1.0.0-rc.6",
+    "@exodus/test-bundler": "1.0.0-rc.7",
     "c8": "^9.1.0",
-    "expect": "^29.7.0",
+    "expect": "^30.2.0",
     "fast-glob": "^3.2.11",
     "jest-extended": "^4.0.2",
     "playwright-core": "^1.52.0",
-    "pretty-format": "^29.7.0",
-    "puppeteer-core": "^24.6.0",
-    "tsx": "^4.20.3"
+    "pretty-format": "^30.2.0",
+    "puppeteer-core": "^24.14.0",
+    "tsx": "^4.20.6"
   },
   "devDependencies": {
     "@exodus/eslint-config": "^5.24.0",

package/src/benchmark.js

@@ -10,9 +10,10 @@ const fTime = (ns) => {
   return min < 5n ? `${s}s` : `${min}min`
 }
 
+const { performance, scheduler, process, requestAnimationFrame, gc } = globalThis
 const getTime = (() => {
-  if (globalThis.process) return () => process.hrtime.bigint()
-  if (globalThis.performance) return () => BigInt(Math.round(performance.now() * 1e6))
+  if (process) return () => process.hrtime.bigint()
+  if (performance) return () => BigInt(Math.round(performance.now() * 1e6))
   return () => BigInt(Math.round(Date.now() * 1e6))
 })()
 
@@ -22,9 +23,13 @@ export async function benchmark(name, options, fn) {
   if (options?.skip) return
   const { args, timeout = 1000 } = options ?? {}
 
-  if (globalThis.gc) {
-    for (let i = 0; i < 4; i++) globalThis.gc()
-  } else if (!gcWarned) {
+  // This will pause us for a bit, but we don't care - having a non-busy process is more important
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  if (requestAnimationFrame) await new Promise((resolve) => requestAnimationFrame(resolve))
+  if (scheduler?.yield) await scheduler.yield()
+
+  if (gc) for (let i = 0; i < 4; i++) gc()
+  if (!gc && !gcWarned) {
     gcWarned = true
     console.log('Warning: no gc() available\n')
   }
@@ -43,12 +48,14 @@ export async function benchmark(name, options, fn) {
     total += diff
     if (min === undefined || min > diff) min = diff
     if (max === undefined || max < diff) max = diff
-    if (total >= BigInt(timeout)) break
+    if (total >= BigInt(timeout) * 10n ** 6n) break
   }
 
   const mean = total / BigInt(count)
-  const rps = 1e9 / Number(mean)
-  console.log(`${name} x ${fRps(rps)} ops/sec @ ${fTime(mean)}/op (${fTime(min)}..${fTime(max)})`)
+  let res = `${name} x ${fRps(1e9 / Number(mean))} ops/sec @ ${fTime(mean)}/op`
+  if (fTime(min) !== fTime(max)) res += ` (${fTime(min)}..${fTime(max)})`
+  console.log(res)
 
-  if (globalThis.gc) for (let i = 0; i < 4; i++) globalThis.gc()
+  if (gc) for (let i = 0; i < 4; i++) gc()
+  return { total, count, mean, min, max }
 }

package/src/dark.cjs

@@ -52,57 +52,63 @@ function createCallerLocationHook() {
   return { installLocationInNextTest, getCallerLocation }
 }
 
-// Easy on Node.js >= 22.3.0 || ^20.16.0, but we polyfill for the rest
-function getTestNamePath(t) {
-  // No implementation in Node.js yet, will have to PR
-  if (t.fullName) return t.fullName.split(' > ')
-
-  if (process.env.EXODUS_TEST_ENGINE === 'node:test') {
-    // We are on Node.js < 22.3.0 where even t.fullName doesn't exist yet, polyfill
-    const namePath = Symbol('namePath')
-    const getNamePath = Symbol('getNamePath')
-    try {
-      if (t[namePath]) return t[namePath]
-
-      // Sigh, ok, whatever
-      const { Test } = require('node:internal/test_runner/test')
+// Optimized out in 'bundle' env
+function getTestNamePathFromNode(t) {
+  // We are on Node.js < 22.3.0 where even t.fullName doesn't exist yet, polyfill
+  const namePath = Symbol('namePath')
+  const getNamePath = Symbol('getNamePath')
+  try {
+    if (t[namePath]) return t[namePath]
+
+    // Sigh, ok, whatever
+    const { Test } = require('node:internal/test_runner/test')
+
+    const usePathName = Symbol('usePathName')
+    const restoreName = Symbol('restoreName')
+    Test.prototype[getNamePath] = function () {
+      if (this === this.root) return []
+      return [...(this.parent?.[getNamePath]() || []), this.name]
+    }
 
-      const usePathName = Symbol('usePathName')
-      const restoreName = Symbol('restoreName')
-      Test.prototype[getNamePath] = function () {
-        if (this === this.root) return []
-        return [...(this.parent?.[getNamePath]() || []), this.name]
+    const diagnostic = Test.prototype.diagnostic
+    Test.prototype.diagnostic = function (...args) {
+      if (args[0] === usePathName) {
+        this[restoreName] = this.name
+        this.name = this[getNamePath]()
+        return
       }
 
-      const diagnostic = Test.prototype.diagnostic
-      Test.prototype.diagnostic = function (...args) {
-        if (args[0] === usePathName) {
-          this[restoreName] = this.name
-          this.name = this[getNamePath]()
-          return
-        }
+      if (args[0] === restoreName) {
+        this.name = this[restoreName]
+        delete this[restoreName]
+        return
+      }
 
-        if (args[0] === restoreName) {
-          this.name = this[restoreName]
-          delete this[restoreName]
-          return
-        }
+      return diagnostic.apply(this, args)
+    }
 
-        return diagnostic.apply(this, args)
-      }
+    const TestContextProto = Object.getPrototypeOf(t)
+    Object.defineProperty(TestContextProto, namePath, {
+      get() {
+        this.diagnostic(usePathName)
+        const result = this.name
+        this.diagnostic(restoreName)
+        return result
+      },
+    })
+
+    return t[namePath]
+  } catch {}
+}
 
-      const TestContextProto = Object.getPrototypeOf(t)
-      Object.defineProperty(TestContextProto, namePath, {
-        get() {
-          this.diagnostic(usePathName)
-          const result = this.name
-          this.diagnostic(restoreName)
-          return result
-        },
-      })
+// Easy on Node.js >= 22.3.0 || ^20.16.0, but we polyfill for the rest
+function getTestNamePath(t) {
+  // No implementation in Node.js yet, will have to PR
+  if (t.fullName) return t.fullName.split(' > ')
 
-      return t[namePath]
-    } catch {}
+  if (process.env.EXODUS_TEST_ENGINE === 'node:test') {
+    const names = getTestNamePathFromNode(t)
+    if (names) return names
   }
 
   return [t.name] // last resort

package/src/engine.node.cjs

@@ -30,7 +30,14 @@ const setSnapshotResolver = (fn) => {
 }
 
 const mockModule = mock?.module
-  ? (t, o) => mock.module(t.includes('\\') ? pathToFileURL(t) : t, o) // resolve windows-looking paths
+  ? (t, o) => {
+      try {
+        // resolve windows-looking paths, fails on old 20.x/22.x, but non-url works there, hence in try-catch
+        if (t.includes('\\')) return mock.module(pathToFileURL(t), o)
+      } catch {}
+
+      return mock.module(t, o)
+    }
   : undefined
 
 /* eslint-disable unicorn/no-useless-spread */

package/src/engine.pure.cjs

@@ -539,7 +539,7 @@ if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
   // eslint-disable-next-line no-undef
   const bundleSnaps = typeof EXODUS_TEST_SNAPSHOTS !== 'undefined' && new Map(EXODUS_TEST_SNAPSHOTS)
   const resolveSnapshot = (f) => snapshotResolver(f[0], f[1]).join('/')
-  readSnapshot = (f = baseFile) => (f ? bundleSnaps.get(resolveSnapshot(f)) : null)
+  readSnapshot = (f = baseFile) => (f && bundleSnaps?.get(resolveSnapshot(f))) || null
   utilFormat = require('exodus-test:util-format')
 } else {
   const { existsSync, readFileSync } = require('node:fs')

package/src/engine.pure.snapshot.cjs

@@ -34,4 +34,4 @@ function matchSnapshot(readSnapshot, assert, name, serialized) {
   return assert.fail(`Could not match "${key}" in snapshot. ${addFail}`)
 }
 
-module.exports = { escapeSnapshot, matchSnapshot }
+module.exports = { matchSnapshot }

package/src/exodus.js

@@ -1,51 +1,24 @@
 import { mock } from './engine.js'
 import * as node from './engine.js'
-import { fetchReplay, fetchRecord, websocketRecord, websocketReplay } from './replay.js'
-import { timersTrack, timersList, timersDebug, timersAssert } from './timers-track.js'
-import { insideEsbuild } from './dark.cjs'
-import { haveValidTimers } from './version.js'
 
-const timersSpeedup = (rate, { apis = ['setTimeout', 'setInterval', 'Date'] } = {}) => {
-  if (!(typeof rate === 'number' && rate > 0)) throw new TypeError('Expected a positive rate')
-  const { setTimeout, setInterval, Date: OrigDate } = globalThis
-  for (const api of apis) {
-    // eslint-disable-next-line unicorn/prefer-switch
-    if (api === 'setTimeout') {
-      globalThis.setTimeout = (fn, ms, ...args) => setTimeout(fn, Math.ceil(ms / rate), ...args)
-    } else if (api === 'setInterval') {
-      globalThis.setInterval = (fn, ms, ...args) => setInterval(fn, Math.ceil(ms / rate), ...args)
-    } else if (api === 'Date') {
-      const base = OrigDate.now()
-      globalThis.Date = class Date extends OrigDate {
-        static now = () => base + Math.floor((OrigDate.now() - base) * rate)
-        constructor(first = globalThis.Date.now(), ...rest) {
-          super(first, ...rest)
-        }
-      }
-    } else {
-      throw new Error(`Unknown or unsupported API in timersSpeedup(): ${api}`)
-    }
-  }
-}
+import { insideEsbuild } from './dark.cjs'
 
 const isBundle = process.env.EXODUS_TEST_ENVIRONMENT === 'bundle' // TODO: improve mocking from bundle
-export const exodus = {
+
+export const platform = String(process.env.EXODUS_TEST_PLATFORM) // e.g. 'hermes', 'node'
+export const engine = String(process.env.EXODUS_TEST_ENGINE) // e.g. 'hermes:bundle', 'node:bundle', 'node:test', 'node:pure'
+export const implementation = String(node.engine) // aka process.env.EXODUS_TEST_CONTEXT, e.g. 'node:test' or 'pure'
+
+/* eslint-disable jsdoc/check-tag-names */
+
+/**
+ * @experimental API might change
+ */
+export const features = {
   __proto__: null,
-  platform: String(process.env.EXODUS_TEST_PLATFORM), // e.g. 'hermes', 'node'
-  engine: String(process.env.EXODUS_TEST_ENGINE), // e.g. 'hermes:bundle', 'node:bundle', 'node:test', 'node:pure'
-  implementation: String(node.engine), // aka process.env.EXODUS_TEST_CONTEXT, e.g. 'node:test' or 'pure'
-  features: {
-    __proto__: null,
-    timers: Boolean(mock.timers && haveValidTimers),
-    dynamicRequire: Boolean(!isBundle), // require(non-literal-non-glob), createRequire()(non-builtin)
-    esmMocks: Boolean(mock.module || isBundle), // support for ESM mocks
-    esmNamedBuiltinMocks: Boolean(mock.module || isBundle || insideEsbuild()), // support for named ESM imports from builtin module mocks: also fine in --esbuild
-    esmInterop: Boolean(insideEsbuild() && !isBundle), // loading/using ESM as CJS, ESM mocks creation without a mocker function
-    concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
-  },
-  mock: {
-    ...{ timersTrack, timersList, timersDebug, timersAssert, timersSpeedup }, // eslint-disable-line unicorn/no-useless-spread
-    ...{ fetchRecord, fetchReplay }, // eslint-disable-line unicorn/no-useless-spread
-    ...{ websocketRecord, websocketReplay }, // eslint-disable-line unicorn/no-useless-spread
-  },
+  dynamicRequire: Boolean(!isBundle), // require(non-literal-non-glob), createRequire()(non-builtin)
+  esmMocks: Boolean(mock.module || isBundle), // support for ESM mocks
+  esmNamedBuiltinMocks: Boolean(mock.module || isBundle || insideEsbuild()), // support for named ESM imports from builtin module mocks: also fine in --esbuild
+  esmInterop: Boolean(insideEsbuild() && !isBundle), // loading/using ESM as CJS, ESM mocks creation without a mocker function
+  concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
 }

package/src/expect.cjs

@@ -13,21 +13,27 @@ function fixupAssertions() {
 
 function loadExpect(loadReason) {
   if (expect) return expect
-  try {
-    expect = require('expect').expect
-  } catch {
-    throw new Error(`Failed to load 'expect', required for ${loadReason}`)
-  }
+  // eslint-disable-next-line no-undef
+  if (typeof EXODUS_TEST_LOAD_EXPECT !== 'undefined' && EXODUS_TEST_LOAD_EXPECT === false) {
+    if (loadReason === 'jest.mock') return // allow that and ignore if there is no usage
+    throw new Error('FATAL: expect() was optimized out')
+  } else {
+    try {
+      expect = require('expect').expect
+    } catch {
+      throw new Error(`Failed to load 'expect', required for ${loadReason}`)
+    }
 
-  // console.log('expect load reason:', loadReason)
-  try {
-    expect.extend(require('jest-extended'))
-  } catch {}
+    // console.log('expect load reason:', loadReason)
+    try {
+      expect.extend(require('jest-extended'))
+    } catch {}
 
-  for (const x of extend) expect.extend(...x)
-  for (const [key, value] of set) expect[key] = value
-  fixupAssertions()
-  return expect
+    for (const x of extend) expect.extend(...x)
+    for (const [key, value] of set) expect[key] = value
+    fixupAssertions()
+    return expect
+  }
 }
 
 const areNumeric = (...args) => args.every((a) => typeof a === 'number' || typeof a === 'bigint')

package/src/jest.config.js

@@ -4,6 +4,7 @@ import { specialEnvironments } from './jest.environment.js'
 
 const skipPreset = new Set(['ts-jest'])
 const EXTS = `.?([cm])[jt]s?(x)` // we differ from jest, allowing [cm] before everything
+const needPreset = ({ preset } = {}) => preset && !skipPreset.has(preset)
 const normalizeJestConfig = (config) => ({
   testMatch: [`**/__tests__/**/*${EXTS}`, `**/?(*.)+(spec|test)${EXTS}`],
   testEnvironment: 'node',
@@ -65,6 +66,67 @@ export const jestConfig = () => {
 
 // Methods loadJestConfig() and installJestEnvironment() below are for --jest flag
 
+// Optimized out in 'bundle' env
+async function loadConfigParts(rawConfig) {
+  const presetExtension = /\.([cm]?js|json)$/u
+  const suffixes = ['/jest-preset.json', '/jest-preset.js', '/jest-preset.cjs', '/jest-preset.mjs']
+  const resolveGlobalSetup = (config, req) => {
+    if (config.globalSetup) config.globalSetup = req.resolve(config.globalSetup) // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
+    if (config.globalTeardown) config.globalTeardown = req.resolve(config.globalTeardown) // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
+  }
+
+  assert(rawConfig.rootDir)
+  const { resolve } = await import('node:path')
+  const { createRequire } = await import('node:module')
+  const { pathToFileURL } = await import('node:url')
+  let requireConfig = createRequire(resolve(rawConfig.rootDir, 'package.json'))
+  resolveGlobalSetup(rawConfig, requireConfig)
+  while (needPreset(rawConfig)) {
+    let baseConfig
+
+    const attemptLoad = async (file) => {
+      try {
+        const resolved = requireConfig.resolve(file)
+        // FIXME: fix linter to allow this
+        // const meta = resolved.toLowerCase().endsWith('.json') ? { with: { type: 'json' } } : undefined
+        // const presetModule = await import(pathToFileURL(resolved), meta)
+        const presetModule = await import(pathToFileURL(resolved))
+        requireConfig = createRequire(resolved)
+        baseConfig = presetModule.default
+      } catch {}
+    }
+
+    // Even if it is relative, it could be a path to module
+    for (const suffix of suffixes) {
+      if (!baseConfig) await attemptLoad(`${rawConfig.preset}${suffix}`)
+    }
+
+    // If it's a path to a file
+    if (!baseConfig && rawConfig.preset[0] === '.' && presetExtension.test(rawConfig.preset)) {
+      const { statSync } = await import('node:fs')
+      if (statSync(rawConfig.preset).isFile()) await attemptLoad(rawConfig.preset)
+    }
+
+    assert(baseConfig, `Could not load preset: ${rawConfig.preset} `)
+    resolveGlobalSetup(baseConfig, requireConfig)
+    rawConfig = {
+      ...baseConfig,
+      ...rawConfig,
+      preset: baseConfig.preset,
+      setupFiles: [
+        ...(baseConfig.setupFiles || []).map((file) => requireConfig.resolve(file)),
+        ...(rawConfig.setupFiles || []),
+      ],
+      setupFilesAfterEnv: [
+        ...(baseConfig.setupFilesAfterEnv || []).map((file) => requireConfig.resolve(file)),
+        ...(rawConfig.setupFilesAfterEnv || []),
+      ],
+    }
+  }
+
+  return rawConfig
+}
+
 export async function loadJestConfig(...args) {
   let rawConfig
   if (process.env.EXODUS_TEST_JEST_CONFIG === undefined) {
@@ -75,67 +137,12 @@ export async function loadJestConfig(...args) {
   }
 
   const cleanFile = (file) => file.replace(/^<rootDir>\//g, './') // require is already relative to rootDir
-  const needPreset = ({ preset } = {}) => preset && !skipPreset.has(preset)
-  const resolveGlobalSetup = (config, req) => {
-    if (config.globalSetup) config.globalSetup = req.resolve(config.globalSetup) // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
-    if (config.globalTeardown) config.globalTeardown = req.resolve(config.globalTeardown) // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
-  }
-
-  const presetExtension = /\.([cm]?js|json)$/u
-  const suffixes = ['/jest-preset.json', '/jest-preset.js', '/jest-preset.cjs', '/jest-preset.mjs']
   if (needPreset(rawConfig) || rawConfig?.globalSetup || rawConfig?.globalTeardown) {
     rawConfig.preset = cleanFile(rawConfig.preset) // relative to root dir only at top level, presets shouldn't use <rootDir>
     if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
       throw new Error('jest preset and globalSetup/Teardown not yet supported in bundles')
     } else {
-      assert(rawConfig.rootDir)
-      const { resolve } = await import('node:path')
-      const { createRequire } = await import('node:module')
-      const { pathToFileURL } = await import('node:url')
-      let requireConfig = createRequire(resolve(rawConfig.rootDir, 'package.json'))
-      resolveGlobalSetup(rawConfig, requireConfig)
-      while (needPreset(rawConfig)) {
-        let baseConfig
-
-        const attemptLoad = async (file) => {
-          try {
-            const resolved = requireConfig.resolve(file)
-            // FIXME: fix linter to allow this
-            // const meta = resolved.toLowerCase().endsWith('.json') ? { with: { type: 'json' } } : undefined
-            // const presetModule = await import(pathToFileURL(resolved), meta)
-            const presetModule = await import(pathToFileURL(resolved))
-            requireConfig = createRequire(resolved)
-            baseConfig = presetModule.default
-          } catch {}
-        }
-
-        // Even if it is relative, it could be a path to module
-        for (const suffix of suffixes) {
-          if (!baseConfig) await attemptLoad(`${rawConfig.preset}${suffix}`)
-        }
-
-        // If it's a path to a file
-        if (!baseConfig && rawConfig.preset[0] === '.' && presetExtension.test(rawConfig.preset)) {
-          const { statSync } = await import('node:fs')
-          if (statSync(rawConfig.preset).isFile()) await attemptLoad(rawConfig.preset)
-        }
-
-        assert(baseConfig, `Could not load preset: ${rawConfig.preset} `)
-        resolveGlobalSetup(baseConfig, requireConfig)
-        rawConfig = {
-          ...baseConfig,
-          ...rawConfig,
-          preset: baseConfig.preset,
-          setupFiles: [
-            ...(baseConfig.setupFiles || []).map((file) => requireConfig.resolve(file)),
-            ...(rawConfig.setupFiles || []),
-          ],
-          setupFilesAfterEnv: [
-            ...(baseConfig.setupFilesAfterEnv || []).map((file) => requireConfig.resolve(file)),
-            ...(rawConfig.setupFilesAfterEnv || []),
-          ],
-        }
-      }
+      rawConfig = await loadConfigParts(rawConfig)
     }
   }
 
@@ -148,6 +155,15 @@ export async function loadJestConfig(...args) {
   return config
 }
 
+// Optimized out in 'bundle' env
+async function makeDynamicImport(rootDir) {
+  const { resolve } = await import('node:path')
+  const { createRequire } = await import('node:module')
+  const { pathToFileURL } = await import('node:url')
+  const require = createRequire(resolve(rootDir, 'package.json'))
+  return (path) => import(pathToFileURL(require.resolve(path))) // does not need json imports
+}
+
 export async function installJestEnvironment(jestGlobals) {
   const engine = await import('./engine.js')
 
@@ -173,11 +189,7 @@ export async function installJestEnvironment(jestGlobals) {
       assert.fail('Requiring non-bundled plugins from bundle is unsupported')
     }
   } else if (config.rootDir) {
-    const { resolve } = await import('node:path')
-    const { createRequire } = await import('node:module')
-    const { pathToFileURL } = await import('node:url')
-    const require = createRequire(resolve(config.rootDir, 'package.json'))
-    dynamicImport = (path) => import(pathToFileURL(require.resolve(path))) // does not need json imports
+    dynamicImport = await makeDynamicImport(config.rootDir)
   } else {
     dynamicImport = async () => assert.fail('Unreachable: importing plugins without a rootDir')
   }

package/src/jest.fn.js

@@ -23,6 +23,7 @@ export const jestFunctionMocks = {
     if (desc?.get && !desc.set && desc.configurable && desc.enumerable) delete obj[name] // e.g. a wrapped module
     // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
     obj[name] = fn
+    if (Symbol.dispose) fn[Symbol.dispose] = () => fn.mockRestore()
     return fn
   },
   clearAllMocks: applyAllWrap('mockClear'),

package/src/jest.js

@@ -6,7 +6,8 @@ import { jestModuleMocks } from './jest.mock.js'
 import * as jestTimers from './jest.timers.js'
 import { setupSnapshots } from './jest.snapshot.js'
 import { createCallerLocationHook } from './dark.cjs'
-import { exodus } from './exodus.js'
+import * as exodus from './exodus.js'
+import * as mock from './mock.js'
 import { expect } from './expect.cjs'
 import { format as prettyFormat } from './pretty-format.cjs'
 import { timersTrack, timersDebug } from './timers-track.js'
@@ -247,12 +248,13 @@ if (process.env.EXODUS_TEST_PLATFORM !== 'deno' && globalThis.process) {
   }
 }
 
-export const jest = {
-  exodus: {
+// jest.exodus extension
+function makeJestExodus() {
+  return {
     __proto__: null,
     ...exodus,
     mock: {
-      ...exodus.mock,
+      ...mock,
       fetchNoop: () => {
         // We can't use pure noop, it will break chained fetch().then(), so let's reject
         const fetch = () => Promise.reject(new Error('fetch is disabled by mock.fetchNoop()'))
@@ -264,7 +266,15 @@ export const jest = {
         return globalThis.WebSocket
       },
     },
-  },
+  }
+}
+
+export const jest = {
+  exodus:
+    // eslint-disable-next-line no-undef
+    typeof EXODUS_TEST_LOAD_JESTEXODUS === 'undefined' || EXODUS_TEST_LOAD_JESTEXODUS !== false
+      ? makeJestExodus()
+      : undefined,
   setTimeout: (x) => {
     assert.equal(typeof x, 'number')
     defaultTimeout = x

package/src/jest.mock.js

@@ -253,7 +253,9 @@ function mockCloneItem(obj, cache) {
 
 // TODO: implement for bundles or add a guard against bundles if __mocks__ dir exists
 let loadMocksDirMock
-if (process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle') {
+
+// Optimized out in 'bundle' env
+function installMockDirs() {
   const { existsSync, readdirSync, statSync } = require('node:fs')
   const { dirname, join, extname } = require('node:path')
   const dirs = []
@@ -290,7 +292,7 @@ if (process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle') {
     }
   }
 
-  // Automock does't work on import() in jest anyway, so it's ok to let that require manual jest.mock()
+  // Automock does't work on import() in jest anyway, so it's ok to let that require manual jest.mock
   if (shouldAutoMock.size > 0) {
     const { Module } = require('node:module')
     const _require = Module.prototype.require
@@ -305,6 +307,8 @@ if (process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle') {
   }
 }
 
+if (process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle') installMockDirs()
+
 function jestmock(name, mocker, { override = false, actual, builtin, loc } = {}) {
   // Loaded ESM: isn't mocked
   // Loaded CJS: mocked via object overriding

package/src/jest.snapshot.js

@@ -9,8 +9,7 @@ import {
 import { formatWithAllPlugins } from './pretty-format.cjs'
 import { jestConfig } from './jest.config.js'
 import { getTestNamePath } from './dark.cjs'
-import { haveSnapshotsReportUnescaped } from './version.js'
-import { matchSnapshot, escapeSnapshot } from './engine.pure.snapshot.cjs'
+import { matchSnapshot } from './engine.pure.snapshot.cjs'
 
 const { snapshotFormat, snapshotSerializers } = jestConfig()
 const plugins = []
@@ -140,8 +139,7 @@ const snapOnDisk = (expect, orig, matcherOrSnapshotName, snapshotName) => {
     wrapContextName(() => context.assert.snapshot(obj), name)
   } catch (e) {
     if (typeof e.expected === 'string') {
-      const escaped = haveSnapshotsReportUnescaped ? e.expected : escapeSnapshot(e.expected)
-      const final = escaped.includes('\n') ? escaped : `\n${escaped}\n`
+      const final = e.expected.includes('\n') ? e.expected : `\n${e.expected}\n`
       if (final === e.actual) return
     }
 

package/src/jest.timers.js

@@ -1,20 +1,8 @@
 import { mock, assert, awaitForMicrotaskQueue } from './engine.js'
 import { jestConfig } from './jest.config.js'
-import { haveValidTimers, haveNoTimerInfiniteLoopBug } from './version.js'
-
-const assertHaveTimers = () =>
-  assert(mock.timers, 'Timer mocking requires Node.js >=20.4.0 || 18 >=18.19.0')
-
-let timersWarned = false
-const warnOldTimers = () => {
-  if (haveValidTimers || timersWarned) return
-  timersWarned = true
-  console.warn('Warning: timer mocks are known to be glitchy before Node.js >=20.11.0')
-}
 
 let enabled = false
 const assertEnabledTimers = () => {
-  assertHaveTimers()
   assert(enabled, 'You should enable MockTimers first by calling useFakeTimers()')
 }
 
@@ -27,15 +15,12 @@ export function useRealTimers() {
 const doNotFakeDefault = jestConfig().fakeTimers?.doNotFake ?? []
 
 export function useFakeTimers({ doNotFake = doNotFakeDefault, ...rest } = {}) {
-  assertHaveTimers()
-  warnOldTimers()
   assert.deepEqual(rest, {}, 'Unsupported options')
-  const allApis = ['setInterval', 'setTimeout', 'setImmediate']
-  if (haveValidTimers) allApis.push('Date') // vas not supported in older versions
+  const allApis = ['setInterval', 'setTimeout', 'setImmediate', 'Date']
   for (const name of doNotFake) assert(allApis.includes(name), `Unknown API: ${name}`)
   const apis = allApis.filter((name) => !doNotFake.includes(name))
   try {
-    mock.timers.enable(haveValidTimers ? { apis } : apis) // in older (aka glitchy) versions it's an array
+    mock.timers.enable({ apis })
   } catch (e) {
     // We allow calling this multiple times and swallow the "MockTimers is already enabled!" error
     if (e.code !== 'ERR_INVALID_STATE') throw e
@@ -62,7 +47,6 @@ export function runAllTimers() {
 
 export function runOnlyPendingTimers() {
   assertEnabledTimers()
-  assert(haveNoTimerInfiniteLoopBug, 'runOnlyPendingTimers requires Node.js >=20.11.0')
   mock.timers.runAll()
   return this
 }

package/src/mock.js

@@ -0,0 +1,25 @@
+export { fetchReplay, websocketRecord, fetchRecord, websocketReplay } from './replay.js'
+export { timersTrack, timersDebug, timersList, timersAssert } from './timers-track.js'
+
+export function timersSpeedup(rate, { apis = ['setTimeout', 'setInterval', 'Date'] } = {}) {
+  if (!(typeof rate === 'number' && rate > 0)) throw new TypeError('Expected a positive rate')
+  const { setTimeout, setInterval, Date: OrigDate } = globalThis
+  for (const api of apis) {
+    // eslint-disable-next-line unicorn/prefer-switch
+    if (api === 'setTimeout') {
+      globalThis.setTimeout = (fn, ms, ...args) => setTimeout(fn, Math.ceil(ms / rate), ...args)
+    } else if (api === 'setInterval') {
+      globalThis.setInterval = (fn, ms, ...args) => setInterval(fn, Math.ceil(ms / rate), ...args)
+    } else if (api === 'Date') {
+      const base = OrigDate.now()
+      globalThis.Date = class Date extends OrigDate {
+        static now = () => base + Math.floor((OrigDate.now() - base) * rate)
+        constructor(first = globalThis.Date.now(), ...rest) {
+          super(first, ...rest)
+        }
+      }
+    } else {
+      throw new Error(`Unknown or unsupported API in timersSpeedup(): ${api}`)
+    }
+  }
+}

package/src/replay.js

@@ -3,18 +3,20 @@ const recordingResolver = (type) => (dir, name) => [dir, '__recordings__', type,
 let replay
 let readRecordingRaw, writeRecording
 
-if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
-  replay = require('@exodus/replay') // we can do this in bundle
-  // eslint-disable-next-line no-undef
-  const files = EXODUS_TEST_FILES
-  const baseFile = files.length === 1 ? files[0] : undefined
-  // eslint-disable-next-line no-undef
-  const map = typeof EXODUS_TEST_RECORDINGS !== 'undefined' && new Map(EXODUS_TEST_RECORDINGS)
-  const resolveRecording = (resolver, f) => resolver(f[0], f[1]).join('/')
-  readRecordingRaw = (resolver) => (baseFile ? map.get(resolveRecording(resolver, baseFile)) : null)
-} else {
+function loadReplayBundle() {
+  // TODO: also under process.features.require_module
+  if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+    replay = require('@exodus/replay') // synchronous
+  } else if (!replay) {
+    throw new Error('Failed to load @exodus/replay')
+  }
+}
+
+// Optimized out in 'bundle' env
+async function loadNonBundle() {
+  // Preload if synchronous lazy-loading is unavailable
+  // TODO: not under process?.features?.require_module
   try {
-    // TODO: we can synchronously lazy-load it under process.features.require_module
     replay = await import('@exodus/replay')
   } catch {}
 
@@ -56,8 +58,19 @@ if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
   }
 }
 
+if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+  // eslint-disable-next-line no-undef
+  const files = EXODUS_TEST_FILES
+  const baseFile = files.length === 1 ? files[0] : undefined
+  // eslint-disable-next-line no-undef
+  const map = new Map(typeof EXODUS_TEST_RECORDINGS === 'undefined' ? [] : EXODUS_TEST_RECORDINGS)
+  const resolveRecording = (resolver, f) => resolver(f[0], f[1]).join('/')
+  readRecordingRaw = (resolver) => (baseFile ? map.get(resolveRecording(resolver, baseFile)) : null)
+} else {
+  await loadNonBundle()
+}
+
 function readRecording(resolver) {
-  if (!readRecordingRaw) throw new Error('Replaying recordings is not supported in this engine')
   const data = readRecordingRaw(resolver)
   if (typeof data !== 'string') throw new Error('Can not read recording')
   return JSON.parse(data)
@@ -66,7 +79,7 @@ function readRecording(resolver) {
 const log = { websocket: undefined, fetch: undefined }
 
 export function fetchRecord(options) {
-  if (!replay) throw new Error('Failed to load @exodus/replay')
+  loadReplayBundle()
   if (log.fetch) throw new Error('Can not record again: already recording or replaying!')
   if (!writeRecording) throw new Error('Writing fetch log is not supported on this engine')
   log.fetch = []
@@ -77,7 +90,7 @@ export function fetchRecord(options) {
 }
 
 export function fetchReplay() {
-  if (!replay) throw new Error('Failed to load @exodus/replay')
+  loadReplayBundle()
   if (log.fetch) throw new Error('Can not replay: already recording or replaying!')
   log.fetch = readRecording(recordingResolver('fetch')) // Re-initialized from start on each call
   const fetch = replay.fetchReplayer(log.fetch)
@@ -86,7 +99,7 @@ export function fetchReplay() {
 }
 
 export function websocketRecord(options) {
-  if (!replay) throw new Error('Failed to load @exodus/replay')
+  loadReplayBundle()
   if (log.websocket) throw new Error('Can not record: already recording or replaying!')
   if (!writeRecording) throw new Error('Writing WebSocket log is not supported on this engine')
   log.websocket = []
@@ -97,7 +110,7 @@ export function websocketRecord(options) {
 }
 
 export function websocketReplay(options) {
-  if (!replay) throw new Error('Failed to load @exodus/replay')
+  loadReplayBundle()
   if (log.websocket) throw new Error('Can not replay: already recording or replaying!')
   log.websocket = readRecording(recordingResolver('websocket')) // Re-initialized from start on each call
   const WebSocket = replay.WebSocketReplayer(log.websocket, options)

package/src/version.js

@@ -1,21 +1,12 @@
 import { assert, nodeVersion } from './engine.js'
 
 const [major, minor, patch] = nodeVersion.split('.').map(Number)
-// older versions are glitchy with before/after on top-level, which is a deal-breaker
-// 20.7.0 is fine for node:test but broken with tsx, so we bump to 20.8.0
-const ok = (major === 18 && minor >= 19) || (major === 20 && minor >= 8) || major >= 22
-assert(ok, 'Node.js version too old or glitchy with node:test, use ^18.19.0 || ^20.8.0 || >=22.0.0')
-assert(major !== 22 || minor !== 3, 'Refusing to run on Node.js 22.3.0 specifically, do not use it') // safe-guard
+// Before 20.18, there are no module mocks
+const ok = (major === 20 && minor >= 18) || (major === 22 && minor >= 6) || major > 22
+assert(ok, 'Node.js version too old, use ^20.18.0 || >=22.6.0')
 
 export { major, minor, patch }
 
-export const haveModuleMocks =
-  (major === 20 && minor >= 18) || (major === 22 && minor >= 3) || major > 22
-export const haveSnapshots = (major === 22 && minor >= 3) || major > 22
-export const haveSnapshotsReportUnescaped = (major === 22 && minor >= 5) || major > 22
-export const haveForceExit = (major === 20 && minor > 13) || major >= 22
-export const haveValidTimers = (major === 20 && minor >= 11) || major >= 22 // older glitch in various ways / stop executing
-export const haveNoTimerInfiniteLoopBug = (major === 20 && minor >= 11) || major >= 22 // mock.timers.runAll() can get into infinite recursion
+// actually 22.3, but prior to 22.5 escaping is wrong. We don't support 22.3-22.5 anyway
+export const haveSnapshots = (major === 22 && minor >= 5) || major > 22
 export const haveCoverExclude = (major === 22 && minor >= 5) || major > 22
-export const haveNetworkInspection =
-  (major === 20 && minor >= 18) || (major === 22 && minor >= 6) || major > 22