@exodus/test 1.0.0-rc.70 → 1.0.0-rc.71

package/bundler/bundle.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict'
-import { readFile, readdir } from 'node:fs/promises'
+import { readFile, writeFile, readdir } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { basename, dirname, extname, resolve, join, relative } from 'node:path'
@@ -11,6 +11,8 @@ import glob from 'fast-glob'
 const require = createRequire(import.meta.url)
 const resolveRequire = (query) => require.resolve(query)
 const resolveImport = import.meta.resolve && ((query) => fileURLToPath(import.meta.resolve(query)))
+const cjsMockRegex = /\.exodus-test-mock\.cjs$/u
+const cjsMockFallback = `throw new Error('Mocking loaded ESM modules in not possible in bundles')`
 
 const readSnapshots = async (files, resolvers) => {
   const snapshots = []
@@ -28,12 +30,42 @@ const readSnapshots = async (files, resolvers) => {
   return snapshots
 }
 
+const stringify = (x) => ([undefined, null].includes(x) ? `${x}` : JSON.stringify(x))
 const loadPipeline = [
   function (source, filepath) {
-    return source
+    let res = source
       .replace(/\bimport\.meta\.url\b/g, JSON.stringify(pathToFileURL(filepath)))
       .replace(/\b(__dirname|import\.meta\.dirname)\b/g, JSON.stringify(dirname(filepath)))
       .replace(/\b(__filename|import\.meta\.filename)\b/g, JSON.stringify(filepath))
+
+    // Unneded polyfills
+    for (const [a, b] of Object.entries({
+      'is-nan': 'Number.isNaN', // https://www.npmjs.com/package/is-nan description: ES2015-compliant shim for Number.isNaN
+      'is-nan/polyfill': '() => Number.isNaN',
+      'object.assign': 'Object.assign',
+      'object.assign/polyfill': '() => Object.assign',
+      'object-is': 'Object.is',
+      'object-is/polyfill': '() => Object.is',
+      hasown: 'Object.hasOwn',
+      gopd: 'Object.getOwnPropertyDescriptor',
+      'has-property-descriptors': '() => true',
+      'has-symbols': '() => true',
+      'has-symbols/shams': '() => true',
+      'has-tostringtag': "() => typeof Symbol.toStringTag === 'symbol'",
+      'has-tostringtag/shams': '() => !!Symbol.toStringTag',
+      'es-define-property': 'Object.defineProperty',
+      'es-errors': 'Error',
+      'es-errors/eval': 'EvalError',
+      'es-errors/range': 'RangeError',
+      'es-errors/ref': 'ReferenceError',
+      'es-errors/syntax': 'SyntaxError',
+      'es-errors/type': 'TypeError',
+      'es-errors/uri': 'URIError',
+    })) {
+      res = res.replaceAll(`require('${a}')`, `(${b})`).replaceAll(`require("${a}")`, `(${b})`) // Assumes well-formed names/code
+    }
+
+    return res
   },
 ]
 
@@ -98,7 +130,7 @@ const loadCache = new Map()
 const loadSourceFileBase = async (filepath) => {
   if (!loadCache.has(filepath)) {
     const load = async () => {
-      let contents = await readFile(filepath, 'utf8')
+      let contents = await readFile(filepath.replace(cjsMockRegex, ''), 'utf8')
       for (const transform of loadPipeline) contents = await transform(contents, filepath)
       return contents
     }
@@ -124,7 +156,6 @@ export const build = async (...files) => {
   const input = []
   const importSource = async (file) => input.push(await loadSourceFile(resolveRequire(file)))
   const importFile = (...args) => input.push(`await import(${JSON.stringify(resolve(...args))});`)
-  const stringify = (x) => ([undefined, null].includes(x) ? `${x}` : JSON.stringify(x))
 
   if (!['node', 'electron'].includes(options.platform)) {
     if (process.env.EXODUS_TEST_IS_BAREBONE) {
@@ -182,7 +213,7 @@ export const build = async (...files) => {
   const fsFilesDirs = new Map()
   const cwd = process.cwd()
   const fixturesRegex = /(fixtures|samples)/u
-  const aggressiveExtensions = /\.(json|txt|hex)$/u // These are bundled when just used in path.join and by wildcard from fixtures/
+  const aggressiveExtensions = /\.(json|txt|hex|wasm)$/u // These are bundled when just used in path.join and by wildcard from fixtures/
   const fileAllowed = (f) =>
     f && f.startsWith(`${cwd}/`) && resolve(f) === f && /^[a-z0-9@_./-]+$/iu.test(relative(cwd, f))
 
@@ -241,7 +272,28 @@ export const build = async (...files) => {
     if (/(readdir|readFile|exists)Sync/u.test(source)) await fsFilesBundleFixtures('fs')
     if (fixturesRegex.test(source)) await fsFilesBundleFixtures('fixtures')
 
-    return source
+    // Resolve require.resolve and bundle those files for fixture or json extensions (e.g. package.json)
+    let filepathRequire
+    const toAdd = []
+    const res = source.replace(
+      /\b(require|import\.meta)\.resolve\(\s*(?:"([^"\\]+)"|'([^'\\]+)')\s*\)/gu,
+      (orig, cause, a, b) => {
+        if (!filepathRequire) filepathRequire = createRequire(filepath)
+        try {
+          const file = filepathRequire.resolve(a || b)
+          if (aggressiveExtensions.test(file)) toAdd.push(file) // load resolved files for specific extensions
+          if (cause === 'require') return `(${stringify(file)})`
+          // Do not replace import.meta.resolve for non-fixture extensions, might cause misresolutions
+          return aggressiveExtensions.test(file) ? `(${stringify(pathToFileURL(file))})` : orig
+        } catch {
+          return orig
+        }
+      }
+    )
+
+    for (const file of toAdd) await fsFilesAdd(file)
+
+    return res
   })
 
   if (files.length === 1) {
@@ -266,6 +318,7 @@ export const build = async (...files) => {
     'fs/promises': api('fs-promises.cjs'),
     http: api('http.cjs'),
     https: api('https.cjs'),
+    module: api('module.cjs'),
     os: resolveRequire('os-browserify/browser.js'), // 'main' entry point is noop, we want browser entry
     path: resolveRequire('path-browserify'),
     querystring: resolveRequire('querystring-es3'),
@@ -273,7 +326,7 @@ export const build = async (...files) => {
     timers: resolveRequire('timers-browserify'),
     tty: api('tty.cjs'),
     url: api('url.cjs'),
-    util: dirname(resolveRequire('util/')),
+    util: api('util.cjs'),
     zlib: resolveRequire('browserify-zlib'),
   }
 
@@ -294,6 +347,7 @@ export const build = async (...files) => {
       'process.stderr': 'undefined',
       'process.stdout': 'undefined',
       'process.type': 'undefined',
+      'process.platform': 'undefined',
       'process.version': stringify('v22.5.1'), // shouldn't depend on currently used Node.js version
       'process.versions.node': stringify('22.5.1'), // see line above
       EXODUS_TEST_PROCESS_CWD: stringify(process.cwd()),
@@ -318,6 +372,7 @@ export const build = async (...files) => {
       ...nodeUnprefixed,
       // Needed for polyfills but name conflicts with Node.js modules
       'url/url.js': resolveRequire('url/url.js'),
+      'util/util.js': resolveRequire('util/util.js'),
       // expect-related deps
       'ansi-styles': api('ansi-styles.cjs'),
       'jest-util': api('jest-util.js'),
@@ -339,7 +394,12 @@ export const build = async (...files) => {
     plugins: [
       {
         name: 'exodus-test.bundle',
-        setup({ onLoad }) {
+        setup({ onResolve, onLoad }) {
+          onResolve({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+            if (shouldInstallMocks && cjsMockRegex.test(args.path)) {
+              return { path: args.path, namespace: 'file' }
+            }
+          })
           onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: 'file' }, async (args) => {
             let filepath = args.path
             // Resolve .native versions
@@ -359,6 +419,46 @@ export const build = async (...files) => {
     ],
   }
 
+  let shouldInstallMocks = false
+  const mocked = new Set()
+  specificLoadPipeline.push(async (source, filepath) => {
+    if (shouldInstallMocks) {
+      if (cjsMockRegex.test(filepath)) return cjsMockFallback
+      if (mocked.has(filepath) && !filepath.endsWith('.cjs') && /^export\b/mu.test(source)) {
+        const mock = stringify(`${filepath}.exodus-test-mock.cjs`)
+        const def = 'x.__esModule ? x.default : (x.default ?? x)'
+        return `export * from ${mock}\nvar x = require(${mock})\nexport default ${def}`
+      }
+    }
+
+    // 'await import' is replaced only in files with mocks (likely toplevel there)
+    // Otherwise we don't patch module system at all
+    if (!source.includes('jest.doMock') && !source.includes('jest.mock')) return source
+    shouldInstallMocks = true
+    const filepathRequire = createRequire(filepath)
+    return source
+      .replaceAll(/\bawait (import\((?:"[^"\\]+"|'[^'\\]+')\))/gu, 'EXODUS_TEST_SYNC_IMPORT($1)')
+      .replaceAll(
+        /\bjest\.(doMock|mock|requireActual|requireMock)\(\s*("[^"\\]+"|'[^'\\]+')/gu,
+        (_, method, raw) => {
+          try {
+            const arg = JSON.parse(raw[0] === "'" ? raw.replaceAll("'", '"') : raw) // fine because it doesn't have quotes or \
+            const { alias } = config
+            const file = Object.hasOwn(alias, arg) ? alias[arg] : filepathRequire.resolve(arg) // throws when not resolved
+            assert(existsSync(file), `File ${file} does not exist`)
+            const builtin = stringify(Object.hasOwn(alias, arg) ? arg.replace(/^node:/, '') : null)
+            const id = `bundle:${relative(cwd, file)}`
+            if (method.startsWith('require')) return `jest.${method}(${stringify(id)}`
+            mocked.add(file)
+            return `jest.__${method}Bundle(${stringify(id)},${builtin},()=>require(${raw})`
+          } catch (err) {
+            console.error(err)
+            throw new Error(`Failed to mock ${raw}: not resolved`, { cause: err })
+          }
+        }
+      )
+  })
+
   if (files.length === 1) {
     config.define['process.argv'] = stringify(['exodus-test', resolve(files[0])])
   }
@@ -379,6 +479,24 @@ export const build = async (...files) => {
     assert.equal(res instanceof Error, res.errors.length > 0)
   }
 
+  if (res.errors.length === 0 && shouldInstallMocks) {
+    const code = await readFile(outfile, 'utf8')
+    const heads = {
+      esm: /(var __esm = (?:function)?\((fn[\d]*), res[\d]*\)\s*(?:=>|\{\s*return)\s*)(function __init[\d]*\(\) \{)/u,
+      cjs: /(var __commonJS = (?:function)?\((cb[\d]*), mod[\d]*\)\s*(?:=>|\{\s*return)\s*)(function __require[\d]*\(\) \{)/u,
+    }
+    const k = '__getOwnPropNames($2)[0]'
+    const mock = (p, l, v) =>
+      `var ${p}=new Set(),${l}=new Set(),${v}=new Map();$1${p}.add(${k}) && $3;{const k=${k};${l}.add(k);if (${v}.has(k))return ${v}.get(k)};`
+    assert(heads.esm.test(code) && heads.cjs.test(code), 'Failed to match for module mocks')
+    const patched = code
+      .replace(heads.esm, mock('__mocksESMPossible', '__mocksESMLoaded', '__mocksESM')) // __mocksESM actually doesn't work
+      .replace(heads.cjs, mock('__mocksCJSPossible', '__mocksCJSLoaded', '__mocksCJS'))
+      .replaceAll('EXODUS_TEST_SYNC_IMPORT(Promise.resolve().then(', '((f=>f())(')
+    assert(!patched.includes('EXODUS_TEST_SYNC_IMPORT'), "Failed to fix 'await import'")
+    await writeFile(outfile, patched)
+  }
+
   // if (res.errors.length === 0) require('fs').copyFileSync(outfile, 'tempout.cjs') // DEBUG
 
   // We treat warnings as errors, so just merge all them

package/bundler/modules/globals.cjs

@@ -5,6 +5,7 @@ if (!globalThis.global) globalThis.global = globalThis
 if (!globalThis.Buffer) globalThis.Buffer = require('buffer').Buffer
 
 const consoleKeys = ['log', 'error', 'warn', 'info', 'debug', 'trace']
+const { print } = globalThis
 if (!globalThis.console) globalThis.console = Object.fromEntries(consoleKeys.map((k) => [k, print])) // eslint-disable-line no-undef
 
 // In browsers e.g. errors (and some other objects) are hard to unwrap via the API
@@ -12,6 +13,7 @@ if (!globalThis.console) globalThis.console = Object.fromEntries(consoleKeys.map
 // In barebone, we don't want console.log({x:10}) to print "[Object object]"", we want "{ x: 10 }"
 if (process.env.EXODUS_TEST_IS_BROWSER || process.env.EXODUS_TEST_IS_BAREBONE) {
   const utilFormat = require('exodus-test:util-format')
+  if (print) globalThis.print = (...args) => print(utilFormat(...args))
   for (const type of consoleKeys) {
     if (!Object.hasOwn(console, type)) continue
     const orig = console[type].bind(console)
@@ -49,10 +51,12 @@ if (!globalThis.WebSocket) {
 }
 
 if (!Array.prototype.at) {
-  // eslint-disable-next-line no-extend-native
-  Array.prototype.at = function (i) {
+  const at = function (i) {
     return this[i < 0 ? this.length + i : i]
   }
+
+  // eslint-disable-next-line no-extend-native
+  Object.defineProperty(Array.prototype, 'at', { configurable: true, writable: true, value: at })
 }
 
 if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
@@ -66,6 +70,43 @@ if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
       )
     Promise.allSettled = (iterable) => Promise.all([...iterable].map((element) => wrap(element)))
   }
+
+  // Refs: https://github.com/facebook/hermes/commit/e97db61b49bd0c065a3ce7da46f074bc39b80c6a
+  if (!Promise.any) {
+    const AggregateError =
+      globalThis.AggregateError ||
+      class AggregateError extends Error {
+        constructor(errors, message) {
+          super(message)
+          this.name = 'AggregateError'
+          this.errors = errors
+        }
+      }
+
+    const errmsg = 'All promises were rejected'
+    Promise.any = function (values) {
+      const promises = [...values]
+      const errors = []
+      if (promises.length === 0) return Promise.reject(new AggregateError(errors, errmsg))
+      let resolved = false
+      return new Promise((resolve, reject) => {
+        const oneResolve = (value) => {
+          if (resolved) return
+          resolved = true
+          errors.length = 0
+          resolve(value)
+        }
+
+        const oneReject = (error) => {
+          if (resolved) return
+          errors.push(error)
+          if (errors.length === promises.length) reject(new AggregateError(errors, errmsg))
+        }
+
+        promises.forEach((promise) => Promise.resolve(promise).then(oneResolve, oneReject))
+      })
+    }
+  }
 }
 
 if (globalThis.describe) delete globalThis.describe

package/bundler/modules/module.cjs

@@ -0,0 +1,16 @@
+const ids = 'Module,SourceMap,builtinModules,findSourceMap,globalPaths,isBuiltin,runMain'.split(',')
+
+const makeMethod = (key) => {
+  // Not an arrow as there are classes that can be called with new
+  return function () {
+    throw new Error(`module.${key} unsupported in bundled mode`)
+  }
+}
+
+const createRequire = (filename) => (file) => {
+  const clean = file.replace(/^node:/, '')
+  if (globalThis.EXODUS_TEST_MOCK_BUILTINS?.has(clean)) return EXODUS_TEST_MOCK_BUILTINS.get(clean) // eslint-disable-line no-undef
+  throw new Error(`module.createRequire is unsupported in bundled mode (origin: ${filename})`)
+}
+
+module.exports = { ...Object.fromEntries(ids.map((key) => [key, makeMethod(key)])), createRequire }

package/bundler/modules/util-format.cjs

@@ -1,4 +1,4 @@
-const { inspect: inspectOrig, isString, isNull, isObject } = require('util/') // dep
+const { inspect: inspectOrig, isString, isNull, isObject } = require('util/util.js') // dep
 
 // Print errors without square brackets
 const trim = (x) => x.trim()

package/bundler/modules/util.cjs

@@ -0,0 +1,4 @@
+const util = require('util/util.js')
+const format = require('./util-format.cjs')
+const { TextEncoder, TextDecoder } = globalThis
+module.exports = { ...util, format, TextEncoder, TextDecoder }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.70",
+  "version": "1.0.0-rc.71",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -58,10 +58,12 @@
     "bundler/modules/globals.cjs",
     "bundler/modules/jest-message-util.js",
     "bundler/modules/jest-util.js",
+    "bundler/modules/module.cjs",
     "bundler/modules/node-buffer.cjs",
     "bundler/modules/text-encoding-utf.cjs",
     "bundler/modules/tty.cjs",
     "bundler/modules/url.cjs",
+    "bundler/modules/util.cjs",
     "bundler/modules/util-format.cjs",
     "bundler/modules/ws.cjs",
     "loaders/babel.cjs",
@@ -96,8 +98,8 @@
   ],
   "scripts": {
     "test:_pure": "EXODUS_TEST_IGNORE='tests/jest-extended/**' npm run test",
-    "test:_bundle": "EXODUS_TEST_IGNORE='tests/{{jest-extended,inband}/**,jest-when/when.test.*,jest/jest.resetModules.*,{jest,jest-superset}/mock/jest.mock.*}' npm run test",
-    "test": "npm run test:jest",
+    "test:_bundle": "EXODUS_TEST_IGNORE='tests/{{jest-extended,inband}/**,jest-when/when.test.*,jest/jest.resetModules.*}' npm run test --",
+    "test": "npm run test:jest --",
     "test:all": "npm run test:jest && npm run test:tape && npm run test:native && npm run test:pure && npm run test:typescript && npm run test:fetch && npm run test:jsdom",
     "test:native": "EXODUS_TEST_IGNORE='{**/typescript/**,**/jest-repo/**/user.test.js}' ./bin/index.js --jest 'tests/**/*.test.{js,cjs,mjs}'",
     "test:typescript": "./bin/index.js --jest --typescript tests/typescript.test.ts",
@@ -113,7 +115,10 @@
     "test:chromium:playwright": "EXODUS_TEST_ENGINE=chromium:playwright npm run test:_bundle --",
     "test:firefox:playwright": "EXODUS_TEST_ENGINE=firefox:playwright npm run test:_bundle --",
     "test:webkit:playwright": "EXODUS_TEST_ENGINE=webkit:playwright npm run test:_bundle --",
-    "test:hermes": "EXODUS_TEST_ENGINE=hermes:bundle npm run test:_bundle",
+    "test:bundle": "EXODUS_TEST_ENGINE=node:bundle npm run test:_bundle --",
+    "test:d8": "EXODUS_TEST_ENGINE=d8:bundle npm run test:_bundle --",
+    "test:jsc": "EXODUS_TEST_ENGINE=jsc:bundle npm run test:_bundle --",
+    "test:hermes": "EXODUS_TEST_ENGINE=hermes:bundle npm run test:_bundle --",
     "test:fetch": "./bin/index.js --jest --drop-network --engine node:pure tests/fetch.test.js tests/websocket.test.js",
     "test:jsdom": "EXODUS_TEST_JEST_CONFIG='{\"testMatch\":[\"**/*.jsdom-test.js\"],\"testEnvironment\":\"jsdom\", \"rootDir\": \".\"}' ./bin/index.js --jest",
     "coverage": "./bin/index.js --jest --esbuild --coverage",

package/src/dark.cjs

@@ -19,33 +19,34 @@ let getCallerLocation
 
 function createCallerLocationHook() {
   if (getCallerLocation) return { installLocationInNextTest, getCallerLocation }
-
-  try {
-    const { Test } = require('node:internal/test_runner/test')
-    const { fileURLToPath } = require('node:url')
-    const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
-    const locStorage = new Map()
-    Object.defineProperty(Test.prototype, 'loc', {
-      get() {
-        return locStorage.get(this)
-      },
-      set(val) {
-        locStorage.set(this, val)
-        if (locForNextTest) {
-          const loc = locForNextTest
-          locForNextTest = undefined
-          locStorage.set(this, { line: loc[0], column: loc[1], file: mayBeUrlToPath(loc[2]) })
-        }
-      },
-    })
-
-    // We can replicate getCallerLocation() with public V8 Error CallSite API, but we won't
-    // need it anyway if we don't have a path for hook into internal Test implementation
-
-    const { internalBinding } = require('node:internal/test/binding')
-    getCallerLocation = internalBinding('util').getCallerLocation
-  } catch {
-    getCallerLocation = () => {}
+  getCallerLocation = () => {}
+
+  if (process.env.EXODUS_TEST_ENGINE === 'node:test') {
+    try {
+      const { Test } = require('node:internal/test_runner/test')
+      const { fileURLToPath } = require('node:url')
+      const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
+      const locStorage = new Map()
+      Object.defineProperty(Test.prototype, 'loc', {
+        get() {
+          return locStorage.get(this)
+        },
+        set(val) {
+          locStorage.set(this, val)
+          if (locForNextTest) {
+            const loc = locForNextTest
+            locForNextTest = undefined
+            locStorage.set(this, { line: loc[0], column: loc[1], file: mayBeUrlToPath(loc[2]) })
+          }
+        },
+      })
+
+      // We can replicate getCallerLocation() with public V8 Error CallSite API, but we won't
+      // need it anyway if we don't have a path for hook into internal Test implementation
+
+      const { internalBinding } = require('node:internal/test/binding')
+      getCallerLocation = internalBinding('util').getCallerLocation
+    } catch {}
   }
 
   return { installLocationInNextTest, getCallerLocation }
@@ -56,51 +57,53 @@ function getTestNamePath(t) {
   // No implementation in Node.js yet, will have to PR
   if (t.fullName) return t.fullName.split(' > ')
 
-  // 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')
+  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')
+
+      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
+        },
+      })
+
+      return t[namePath]
+    } catch {}
+  }
 
   return [t.name] // last resort
 }

package/src/jest.js

@@ -222,9 +222,10 @@ export const jest = {
     features: {
       __proto__: null,
       timers: Boolean(mock.timers && haveValidTimers),
-      esmMocks: Boolean(mock.module && !isBundle), // full support for ESM mocks
+      dynamicRequire: Boolean(!isBundle), // require(non-literal-non-glob), createRequire()(non-builtin)
+      esmMocks: Boolean(mock.module || isBundle), // support for ESM mocks
       esmInterop: Boolean(insideEsbuild && !isBundle), // loading/using ESM as CJS, ESM mocks creation without a mocker function
-      esmNamedBuiltinMocks: Boolean(mock.module || (insideEsbuild && !isBundle)), // support for named ESM imports from builtin module mocks
+      esmNamedBuiltinMocks: Boolean(mock.module || insideEsbuild || isBundle), // support for named ESM imports from builtin module mocks
       concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
     },
     mock: {

package/src/jest.mock.js

@@ -34,7 +34,38 @@ export const jestModuleMocks = {
   resetModules,
 }
 
+if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+  globalThis.EXODUS_TEST_MOCK_BUILTINS = new Map()
+  Object.assign(jestModuleMocks, {
+    __mockBundle: wrap((name, builtin, actual, mock) =>
+      jestmock(name, mock, { actual, builtin, override: true })
+    ),
+    __doMockBundle: wrap((name, builtin, actual, mock) =>
+      jestmock(name, mock, { actual, builtin })
+    ),
+  })
+}
+
+// For bundles
+const cjsSet = typeof __mocksCJSPossible === 'undefined' ? null : __mocksCJSPossible // eslint-disable-line no-undef
+const esmSet = typeof __mocksESMPossible === 'undefined' ? null : __mocksESMPossible // eslint-disable-line no-undef
+
 function resolveModule(name) {
+  if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+    assert(name.startsWith('bundle:'), `Can't mock unresolved ${name} in bundle, use static syntax`)
+    assert(cjsSet && esmSet, 'Module mocking not installed correctly in bundle')
+    const id = name.replace(/^bundle:/u, '')
+    assert(!cjsSet?.has(id) || !esmSet?.has(id), 'CJS/ESM conflict in bundle mock')
+    assert(cjsSet?.has(id) || esmSet?.has(id), `Mock: can not find ${id} in bundle. Unused mock?`)
+    const cjs = `${id}.exodus-test-mock.cjs`
+    if (esmSet.has(id) && cjsSet.has(cjs)) {
+      assert(!esmSet.has(cjs))
+      return cjs
+    }
+
+    return id
+  }
+
   assert(requireIsRelative || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
   const unprefixed = name.replace(/^node:/, '')
   if (builtinModules.includes(unprefixed)) return unprefixed
@@ -182,15 +213,16 @@ function mockCloneItem(obj, cache) {
   return null
 }
 
-function jestmock(name, mocker, { override = false } = {}) {
-  assert(process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle', 'module mocks unsupported from bundle') // TODO: can we do something?
-
+function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
   // Loaded ESM: isn't mocked
   // Loaded CJS: mocked via object overriding
   // Loaded built-ins: mocked via object overriding where possible
-  // New CJS: mocked via mock.module + require.cache
-  // New ESM: mocked via mock.module
+  // New CJS, doMock CJS: mocked via mock.module + require.cache
+  // New ESM, doMock ESM: mocked via mock.module
   // New built-ins: mocked via mock.module
+  // [Bundled] New CJS, doMock CJS: mocked via bundle hook
+  // [Bundled] New ESM, doMock ESM: isn't mocked
+  // [Bundled] New built-ins: mocked via bundle hook
 
   const resolved = resolveModule(name)
   assert(!mapMocks.has(resolved), 'Re-mocking the same module is not supported')
@@ -199,14 +231,24 @@ function jestmock(name, mocker, { override = false } = {}) {
     'Built-in modules mocked with jest.mock can not be remocked, use jest.doMock'
   )
 
+  let havePrior
+  if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+    havePrior = __mocksCJSLoaded.has(resolved) || __mocksESMLoaded.has(resolved) // eslint-disable-line no-undef
+    assert(actual)
+  } else {
+    havePrior = Object.hasOwn(require.cache, resolved)
+    assert(!actual && !builtin)
+  }
+
   // Attempt to load it
   // Jest also loads modules on mock
   // Can be ESM, so let it fail silently
-  const havePrior = Object.hasOwn(require.cache, resolved)
   try {
-    mapActual.set(resolved, require(resolved))
+    assert(!resolved.endsWith('.exodus-test-mock.cjs')) // actual() would attempt to load non-wrapped ESM here
+    mapActual.set(resolved, actual ? actual() : require(resolved))
   } catch {
-    assert(mocker, 'Can not auto-clone a native ESM module without --esbuild or newer Node.js')
+    const reason = actual ? 'in bundle' : 'without --esbuild or newer Node.js'
+    assert(mocker, `Can not auto-clone a native ESM module ${reason}`)
   }
 
   const expand = (obj) => (isObject(obj) ? { ...obj } : obj)
@@ -214,6 +256,22 @@ function jestmock(name, mocker, { override = false } = {}) {
   mapMocks.set(resolved, value)
 
   loadExpect() // we need to do this as we don't want mocks affecting expect
+
+  if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+    if (builtin) globalThis.EXODUS_TEST_MOCK_BUILTINS.set(builtin, value)
+    if (havePrior && override) overrideModule(resolved) // This won't work on ESM
+
+    if (cjsSet?.has(resolved)) {
+      __mocksCJS.set(resolved, value) // eslint-disable-line no-undef
+    } else if (esmSet?.has(resolved)) {
+      throw new Error('ESM module mocks are not supported from bundle') // TODO: can we do something?
+    } else {
+      throw new Error('unreachable')
+    }
+
+    return this
+  }
+
   const topLevelESM = isTopLevelESM()
   let likelyESM = topLevelESM && !insideEsbuild && ![null, resolved].includes(resolveImport(name))
   let okFromESM = false