@exodus/test 1.0.0-rc.26 → 1.0.0-rc.28

package/bin/index.js

@@ -2,9 +2,11 @@
 
 import { spawn } from 'node:child_process'
 import { once } from 'node:events'
-import { fileURLToPath } from 'node:url'
-import { basename, dirname, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { basename, dirname, resolve, join } from 'node:path'
 import { createRequire } from 'node:module'
+import { randomUUID } from 'node:crypto'
+import { existsSync } from 'node:fs'
 import assert from 'node:assert/strict'
 import glob from 'fast-glob'
 import { haveModuleMocks, haveSnapshots, haveForceExit } from '../src/version.js'
@@ -14,11 +16,17 @@ const bindir = dirname(fileURLToPath(import.meta.url))
 const EXTS = `.?([cm])[jt]s?(x)` // we differ from jest, allowing [cm] before everything
 const DEFAULT_PATTERNS = [`**/__tests__/**/*${EXTS}`, `**/?(*.)+(spec|test)${EXTS}`]
 
+const bundleOptions = { pure: true, bundle: true, esbuild: true }
 const ENGINES = new Map(
   Object.entries({
     'node:test': { binary: 'node', pure: false, hasImportLoader: true },
     'node:pure': { binary: 'node', pure: true, hasImportLoader: true },
+    'node:bundle': { binary: 'node', ...bundleOptions },
     'bun:pure': { binary: 'bun', pure: true, hasImportLoader: false },
+    'bun:bundle': { binary: 'bun', ...bundleOptions },
+    'deno:bundle': { binary: 'deno', binaryArgs: ['run'], target: 'deno1', ...bundleOptions },
+    'jsc:bundle': { binary: 'jsc', ...bundleOptions, target: 'safari11' },
+    'hermes:bundle': { binary: 'hermes', binaryArgs: ['-Og'], target: 'es2018', ...bundleOptions },
   })
 )
 
@@ -37,10 +45,6 @@ function parseOptions() {
     debug: { files: false },
     ideaCompat: false,
     engine: process.env.EXODUS_TEST_ENGINE ?? 'node:test',
-    // Engine options
-    binary: 'node',
-    pure: false,
-    hasImportLoader: false,
   }
 
   const args = [...process.argv]
@@ -152,6 +156,11 @@ const resolveImport = import.meta.resolve && ((query) => fileURLToPath(import.me
 
 const args = []
 if (options.pure) {
+  if (options.bundle) {
+    assert(!options.coverage, `Can not use --coverage with ${options.engine} engine`)
+    assert(!options.babel, `Can not use --babel with ${options.engine} engine`) // TODO?
+  }
+
   const requiresNodeCoverage = options.coverage && options.coverageEngine === 'node'
   assert(!requiresNodeCoverage, '"--coverage-engine node" requires "--engine node:test" (default)')
   assert(!options.writeSnapshots, `Can not use write snapshots with ${options.engine} engine`)
@@ -192,10 +201,14 @@ if (process.env.EXODUS_TEST_IGNORE) {
 
 // The comment below is disabled, we don't auto-mock @jest/globals anymore, and having our loader first is faster
 // [Disabled] Our loader should be last, as enabling module mocks confuses other loaders
+let jestConfig = null
 if (options.jest) {
   const { loadJestConfig } = await import('../src/jest.config.js')
   const config = await loadJestConfig(process.cwd())
-  args.push(options.hasImportLoader ? '--import' : '-r', resolve(bindir, 'jest.js'))
+  jestConfig = config
+  if (!options.bundle) {
+    args.push(options.hasImportLoader ? '--import' : '-r', resolve(bindir, 'jest.js'))
+  }
 
   if (config.testFailureExitCode !== undefined) {
     if (Number(config.testFailureExitCode) === 0) {
@@ -229,12 +242,15 @@ if (options.jest) {
   }
 }
 
-if (options.esbuild) {
+if (options.esbuild && !options.bundle) {
   assert(resolveImport)
   if (options.hasImportLoader) {
     args.push('--import', resolveImport('tsx'))
+  } else if (options.engine === process.env.EXODUS_TEST_ENGINE) {
+    console.warn(`Warning: ${options.engine} engine does not support --esbuild option`)
   } else {
-    args.push('-r', resolveImport('tsx/cjs'))
+    console.error(`Error: ${options.engine} engine does not support --esbuild option`)
+    process.exit(1)
   }
 }
 
@@ -326,18 +342,223 @@ if (options.coverage) {
   }
 }
 
-assert(files.length > 0) // otherwise we can run recursively
-assert(options.binary && ['node', 'bun', c8].includes(options.binary))
 process.env.EXODUS_TEST_EXECARGV = JSON.stringify(args)
+const inputs = files.map((file) => ({ source: file, file }))
+
+if (options.bundle) {
+  const esbuild = await import('esbuild')
+  const { readFile, writeFile } = await import('node:fs/promises')
+  const { rmSync } = await import('node:fs')
+  const os = await import('node:os')
+  const outdir = join(os.tmpdir(), `exodus-test-${randomUUID().slice(0, 8)}`)
+  process.on('beforeExit', async () => rmSync(outdir, { recursive: true, force: true }))
+  assert.deepEqual(args, [])
+  if (options.binary === 'node') args.unshift('--enable-source-maps') // FIXME
+
+  const readSnapshots = async (ifiles) => {
+    const snapshots = []
+    for (const file of ifiles) {
+      for (const resolver of [
+        (dir, name) => [dir, `${name}.snapshot`], // node:test
+        (dir, name) => [dir, '__snapshots__', `${name}.snap`], // jest
+      ]) {
+        const snapshotFile = join(...resolver(dirname(file), basename(file)))
+        try {
+          snapshots.push([snapshotFile, await readFile(snapshotFile, 'utf8')])
+        } catch (e) {
+          if (e.code !== 'ENOENT') throw e
+        }
+      }
+    }
+
+    return snapshots
+  }
+
+  const loadPipeline = [
+    function (source, args) {
+      return source
+        .replace(/\bimport\.meta\.url\b/g, JSON.stringify(pathToFileURL(args.path)))
+        .replace(/\bimport\.meta\.dirname\b/g, JSON.stringify(dirname(args.path)))
+        .replace(/\bimport\.meta\.filename\b/g, JSON.stringify(basename(args.path)))
+    },
+  ]
+
+  const writePipeline = []
+  if (options.binary === 'hermes') {
+    const babel = await import('@babel/core')
+    writePipeline.push((source) => {
+      const result = babel.transformSync(source, {
+        compact: false,
+        plugins: [
+          '@babel/plugin-transform-arrow-functions',
+          '@babel/plugin-transform-class-properties',
+          '@babel/plugin-transform-classes',
+          '@babel/plugin-transform-block-scoping',
+        ],
+      })
+      return result.code
+    })
+  }
+
+  const buildOne = async (...ifiles) => {
+    const input = []
+    const importSource = async (file) => input.push(await readFile(resolveRequire(file), 'utf8'))
+    const importFile = (...args) => input.push(`await import(${JSON.stringify(resolve(...args))});`)
+
+    if (!['node', c8].includes(options.binary)) await importSource('../src/bundle-apis/globals.cjs')
+
+    if (options.jest) {
+      assert(jestConfig.rootDir)
+      const preload = [...(jestConfig.setupFiles || []), ...(jestConfig.setupFilesAfterEnv || [])]
+      if (jestConfig.testEnvironment && jestConfig.testEnvironment !== 'node') {
+        const { specialEnvironments } = await import('../src/jest.environment.js')
+        assert(Object.hasOwn(specialEnvironments, jestConfig.testEnvironment))
+        preload.push(...(specialEnvironments[jestConfig.testEnvironment].dependencies || []))
+      }
+
+      const local = createRequire(resolve(jestConfig.rootDir, 'package.json'))
+      const w = (f) => `[${JSON.stringify(f)}, () => require(${JSON.stringify(local.resolve(f))})]`
+      input.push(`globalThis.EXODUS_TEST_PRELOADED = [${preload.map((f) => w(f)).join(', ')}]`)
+      await importSource('./jest.js')
+    }
+
+    for (const file of ifiles) importFile(file)
+    const filename =
+      ifiles.length === 1 ? `${ifiles[0]}-${randomUUID().slice(0, 8)}` : `bundle-${randomUUID()}`
+    const outfile = `${join(outdir, filename)}.js`
+    const EXODUS_TEST_SNAPSHOTS = await readSnapshots(ifiles)
+    const build = async (opts) => esbuild.build(opts).catch((err) => ({ errors: [err] }))
+    let main = input.join('\n')
+    if (['jsc', 'hermes'].includes(options.binary)) {
+      main = `try {\n${main}\n} catch (err) { print(err); throw err }` // TODO: fix reporting
+    }
+
+    const stringify = (x) => ([undefined, null].includes(x) ? `${x}` : JSON.stringify(x))
+    const res = await build({
+      stdin: {
+        contents: `(async function () {\n${main}\n})()`,
+        resolveDir: bindir,
+      },
+      bundle: true,
+      outdir,
+      entryNames: filename,
+      platform: 'neutral',
+      mainFields: ['browser', 'module', 'main'],
+      define: {
+        'process.env.FORCE_COLOR': stringify('0'),
+        'process.env.NO_COLOR': stringify('1'),
+        'process.env.NODE_ENV': stringify(process.env.NODE_ENV),
+        'process.env.EXODUS_TEST_CONTEXT': stringify('pure'),
+        'process.env.EXODUS_TEST_ENVIRONMENT': stringify('bundle'),
+        'process.env.EXODUS_TEST_PLATFORM': stringify(process.env.EXODUS_TEST_PLATFORM),
+        'process.env.EXODUS_TEST_JEST_CONFIG': stringify(JSON.stringify(jestConfig)),
+        'process.env.EXODUS_TEST_EXECARGV': stringify(process.env.EXODUS_TEST_EXECARGV),
+        'process.env.NODE_DEBUG': stringify(),
+        'process.env.READABLE_STREAM': stringify(),
+        'process.env.CI': stringify(process.env.CI),
+        'process.env.CI_ENABLE_VERBOSE_LOGS': stringify(process.env.CI_ENABLE_VERBOSE_LOGS),
+        'process.browser': stringify(true),
+        'process.emitWarning': 'undefined',
+        'process.stderr': 'undefined',
+        'process.stdout': 'undefined',
+        EXODUS_TEST_FILES: stringify(ifiles.map((f) => [dirname(f), basename(f)])),
+        EXODUS_TEST_SNAPSHOTS: stringify(EXODUS_TEST_SNAPSHOTS),
+      },
+      alias: {
+        // Node browserify
+        'node:assert': resolveRequire('assert'),
+        'node:assert/strict': resolveRequire('../src/bundle-apis/assert-strict.cjs'),
+        assert: resolveRequire('assert'),
+        buffer: resolveRequire('buffer'),
+        crypto: resolveRequire('crypto-browserify'),
+        events: resolveRequire('events'),
+        os: resolveRequire('os-browserify'),
+        path: resolveRequire('path-browserify'),
+        stream: resolveRequire('stream-browserify'),
+        util: resolveRequire('util'),
+        // expect-related deps
+        'ansi-styles': resolveRequire('../src/bundle-apis/ansi-styles.cjs'),
+        'jest-util': resolveRequire('../src/bundle-apis/jest-util.js'),
+        'jest-message-util': resolveRequire('../src/bundle-apis/jest-message-util.js'),
+      },
+      sourcemap: writePipeline.length > 0 ? 'inline' : 'linked',
+      sourcesContent: false,
+      keepNames: true,
+      format: 'iife',
+      target: options.target || `node${process.versions.node}`,
+      supported: {
+        bigint: true,
+      },
+      plugins: [
+        {
+          name: 'exodus-test.bundle',
+          setup({ onLoad }) {
+            onLoad({ filter: /\.m?js$/, namespace: 'file' }, async (args) => {
+              let contents = await readFile(args.path, 'utf8')
+              for (const transform of loadPipeline) contents = await transform(contents, args)
+              return { contents }
+            })
+          },
+        },
+      ],
+    })
+
+    if (writePipeline.length > 0 && res.errors.length === 0) {
+      let contents = await readFile(outfile, 'utf8')
+      for (const transform of writePipeline) contents = await transform(contents)
+      await writeFile(outfile, contents)
+    }
+
+    // require('fs').copyFileSync(outfile, 'tempout.cjs') // DEBUG
+    return { file: outfile, errors: res.errors, warnings: res.warnings }
+  }
+
+  for (const input of inputs) Object.assign(input, await buildOne(input.file)) // TODO: queued concurrency
+}
+
+assert.equal(inputs.length, files.length)
+assert(options.binary && ['node', 'bun', 'deno', 'jsc', 'hermes', c8].includes(options.binary))
 
 if (options.pure) {
+  if (options.binary === 'hermes') {
+    const dir = dirname(require.resolve('hermes-engine-cli/package.json'))
+    switch (process.platform) {
+      case 'darwin':
+        process.env.PATH = `${join(dir, 'osx-bin')}:${process.env.PATH}`
+        break
+      case 'linux':
+        process.env.PATH = `${join(dir, 'linux64-bin')}:${process.env.PATH}`
+        break
+      case 'win32':
+        process.env.PATH = `${join(dir, 'win64-bin')}:${process.env.PATH}`
+        break
+      default:
+        assert.fail(`Unexpected platform: ${process.platform}`)
+    }
+  } else if (options.binary === 'jsc' && process.platform === 'darwin') {
+    const prefix = '/System/Library/Frameworks/JavaScriptCore.framework/Versions/A'
+    for (const dir of [`${prefix}/Helpers`, `${prefix}/Resources`]) {
+      if (existsSync(join(dir, 'jsc'))) {
+        process.env.PATH = `${dir}:${process.env.PATH}`
+        break
+      }
+    }
+  }
+
   process.env.EXODUS_TEST_CONTEXT = 'pure'
   console.warn(`\n${options.engine} engine is experimental and may not work an expected\n\n`)
   const failures = []
-  for (const file of files) {
-    const node = spawn(options.binary, [...args, file], { stdio: 'inherit' })
+  for (const input of inputs) {
+    if (input.errors?.length > 0 || input.warnings?.length > 0) {
+      failures.push(input.source)
+      continue
+    }
+
+    const { binaryArgs = [] } = options
+    console.log(`# ${input.source}`)
+    const node = spawn(options.binary, [...binaryArgs, ...args, input.file], { stdio: 'inherit' })
     const [code] = await once(node, 'close')
-    if (code !== 0) failures.push(file)
+    if (code !== 0) failures.push(input.source)
   }
 
   if (failures.length > 0) {
@@ -350,9 +571,11 @@ if (options.pure) {
     console.log(`All ${files.length} test suites passed`)
   }
 } else {
-  assert(['node', c8].includes(options.binary), 'Native test engine is only supported with Node.js')
-  assert.equal(options.engine, 'node:test')
-  process.env.EXODUS_TEST_CONTEXT = 'node:test'
+  assert(['node', c8].includes(options.binary), `Unexpected native engine: ${options.binary}`)
+  assert(['node:test'].includes(options.engine))
+  process.env.EXODUS_TEST_CONTEXT = options.engine
+  assert(files.length > 0) // otherwise we can run recursively
+  assert(!options.binaryArgs)
   const node = spawn(options.binary, [...args, ...files], { stdio: 'inherit' })
   const [code] = await once(node, 'close')
   process.exitCode = code

package/bin/jest.js

@@ -1,5 +1,4 @@
-import { loadJestConfig, installJestEnvironment } from '../src/jest.config.js'
-
+const { loadJestConfig, installJestEnvironment } = await import('../src/jest.config.js')
 await loadJestConfig()
 const jestGlobals = await import('../src/jest.js')
 await installJestEnvironment(jestGlobals)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.26",
+  "version": "1.0.0-rc.28",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -37,6 +37,12 @@
   "files": [
     "bin/babel.cjs",
     "bin/jest.js",
+    "src/bundle-apis/ansi-styles.cjs",
+    "src/bundle-apis/assert-strict.cjs",
+    "src/bundle-apis/globals.cjs",
+    "src/bundle-apis/jest-message-util.js",
+    "src/bundle-apis/jest-util.js",
+    "src/bundle-apis/util-format.js",
     "src/dark.cjs",
     "src/engine.js",
     "src/engine.node.cjs",
@@ -58,8 +64,8 @@
   ],
   "scripts": {
     "test": "npm run test:jest",
-    "test:all": "npm run test:jest && npm run test:tape && npm run test:native",
-    "test:native": "EXODUS_TEST_IGNORE='{**/typescript/**,**/jest-repo/**/user.test.js}' ./bin/index.js --jest '__test__/**/*.test.js'",
+    "test:all": "npm run test:jest && npm run test:tape && npm run test:native && npm run test:pure",
+    "test:native": "EXODUS_TEST_IGNORE='{**/typescript/**,**/jest-repo/**/user.test.js}' ./bin/index.js --jest '__test__/**/*.test.{js,cjs,mjs}'",
     "test:jest": "./bin/index.js --jest --esbuild",
     "test:tape": "./bin/index.js --esbuild '__test__/tape/test/*.js' __test__/tape.test.js",
     "test:pure": "EXODUS_TEST_ENGINE=node:pure npm run test",
@@ -69,15 +75,28 @@
     "lint:fix": "prettier --write . && eslint --fix ."
   },
   "dependencies": {
+    "@babel/core": "^7.24.9",
+    "@babel/plugin-transform-arrow-functions": "^7.24.7",
+    "@babel/plugin-transform-block-scoping": "^7.24.7",
+    "@babel/plugin-transform-class-properties": "^7.24.7",
+    "@babel/plugin-transform-classes": "^7.24.8",
     "@babel/register": "^7.0.0",
+    "assert": "^2.1.0",
+    "buffer": "^6.0.3",
     "c8": "^9.1.0",
+    "crypto-browserify": "^3.12.0",
     "esbuild": "~0.21.5",
+    "events": "^3.3.0",
     "expect": "^29.7.0",
     "fast-glob": "^3.2.11",
     "jest-extended": "^4.0.2",
     "jsdom": "^24.1.0",
+    "os-browserify": "^0.3.0",
+    "path-browserify": "^1.0.1",
     "pretty-format": "^29.7.0",
-    "tsx": "^4.16.2"
+    "stream-browserify": "^3.0.0",
+    "tsx": "^4.16.2",
+    "util": "^0.12.5"
   },
   "devDependencies": {
     "@exodus/eslint-config": "^5.24.0",
@@ -91,5 +110,13 @@
     "jest-serializer-ansi-escapes": "^3.0.0",
     "jest-when": "^3.6.0"
   },
+  "peerDependencies": {
+    "hermes-engine-cli": "^0.12.0"
+  },
+  "peerDependenciesMeta": {
+    "hermes-engine-cli": {
+      "optional": true
+    }
+  },
   "packageManager": "pnpm@9.4.0+sha1.9217c800d4ab947a7aee520242a7b70d64fc7638"
 }

package/src/bundle-apis/ansi-styles.cjs

@@ -0,0 +1,49 @@
+const colors = [
+  'reset',
+  'bold',
+  'dim',
+  'italic',
+  'underline',
+  'overline',
+  'inverse',
+  'hidden',
+  'strikethrough',
+  'black',
+  'red',
+  'green',
+  'yellow',
+  'blue',
+  'magenta',
+  'cyan',
+  'white',
+  'blackBright',
+  'redBright',
+  'greenBright',
+  'yellowBright',
+  'blueBright',
+  'magentaBright',
+  'cyanBright',
+  'whiteBright',
+  'gray',
+  'grey',
+  'bgBlack',
+  'bgRed',
+  'bgGreen',
+  'bgYellow',
+  'bgBlue',
+  'bgMagenta',
+  'bgCyan',
+  'bgWhite',
+  'bgBlackBright',
+  'bgRedBright',
+  'bgGreenBright',
+  'bgYellowBright',
+  'bgBlueBright',
+  'bgMagentaBright',
+  'bgCyanBright',
+  'bgWhiteBright',
+  'bgGray',
+  'bgGrey',
+]
+
+for (const key of colors) exports[key] = { open: '', close: '' }

package/src/bundle-apis/assert-strict.cjs

@@ -0,0 +1 @@
+module.exports = require('node:assert').strict

package/src/bundle-apis/globals.cjs

@@ -0,0 +1,58 @@
+if (!globalThis.global) globalThis.global = globalThis
+if (!globalThis.Buffer) globalThis.Buffer = require('buffer').Buffer
+if (!globalThis.console) {
+  // eslint-disable-next-line no-undef
+  globalThis.console = { log: print, error: print, warn: print, info: print, debug: print }
+}
+
+if (!globalThis.fetch) {
+  globalThis.fetch = () => {
+    throw new Error('Fetch not supported')
+  }
+}
+
+if (!globalThis.WebSocket) {
+  globalThis.WebSocket = () => {
+    throw new Error('WebSocket not supported')
+  }
+}
+
+if (!Array.prototype.at) {
+  // eslint-disable-next-line no-extend-native
+  Array.prototype.at = function (i) {
+    return this[i < 0 ? this.length + i : i]
+  }
+}
+
+if (globalThis.describe) delete globalThis.describe
+
+if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
+  // Ok, we have broken timers, let's hack them around
+  let i = 0
+  const timers = new Map()
+  const { setTimeout, clearTimeout } = globalThis
+  const dateNow = Date.now
+  globalThis.setTimeout = (fn, time) => {
+    const id = `ht${i++}`
+    const now = dateNow()
+    const tick = () => {
+      if (!timers.has(id)) return
+      const remaining = now + time - dateNow()
+      if (remaining < 0) {
+        timers.delete(id)
+        fn()
+      } else {
+        timers.set(id, setTimeout(tick, remaining))
+      }
+    }
+
+    timers.set(id, setTimeout(tick, time))
+  }
+
+  globalThis.clearTimeout = (id) => {
+    if (!timers.has(id)) return
+    clearTimeout(timers.get(id))
+    timers.delete(id)
+  }
+  // TODO: setInterval, clearInterval
+}

package/src/bundle-apis/jest-message-util.js

@@ -0,0 +1,5 @@
+// Used in expect toThrowMatchers
+// TODO: figure out if a better impl is actually needed
+
+export const formatStackTrace = (stack) => stack
+export const separateMessageFromStack = (content) => ({ stack: content })

package/src/bundle-apis/jest-util.js

@@ -0,0 +1,22 @@
+// APIs used in expect()
+
+export { isPromise } from '../engine.js'
+
+var NUMS = [
+  'zero',
+  'one',
+  'two',
+  'three',
+  'four',
+  'five',
+  'six',
+  'seven',
+  'eight',
+  'nine',
+  'ten',
+  'eleven',
+  'twelve',
+  'thirteen',
+]
+
+export const pluralize = (word, count) => `${NUMS[count] || count} ${word}${count === 1 ? '' : 's'}`

package/src/dark.cjs

@@ -51,7 +51,7 @@ function createCallerLocationHook() {
   return { installLocationInNextTest, getCallerLocation }
 }
 
-// Easy on Node.js >= 22.3.0, but we polyfill for the rest
+// 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(' > ')
@@ -108,7 +108,7 @@ function getTestNamePath(t) {
 const execArgv = process.env.EXODUS_TEST_EXECARGV
   ? JSON.parse(process.env.EXODUS_TEST_EXECARGV)
   : process.execArgv
-const insideEsbuild = execArgv.some((x) => x.includes('node_modules/tsx/dist/'))
+const insideEsbuild = execArgv.some((x) => x.endsWith('node_modules/tsx/dist/loader.mjs'))
 
 function makeEsbuildMockable() {
   if (!insideEsbuild) return

package/src/engine.js

@@ -15,8 +15,8 @@ export { builtinModules, syncBuiltinESMExports }
 const { utilFormat, isPromise, nodeVersion } = engine
 export { utilFormat, isPromise, nodeVersion }
 
-const { baseFile, relativeRequire, isTopLevelESM } = engine
-export { baseFile, relativeRequire, isTopLevelESM }
+const { requireIsRelative, relativeRequire, isTopLevelESM } = engine
+export { requireIsRelative, relativeRequire, isTopLevelESM }
 
 const { readSnapshot, setSnapshotSerializers, setSnapshotResolver } = engine
 export { readSnapshot, setSnapshotSerializers, setSnapshotResolver }

package/src/engine.node.cjs

@@ -14,6 +14,7 @@ const nodeVersion = process.versions.node
 const files = process.argv.slice(1)
 const baseFile = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
 const relativeRequire = baseFile ? createRequire(baseFile) : require
+const requireIsRelative = Boolean(baseFile)
 const isTopLevelESM = () => !baseFile || !Object.hasOwn(relativeRequire.cache, baseFile) // assume ESM otherwise
 
 const snapshot = nodeTest.snapshot
@@ -33,7 +34,7 @@ module.exports = {
   ...{ mock, describe, test, beforeEach, afterEach, before, after },
   ...{ builtinModules, syncBuiltinESMExports },
   ...{ utilFormat, isPromise, nodeVersion },
-  ...{ baseFile, relativeRequire, isTopLevelESM },
+  ...{ requireIsRelative, relativeRequire, isTopLevelESM },
   ...{ readSnapshot, setSnapshotSerializers, setSnapshotResolver },
 }
 /* eslint-enable unicorn/no-useless-spread */

package/src/engine.pure.cjs

@@ -1,9 +1,5 @@
 const assert = require('node:assert/strict')
 const assertLoose = require('node:assert')
-const { existsSync, readFileSync } = require('node:fs')
-const { normalize, basename, dirname, join: pathJoin } = require('node:path')
-const { format: utilFormat } = require('node:util')
-const { createRequire, builtinModules, syncBuiltinESMExports } = require('node:module')
 
 const { setTimeout, setInterval, setImmediate, Date } = globalThis
 const { clearTimeout, clearInterval, clearImmediate } = globalThis
@@ -57,6 +53,14 @@ async function runFunction(fn, context) {
   return new Promise((resolve, reject) => fn(context, (err) => (err ? reject(err) : resolve())))
 }
 
+let fallbackExitCode = 0
+const failExitCode = (...args) => {
+  console.log(...args)
+  if (globalThis.process) return (globalThis.process.exitCode = 1)
+  if (globalThis.Deno) return (globalThis.Deno.exitCode = 1)
+  return (fallbackExitCode = 1)
+}
+
 async function runContext(context) {
   const { options, children, hooks, fn } = context
   assert(!context.running, 'Can not run twice')
@@ -81,10 +85,7 @@ async function runContext(context) {
     for (const c of stack) for (const hook of c.hooks.afterEach) await runFunction(hook, context)
 
     console.log(error === undefined ? '✔ PASS' : '✖ FAIL', context.fullName)
-    if (error) {
-      console.log(' ', error)
-      if (globalThis.process) globalThis.process.exitCode = 1
-    }
+    if (error) failExitCode(' ', error)
   } else {
     // if (context !== context.root) console.log(`▶ ${context.fullName}`)
     // TODO: try/catch for hooks?
@@ -100,11 +101,15 @@ async function run() {
   assert(!running)
   running = true
   assert(context === context.root)
-  runContext(context).catch((error) => {
+  await runContext(context).catch((error) => {
     // Should not throw under regular circumstances
-    console.log('Fatal: ', error)
-    if (globalThis.process) globalThis.process.exitCode = 1
+    failExitCode('Fatal: ', error)
   })
+  if (fallbackExitCode !== 0) {
+    setTimeout(() => {
+      throw new Error('Test failed')
+    }, 0)
+  }
 }
 
 function describe(...args) {
@@ -152,7 +157,19 @@ class MockTimers {
     }
 
     if (apis.includes('setImmediate')) {
-      globalThis.setImmediate = this.#setImmediate.bind(this)
+      if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
+        // Sigh, these are used internally
+        const isInternal = (x) =>
+          x.includes('at handleResolved ') || x.includes('/InternalBytecode/InternalBytecode')
+        globalThis.setImmediate = (...args) => {
+          const { stack } = new Error() // eslint-disable-line unicorn/error-message
+          if (isInternal(stack.split('\n')[2])) return setImmediate(...args)
+          return this.#setImmediate(...args)
+        }
+      } else {
+        globalThis.setImmediate = this.#setImmediate.bind(this)
+      }
+
       globalThis.clearImmediate = this.#clearImmediate.bind(this)
     }
 
@@ -306,17 +323,40 @@ const after = (fn) => context.hooks.after.push(fn)
 const isPromise = (x) => Boolean(x && x.then && x.catch && x.finally)
 const nodeVersion = '9999.99.99'
 
-const files = process.argv.slice(1)
-const baseFile = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
-const relativeRequire = baseFile ? createRequire(baseFile) : require
-const isTopLevelESM = () =>
-  !baseFile || // assume ESM otherwise
-  !Object.hasOwn(relativeRequire.cache, baseFile) || // node esm
-  relativeRequire.cache[baseFile].exports[Symbol.toStringTag] === 'Module' // bun esm
+let builtinModules = []
+let requireIsRelative = false
+let relativeRequire, isTopLevelESM, syncBuiltinESMExports, readSnapshot, utilFormat
+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
+  isTopLevelESM = () => false
+  // 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)
+  utilFormat = require('./bundle-apis/util-format.cjs')
+} else {
+  const { existsSync, readFileSync } = require('node:fs')
+  const { dirname, basename, normalize, join } = require('node:path')
+  const nodeModule = require('node:module')
+  const files = process.argv.slice(1)
+  const baseFile = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
+  requireIsRelative = Boolean(baseFile)
+  relativeRequire = baseFile ? nodeModule.createRequire(baseFile) : require
+  isTopLevelESM = () =>
+    !baseFile || // assume ESM otherwise
+    !Object.hasOwn(relativeRequire.cache, baseFile) || // node esm
+    relativeRequire.cache[baseFile].exports[Symbol.toStringTag] === 'Module' // bun esm
+  const resolveSnapshot = (f) => join(...snapshotResolver(dirname(f), basename(f)))
+  readSnapshot = (f = baseFile) => (f ? readFileSync(resolveSnapshot(f), 'utf8') : null)
+  builtinModules = nodeModule.builtinModules
+  syncBuiltinESMExports = nodeModule.syncBuiltinESMExports || nodeModule.syncBuiltinExports // bun has it under a different name (also a no-op and always synced atm)
+  utilFormat = require('node:util').format
+}
 
+// eslint-disable-next-line no-undef
 let snapshotResolver = (dir, name) => [dir, `${name}.snapshot`] // default per Node.js docs
-const resolveSnapshot = (f) => pathJoin(...snapshotResolver(dirname(f), basename(f)))
-const readSnapshot = (f = baseFile) => (f ? readFileSync(resolveSnapshot(f), 'utf8') : null)
 const setSnapshotSerializers = () => {}
 const setSnapshotResolver = (fn) => {
   snapshotResolver = fn
@@ -331,7 +371,7 @@ module.exports = {
   ...{ mock, describe, test, beforeEach, afterEach, before, after },
   ...{ builtinModules, syncBuiltinESMExports },
   ...{ utilFormat, isPromise, nodeVersion },
-  ...{ baseFile, relativeRequire, isTopLevelESM },
+  ...{ requireIsRelative, relativeRequire, isTopLevelESM },
   ...{ readSnapshot, setSnapshotSerializers, setSnapshotResolver },
 }
 /* eslint-enable unicorn/no-useless-spread */

package/src/jest.config.js

@@ -1,7 +1,5 @@
 // Not using ./engine.js yet, might pass / embed already loaded config instead
 import assert from 'node:assert/strict'
-import path from 'node:path'
-import { createRequire } from 'node:module'
 import { specialEnvironments } from './jest.environment.js'
 
 const normalizeJestConfig = (config) => ({
@@ -75,6 +73,12 @@ export async function loadJestConfig(...args) {
 
   config = normalizeJestConfig(rawConfig)
   verifyJestConfig(config)
+
+  // require is already relative to rootDir
+  const cleanFile = (file) => file.replace(/^<rootDir>\//g, './')
+  config.setupFiles = config.setupFiles?.map((f) => cleanFile(f))
+  config.setupFilesAfterEnv = config.setupFilesAfterEnv?.map((f) => cleanFile(f))
+
   return config
 }
 
@@ -95,17 +99,29 @@ export async function installJestEnvironment(jestGlobals) {
   if (c.restoreMocks) beforeEach(() => jest.restoreAllMocks())
   if (c.resetModules) beforeEach(() => jest.resetModules())
 
-  const require = config.rootDir
-    ? createRequire(path.resolve(config.rootDir, 'package.json'))
-    : () => assert.fail('Unreachable: requiring plugins without a rootDir')
+  let require
+  if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
+    const preloaded = new Map(EXODUS_TEST_PRELOADED) // eslint-disable-line no-undef
+    require = (name) => {
+      if (preloaded.has(name)) return preloaded.get(name)()
+      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')
+    require = createRequire(resolve(config.rootDir, 'package.json'))
+  } else {
+    require = () => assert.fail('Unreachable: requiring plugins without a rootDir')
+  }
+
+  for (const file of c.setupFiles || []) require(file)
 
   if (Object.hasOwn(specialEnvironments, c.testEnvironment)) {
-    specialEnvironments[c.testEnvironment](require, engine, jestGlobals, c.testEnvironmentOptions)
+    const { setup } = specialEnvironments[c.testEnvironment]
+    await setup(require, engine, jestGlobals, c.testEnvironmentOptions)
   }
 
-  // require is already relative to rootDir
-  for (const file of c.setupFiles || []) require(file.replace(/^<rootDir>\//g, './'))
-  for (const file of c.setupFilesAfterEnv || []) require(file.replace(/^<rootDir>\//g, './'))
+  for (const file of c.setupFilesAfterEnv || []) require(file)
 
   // @jest/globals import auto-mocking is disabled until https://github.com/nodejs/node/issues/53807 is resolved
   /*

package/src/jest.environment.js

@@ -1,64 +1,72 @@
-import { getTestNamePath } from './dark.cjs'
-
 export const specialEnvironments = {
   __proto__: null,
 
-  jsdom: (require) => {
-    const { JSDOM, VirtualConsole } = require('jsdom')
-    const virtualConsole = new VirtualConsole()
-    const { window } = new JSDOM('<!DOCTYPE html>', {
-      url: 'http://localhost/',
-      pretendToBeVisual: true,
-      runScripts: 'dangerously',
-      virtualConsole,
-    })
-    virtualConsole.sendTo(console, { omitJSDOMErrors: true })
-    virtualConsole.on('jsdomError', (error) => {
-      throw error
-    })
-    const assignMissing = (target, source) => {
-      const entries = Object.entries(source).filter(([key]) => !Object.hasOwn(target, key))
-      Object.assign(target, Object.fromEntries(entries))
-    }
+  jsdom: {
+    dependencies: ['jsdom'],
+    setup: (require) => {
+      const { JSDOM, VirtualConsole } = require('jsdom')
+      const virtualConsole = new VirtualConsole()
+      const { window } = new JSDOM('<!DOCTYPE html>', {
+        url: 'http://localhost/',
+        pretendToBeVisual: true,
+        runScripts: 'dangerously',
+        virtualConsole,
+      })
+      virtualConsole.sendTo(console, { omitJSDOMErrors: true })
+      virtualConsole.on('jsdomError', (error) => {
+        throw error
+      })
+      const assignMissing = (target, source) => {
+        const entries = Object.entries(source).filter(([key]) => !Object.hasOwn(target, key))
+        Object.assign(target, Object.fromEntries(entries))
+      }
 
-    assignMissing(globalThis, window)
-    assignMissing(console, window.console)
-    Object.setPrototypeOf(global, Object.getPrototypeOf(window))
+      assignMissing(globalThis, window)
+      assignMissing(console, window.console)
+      Object.setPrototypeOf(global, Object.getPrototypeOf(window))
+    },
   },
 
   // Reproduces setup-polly-jest/jest-environment-node ad hacks into 'setup-polly-jest'.pollyJest
-  'setup-polly-jest/jest-environment-node': (require, engine) => {
-    const { Polly } = require('@pollyjs/core')
-    const pollyJest = require('setup-polly-jest')
-    const { JestPollyGlobals, createPollyContextAccessor } = require('setup-polly-jest/lib/common')
-    const pollyGlobals = new JestPollyGlobals(globalThis)
-    pollyGlobals.isJestPollyEnvironment = true
-    pollyJest.setupPolly = (options) => {
-      if (!pollyGlobals.isJestPollyEnvironment) return
+  'setup-polly-jest/jest-environment-node': {
+    dependencies: ['@pollyjs/core', 'setup-polly-jest', 'setup-polly-jest/lib/common'],
+    setup: async (require, engine) => {
+      const { getTestNamePath } = await import('./dark.cjs')
+      const { Polly } = require('@pollyjs/core')
+      const pollyJest = require('setup-polly-jest')
+      const {
+        JestPollyGlobals,
+        createPollyContextAccessor,
+      } = require('setup-polly-jest/lib/common')
+      const pollyGlobals = new JestPollyGlobals(globalThis)
+      pollyGlobals.isJestPollyEnvironment = true
+      pollyJest.setupPolly = (options) => {
+        if (!pollyGlobals.isJestPollyEnvironment) return
 
-      engine.before(() => {
-        pollyGlobals.isPollyActive = true
-        pollyGlobals.pollyContext.options = options
-      })
+        engine.before(() => {
+          pollyGlobals.isPollyActive = true
+          pollyGlobals.pollyContext.options = options
+        })
 
-      engine.after(() => {
-        pollyGlobals.isPollyActive = false
-        pollyGlobals.pollyContext.options = null
-      })
+        engine.after(() => {
+          pollyGlobals.isPollyActive = false
+          pollyGlobals.pollyContext.options = null
+        })
 
-      return createPollyContextAccessor(pollyGlobals)
-    }
+        return createPollyContextAccessor(pollyGlobals)
+      }
 
-    engine.beforeEach((t) => {
-      if (!pollyGlobals.isPollyActive) return
-      const name = getTestNamePath(t).join('/')
-      pollyGlobals.pollyContext.polly = new Polly(name, pollyGlobals.pollyContext.options)
-    })
+      engine.beforeEach((t) => {
+        if (!pollyGlobals.isPollyActive) return
+        const name = getTestNamePath(t).join('/')
+        pollyGlobals.pollyContext.polly = new Polly(name, pollyGlobals.pollyContext.options)
+      })
 
-    engine.afterEach(async () => {
-      if (!pollyGlobals.pollyContext.polly) return
-      await pollyGlobals.pollyContext.polly.stop()
-      pollyGlobals.pollyContext.polly = null
-    })
+      engine.afterEach(async () => {
+        if (!pollyGlobals.pollyContext.polly) return
+        await pollyGlobals.pollyContext.polly.stop()
+        pollyGlobals.pollyContext.polly = null
+      })
+    },
   },
 }

package/src/jest.js

@@ -81,7 +81,10 @@ const makeEach =
     }
   }
 
-const forceExit = process.execArgv.map((x) => x.replaceAll('_', '-')).includes('--test-force-exit')
+const execArgv = process.env.EXODUS_TEST_EXECARGV
+  ? JSON.parse(process.env.EXODUS_TEST_EXECARGV)
+  : process.execArgv
+const forceExit = execArgv.map((x) => x.replaceAll('_', '-')).includes('--test-force-exit')
 
 const inConcurrent = []
 const inDescribe = []
@@ -149,26 +152,29 @@ node.afterEach(() => {
   for (const { error } of expect.extractExpectedAssertionsErrors()) throw error
 })
 
-node.after(() => {
-  jestTimers.useRealTimers()
-  const prefix = `Tests completed, but still have asynchronous activity after`
+if (globalThis.process) {
+  node.after(() => {
+    jestTimers.useRealTimers()
+    const prefix = `Tests completed, but still have asynchronous activity after`
 
-  // give everything additional (configurable) defaultTimeout time to finish, otherwide fail
-  const timeout = defaultTimeout
-  setTimeout(() => {
-    console.error(`${prefix} additional ${timeout}ms. Terminating with a failure...`)
-    process.exit(1)
-  }, timeout).unref()
-
-  // Warn after 5s that something is going on
-  const warnTimeout = 5000
-  if (warnTimeout < timeout + 1000) {
+    // give everything additional (configurable) defaultTimeout time to finish, otherwide fail
+    const timeout = defaultTimeout
     setTimeout(() => {
-      console.warn(`${prefix} ${warnTimeout}ms. Waiting for ${timeout}ms to pass to finish...`)
-    }, warnTimeout).unref()
-  }
-})
+      console.error(`${prefix} additional ${timeout}ms. Terminating with a failure...`)
+      process.exit(1)
+    }, timeout).unref()
+
+    // Warn after 5s that something is going on
+    const warnTimeout = 5000
+    if (warnTimeout < timeout + 1000) {
+      setTimeout(() => {
+        console.warn(`${prefix} ${warnTimeout}ms. Waiting for ${timeout}ms to pass to finish...`)
+      }, warnTimeout).unref()
+    }
+  })
+}
 
+const isBundle = process.env.EXODUS_TEST_ENVIRONMENT === 'bundle' // TODO: improve mocking from bundle
 export const jest = {
   exodus: {
     __proto__: null,
@@ -177,9 +183,9 @@ export const jest = {
       platform: String(process.env.EXODUS_TEST_PLATFORM),
       engine: String(node.engine),
       timers: Boolean(mock.timers && haveValidTimers),
-      esmMocks: Boolean(mock.module), // full support for ESM mocks
-      esmClone: Boolean(insideEsbuild), // support for ESM mocks creation without a mocker function
-      esmNamedBuiltinMocks: Boolean(mock.module || insideEsbuild), // support for named ESM imports from builtin module mocks
+      esmMocks: Boolean(mock.module && !isBundle), // full 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
       concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
     },
   },

package/src/jest.mock.js

@@ -1,7 +1,7 @@
 import {
   mock,
   assert,
-  baseFile,
+  requireIsRelative,
   relativeRequire as require,
   isTopLevelESM,
   builtinModules,
@@ -34,7 +34,7 @@ export const jestModuleMocks = {
 }
 
 export function resolveModule(name) {
-  assert(baseFile || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
+  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
   return require.resolve(name)
@@ -58,6 +58,7 @@ export function resetModules() {
     if (mock.module) ctx.restore()
   }
 
+  assert(process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle', 'resetModules() unsupported from bundle')
   for (const resolved of Object.keys(require.cache)) {
     delete require.cache[resolved]
     mapMocks.delete(resolved)
@@ -132,7 +133,9 @@ function mockCloneItem(obj, cache) {
     // Special path, as .default might be a getter and we want to unwrap it
     if (obj.__esModule === true) {
       const { __esModule, default: def, ...rest } = obj
-      return { __esModule, ...mockClone({ default: def, ...rest }, cache) }
+      const proto = Object.getPrototypeOf(obj)
+      const toClone = proto?.[Symbol.toStringTag] === 'Module' ? proto : { default: def, ...rest } // unwrap bun modules for proper cloning
+      return { __esModule, ...mockClone(toClone, cache) }
     }
 
     const prototype = Object.getPrototypeOf(obj)
@@ -170,6 +173,8 @@ function mockCloneItem(obj, cache) {
 }
 
 export function jestmock(name, mocker, { override = false } = {}) {
+  assert(process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle', 'module mocks unsupported from bundle') // TODO: can we do something?
+
   // Loaded ESM: isn't mocked
   // Loaded CJS: mocked via object overriding
   // Loaded built-ins: mocked via object overriding where possible