@exodus/test 1.0.0-rc.32 → 1.0.0-rc.34

package/README.md

@@ -37,7 +37,7 @@ Or, run with [`--jest` option](#options) to register jest globals
 ### Moving from tap/tape
 
 ```js
-import test from '@exodus/test/tap'
+import test from '@exodus/test/tape'
 ```
 
 ### Running tests asynchronously

package/bin/babel-worker.cjs

@@ -0,0 +1,50 @@
+const { Worker, MessageChannel, isMainThread, parentPort } = require('node:worker_threads')
+const { once } = require('node:events')
+const { availableParallelism } = require('node:os')
+
+if (isMainThread) {
+  const maxWorkers = availableParallelism() >= 4 ? 2 : 1
+  const workers = []
+
+  const getWorker = () => {
+    const idle = workers.find((info) => info.busy === 0)
+    if (idle) return idle
+
+    if (workers.length < maxWorkers) {
+      const worker = new Worker(__filename)
+      worker.unref()
+      // unhandled top-level errors will crash automatically, which is desired behavior, no need to listen to error
+      workers.unshift({ worker, busy: 0 })
+    } else if (workers.length > 1) {
+      workers.sort((a, b) => a.busy - b.busy)
+    }
+
+    return workers[0]
+  }
+
+  const transformAsync = async (code, options) => {
+    const info = getWorker()
+    info.busy++
+    const channel = new MessageChannel()
+    info.worker.postMessage({ port: channel.port1, code, options }, [channel.port1])
+    const [{ result, error }] = await once(channel.port2, 'message')
+    info.busy--
+    if (error) throw error
+    return result
+  }
+
+  module.exports = { transformAsync }
+} else {
+  const babel = require('@babel/core')
+  parentPort.on('message', ({ port, code: input, options }) => {
+    try {
+      const { code, sourcetype, map } = babel.transformSync(input, options) // async here is useless and slower
+      // additional properties are deleted as we don't want to transfer e.g. Plugin instances
+      port.postMessage({ result: { code, sourcetype, map } })
+    } catch (error) {
+      port.postMessage({ error })
+    }
+
+    port.close()
+  })
+}

package/bin/bundle.js

@@ -0,0 +1,285 @@
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { basename, dirname, resolve, join } from 'node:path'
+import { createRequire } from 'node:module'
+import { randomUUID as uuid, randomBytes } from 'node:crypto'
+import * as esbuild from 'esbuild'
+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 readSnapshots = async (files) => {
+  const snapshots = []
+  for (const file of files) {
+    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
+}
+
+// These packages throw on import
+const blockedDeps = ['@pollyjs/adapter-node-http', '@pollyjs/node-server']
+const loadPipeline = [
+  function (source, filepath) {
+    return 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))
+  },
+  function (source, filepath) {
+    // Just a convenience wrapper to show pretty errors instead of generic bundle-apis/empty/module-throw.cjs
+    for (const pkg of blockedDeps) {
+      const str = `require(${JSON.stringify(pkg)})`
+      assert(!str.includes("'"))
+      const err = `module unsupported in bundled form: ${pkg}\n       loaded from ${filepath}`
+      const rep = `((() => { throw new Error(${JSON.stringify(err)}) })())`
+      for (const sub of [str, str.replaceAll('"', "'")]) source = source.replace(sub, rep)
+    }
+
+    return source
+  },
+]
+
+const options = {}
+
+export const init = async ({ platform, jest, target, jestConfig, outdir }) => {
+  Object.assign(options, { platform, jest, target, jestConfig, outdir })
+  if (options.platform === 'hermes') {
+    const babel = await import('./babel-worker.cjs')
+    loadPipeline.push(async (source) => {
+      const result = await babel.transformAsync(source, {
+        compact: false,
+        babelrc: false,
+        configFile: false,
+        plugins: [
+          '@babel/plugin-syntax-typescript',
+          '@babel/plugin-transform-block-scoping',
+          '@babel/plugin-transform-class-properties',
+          '@babel/plugin-transform-classes',
+          '@babel/plugin-transform-private-methods',
+        ],
+      })
+      return result.code
+    })
+  }
+}
+
+const hermesSupported = {
+  arrow: false,
+  class: false, // we get a safeguard check this way that it's not used
+  'async-generator': false,
+  'const-and-let': false, // have to explicitly set for esbuild to not emit that in helpers, also to get a safeguard check
+  'for-await': false,
+}
+
+const getPackageFiles = async (dir) => {
+  // Returns an empty list on errors
+  let patterns
+  try {
+    patterns = JSON.parse(await readFile(resolve(dir, 'package.json'), 'utf8')).files
+  } catch {}
+
+  if (!patterns) {
+    const parent = dirname(dir)
+    if (parent !== dir) return getPackageFiles(parent)
+    return []
+  }
+
+  // Hack for now, TODO: fix this
+  const expanded = patterns.flatMap((x) => (x.includes('.') ? [x] : [x, `${x}/**/*`]))
+  return glob(expanded, { ignore: ['**/node_modules'], cwd: dir, absolute: true })
+}
+
+const loadCache = new Map()
+const loadSourceFile = async (filepath) => {
+  if (!loadCache.has(filepath)) {
+    const load = async () => {
+      let contents = await readFile(filepath, 'utf8')
+      for (const transform of loadPipeline) contents = await transform(contents, filepath)
+      return contents
+    }
+
+    loadCache.set(filepath, load())
+  }
+
+  return loadCache.get(filepath)
+}
+
+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'].includes(options.platform)) {
+    if (['jsc', 'hermes'].includes(options.platform)) {
+      const entropy = randomBytes(5 * 1024).toString('base64')
+      input.push(`globalThis.EXODUS_TEST_CRYPTO_ENTROPY = ${stringify(entropy)};`)
+    }
+
+    await importSource('../src/bundle-apis/globals.cjs')
+  }
+
+  if (options.jest) {
+    const { jestConfig } = options
+    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) => `[${stringify(f)}, () => require(${stringify(local.resolve(f))})]`
+    input.push(`globalThis.EXODUS_TEST_PRELOADED = [${preload.map((f) => w(f)).join(', ')}]`)
+    await importSource('./jest.js')
+  }
+
+  for (const file of files) importFile(file)
+
+  const filename = files.length === 1 ? `${files[0]}-${uuid().slice(0, 8)}` : `bundle-${uuid()}`
+  const outfile = `${join(options.outdir, filename)}.js`
+  const EXODUS_TEST_SNAPSHOTS = await readSnapshots(files)
+  const buildWrap = async (opts) => esbuild.build(opts).catch((err) => err)
+  let main = input.join(';\n')
+  if (['jsc', 'hermes'].includes(options.platform)) {
+    const exit = `EXODUS_TEST_PROCESS.exitCode = 1; EXODUS_TEST_PROCESS._maybeProcessExitCode();`
+    main = `try {\n${main}\n} catch (err) { print(err); ${exit} }`
+  }
+
+  const fsfiles = await getPackageFiles(filename ? dirname(resolve(filename)) : process.cwd())
+
+  const hasBuffer = ['node', 'bun'].includes(options.platform)
+  const api = (f) => resolveRequire(join('../src/bundle-apis', f))
+  const res = await buildWrap({
+    logLevel: 'silent',
+    stdin: {
+      contents: `(async function () {\n${main}\n})()`,
+      resolveDir: dirname(fileURLToPath(import.meta.url)),
+    },
+    bundle: true,
+    outdir: options.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(options.jestConfig)),
+      'process.env.EXODUS_TEST_EXECARGV': stringify(process.env.EXODUS_TEST_EXECARGV),
+      'process.env.NODE_DEBUG': stringify(),
+      'process.env.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',
+      'process.type': '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_FILES: stringify(files.map((f) => [dirname(f), basename(f)])),
+      EXODUS_TEST_SNAPSHOTS: stringify(EXODUS_TEST_SNAPSHOTS),
+      EXODUS_TEST_FSFILES: stringify(fsfiles), // TODO: can we safely use relative paths?
+    },
+    alias: {
+      // Jest and tape
+      '@jest/globals': resolveImport('../src/jest.js'),
+      tape: resolveImport('../src/tape.cjs'),
+      'tape-promise/tape': resolveImport('../src/tape.cjs'),
+      // Node browserify
+      'node:assert': dirname(dirname(resolveRequire('assert/'))),
+      'node:assert/strict': api('assert-strict.cjs'),
+      'node:fs': api('fs.cjs'),
+      'node:fs/promises': api('fs-promises.cjs'),
+      fs: api('fs.cjs'),
+      'fs/promises': api('fs-promises.cjs'),
+      assert: dirname(dirname(resolveRequire('assert/'))),
+      buffer: hasBuffer ? api('node-buffer.cjs') : dirname(resolveRequire('buffer/')),
+      child_process: api('child_process.cjs'),
+      constants: resolveRequire('constants-browserify'),
+      crypto: api('crypto.cjs'),
+      events: dirname(resolveRequire('events/')),
+      http: api('http.cjs'),
+      https: api('https.cjs'),
+      os: resolveRequire('os-browserify'),
+      path: resolveRequire('path-browserify'),
+      querystring: resolveRequire('querystring-es3'),
+      stream: resolveRequire('stream-browserify'),
+      timers: resolveRequire('timers-browserify'),
+      url: dirname(resolveRequire('url/')),
+      util: dirname(resolveRequire('util/')),
+      zlib: resolveRequire('browserify-zlib'),
+      // expect-related deps
+      'ansi-styles': api('ansi-styles.cjs'),
+      'jest-util': api('jest-util.js'),
+      'jest-message-util': api('jest-message-util.js'),
+      // unwanted deps
+      bindings: api('empty/function-throw.cjs'),
+      'node-gyp-build': api('empty/function-throw.cjs'),
+      ws: api('ws.cjs'),
+      // unsupported deps
+      ...Object.fromEntries(blockedDeps.map((n) => [n, api('empty/module-throw.cjs')])),
+    },
+    sourcemap: ['hermes', 'jsc'].includes(options.platform) ? 'inline' : 'linked', // FIXME?
+    sourcesContent: false,
+    keepNames: true,
+    format: 'iife',
+    target: options.target || `node${process.versions.node}`,
+    supported: {
+      bigint: true,
+      ...(options.platform === 'hermes' ? hermesSupported : {}),
+    },
+    plugins: [
+      {
+        name: 'exodus-test.bundle',
+        setup({ onLoad }) {
+          onLoad({ filter: /\.[cm]?[jt]s$/, namespace: 'file' }, async (args) => {
+            let filepath = args.path
+            // Resolve .native versions
+            // TODO: move flag to engine options
+            // TODO: maybe follow package.json for this
+            if (['jsc', 'hermes'].includes(options.platform)) {
+              const maybeNative = filepath.replace(/(\.[cm]?[jt]s)$/u, '.native$1')
+              if (existsSync(maybeNative)) filepath = maybeNative
+            }
+
+            const loader = /\.[cm]?ts$/.test(filepath) ? 'ts' : 'js'
+            return { contents: await loadSourceFile(filepath), loader }
+          })
+        },
+      },
+    ],
+  })
+  assert.equal(res instanceof Error, res.errors.length > 0)
+
+  // if (res.errors.length === 0) require('fs').copyFileSync(outfile, 'tempout.cjs') // DEBUG
+
+  // We treat warnings as errors, so just merge all them
+  const errors = []
+  const formatOpts = { color: process.stdout.hasColors?.(), terminalWidth: process.stdout.columns }
+  const formatMessages = (list, kind) => esbuild.formatMessages(list, { kind, ...formatOpts })
+  if (res.warnings.length > 0) errors.push(...(await formatMessages(res.warnings, 'warning')))
+  if (res.errors.length > 0) errors.push(...(await formatMessages(res.errors, 'error')))
+  return { file: outfile, errors }
+}

package/bin/index.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 
-import { spawn } from 'node:child_process'
+import { spawn, execFile as execFileCallback } from 'node:child_process'
+import { promisify, inspect } from 'node:util'
 import { once } from 'node:events'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { fileURLToPath } from 'node:url'
 import { basename, dirname, resolve, join } from 'node:path'
 import { createRequire } from 'node:module'
-import { randomUUID, randomBytes } from 'node:crypto'
-import { existsSync } from 'node:fs'
+import { randomUUID } from 'node:crypto'
+import { existsSync, rmSync } from 'node:fs'
+import { unlink } from 'node:fs/promises'
+import { tmpdir, availableParallelism } from 'node:os'
 import assert from 'node:assert/strict'
+import { Queue } from '@chalker/queue'
 import glob from 'fast-glob'
 import { haveModuleMocks, haveSnapshots, haveForceExit } from '../src/version.js'
 
@@ -25,7 +29,7 @@ const ENGINES = new Map(
     'bun:pure': { binary: 'bun', pure: true, hasImportLoader: false, ts: 'auto' },
     'bun:bundle': { binary: 'bun', ...bundleOptions },
     'deno:bundle': { binary: 'deno', binaryArgs: ['run'], target: 'deno1', ...bundleOptions },
-    'jsc:bundle': { binary: 'jsc', ...bundleOptions, target: 'safari11' },
+    'jsc:bundle': { binary: 'jsc', ...bundleOptions, target: 'safari13' },
     'hermes:bundle': { binary: 'hermes', binaryArgs: ['-Og'], target: 'es2018', ...bundleOptions },
   })
 )
@@ -147,6 +151,7 @@ const { options, patterns } = parseOptions()
 const engineOptions = ENGINES.get(options.engine)
 assert(engineOptions, `Unknown engine: ${options.engine}`)
 Object.assign(options, engineOptions)
+options.platform = options.binary // binary can be overriden by c8
 
 const require = createRequire(import.meta.url)
 const resolveRequire = (query) => require.resolve(query)
@@ -348,258 +353,27 @@ if (options.coverage) {
     args.unshift(options.binary)
     options.binary = c8
     // perhaps use text-summary ?
-    args.unshift('-r', 'text', '-r', 'html')
+    args.unshift('-r', 'text', '-r', 'html', '-r', 'lcov', '-r', 'json-summary')
   } else {
     throw new Error(`Unknown coverage engine: ${JSON.stringify(options.coverageEngine)}`)
   }
 }
 
 process.env.EXODUS_TEST_EXECARGV = JSON.stringify(args)
-const inputs = files.map((file) => ({ source: file, file }))
+let buildFile
 
 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 }))
+  const outdir = join(tmpdir(), `exodus-test-${randomUUID().slice(0, 8)}`)
+  process.on('exit', () => 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
-  }
-
-  // These packages throw on import
-  const blockedDeps = ['@pollyjs/adapter-node-http', '@pollyjs/node-server']
-  const loadPipeline = [
-    function (source, args) {
-      return source
-        .replace(/\bimport\.meta\.url\b/g, JSON.stringify(pathToFileURL(args.path)))
-        .replace(/\b(__dirname|import\.meta\.dirname)\b/g, JSON.stringify(dirname(args.path)))
-        .replace(/\b(__filename|import\.meta\.filename)\b/g, JSON.stringify(args.path))
-    },
-    function (source, args) {
-      // Just a convenience wrapper to show pretty errors instead of generic bundle-apis/empty/module-throw.cjs
-      for (const pkg of blockedDeps) {
-        const str = `require(${JSON.stringify(pkg)})`
-        assert(!str.includes("'"))
-        const err = `module unsupported in bundled form: ${pkg}\n       loaded from ${args.path}`
-        const rep = `((() => { throw new Error(${JSON.stringify(err)}) })())`
-        for (const sub of [str, str.replaceAll('"', "'")]) source = source.replace(sub, rep)
-      }
-
-      return source
-    },
-  ]
-
-  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-async-generator-functions',
-          '@babel/plugin-transform-class-properties',
-          '@babel/plugin-transform-classes',
-          '@babel/plugin-transform-block-scoping',
-        ],
-      })
-      return result.code
-    })
-  }
-
-  const getPackageFiles = async () => {
-    // Returns an empty list on errors
-    let patterns
-    try {
-      patterns = JSON.parse(await readFile('package.json', 'utf8')).files
-    } catch {}
-
-    if (!patterns) return []
-    // Hack for now, TODO: fix this
-    const expanded = patterns.flatMap((x) => (x.includes('.') ? [x] : [x, `${x}/**/*`]))
-    return glob(expanded, { ignore: ['**/node_modules'] })
-  }
-
-  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))});`)
-    const stringify = (x) => ([undefined, null].includes(x) ? `${x}` : JSON.stringify(x))
-
-    if (!['node', c8].includes(options.binary)) {
-      if (['jsc', 'hermes'].includes(options.binary)) {
-        const entropy = randomBytes(5 * 1024).toString('base64')
-        input.push(`globalThis.EXODUS_TEST_CRYPTO_ENTROPY = ${stringify(entropy)};`)
-      }
-
-      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) => `[${stringify(f)}, () => require(${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)) {
-      const exit = `EXODUS_TEST_PROCESS.exitCode = 1; EXODUS_TEST_PROCESS._maybeProcessExitCode();`
-      main = `try {\n${main}\n} catch (err) { print(err); ${exit} }`
-    }
-
-    const fsfiles = await getPackageFiles()
-
-    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.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',
-        'process.type': '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_FILES: stringify(ifiles.map((f) => [dirname(f), basename(f)])),
-        EXODUS_TEST_SNAPSHOTS: stringify(EXODUS_TEST_SNAPSHOTS),
-        EXODUS_TEST_FSFILES: stringify(fsfiles.map((file) => resolve(file))), // TODO: can we safely use relative paths?
-      },
-      alias: {
-        // Node browserify
-        'node:assert': resolveRequire('assert'),
-        'node:assert/strict': resolveRequire('../src/bundle-apis/assert-strict.cjs'),
-        'node:fs': resolveRequire('../src/bundle-apis/fs.cjs'),
-        'node:fs/promises': resolveRequire('../src/bundle-apis/fs-promises.cjs'),
-        fs: resolveRequire('../src/bundle-apis/fs.cjs'),
-        'fs/promises': resolveRequire('../src/bundle-apis/fs-promises.cjs'),
-        assert: resolveRequire('assert'),
-        buffer: resolveRequire('buffer'),
-        child_process: resolveRequire('../src/bundle-apis/child_process.cjs'),
-        constants: resolveRequire('constants-browserify'),
-        crypto: resolveRequire('../src/bundle-apis/crypto.cjs'),
-        events: resolveRequire('events'),
-        http: resolveRequire('../src/bundle-apis/http.cjs'),
-        https: resolveRequire('../src/bundle-apis/https.cjs'),
-        os: resolveRequire('os-browserify'),
-        path: resolveRequire('path-browserify'),
-        querystring: resolveRequire('querystring-es3'),
-        stream: resolveRequire('stream-browserify'),
-        url: resolveRequire('url'),
-        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'),
-        // unwanted deps
-        bindings: resolveRequire('../src/bundle-apis/empty/function-throw.cjs'),
-        'node-gyp-build': resolveRequire('../src/bundle-apis/empty/function-throw.cjs'),
-        ws: resolveRequire('../src/bundle-apis/ws.cjs'),
-        // unsupported deps
-        ...Object.fromEntries(
-          blockedDeps.map((n) => [n, resolveRequire('../src/bundle-apis/empty/module-throw.cjs')])
-        ),
-      },
-      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 filepath = args.path
-              // Resolve .native versions
-              // TODO: move flag to engine options
-              // TODO: maybe follow package.json for this
-              if (['jsc', 'hermes'].includes(options.binary)) {
-                const maybeNative = filepath.replace(/(\.[cm]?js)$/u, '.native$1')
-                if (existsSync(maybeNative)) filepath = maybeNative
-              }
-
-              let contents = await readFile(filepath, '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 }
-  }
+  if (options.binary === 'node') args.unshift('--enable-source-maps') // FIXME
 
-  for (const input of inputs) Object.assign(input, await buildOne(input.file)) // TODO: queued concurrency
+  const bundle = await import('./bundle.js')
+  await bundle.init({ ...options, outdir, jestConfig })
+  buildFile = (file) => bundle.build(file)
 }
 
-assert.equal(inputs.length, files.length)
 assert(options.binary && ['node', 'bun', 'deno', 'jsc', 'hermes', c8].includes(options.binary))
 
 if (options.pure) {
@@ -630,30 +404,95 @@ if (options.pure) {
 
   process.env.EXODUS_TEST_CONTEXT = 'pure'
   console.warn(`\n${options.engine} engine is experimental and may not work an expected\n`)
-  const failures = []
-  for (const input of inputs) {
-    if (input.errors?.length > 0 || input.warnings?.length > 0) {
-      failures.push(input.source)
-      continue
-    }
+
+  const execFile = promisify(execFileCallback)
+
+  const runOne = async (inputFile) => {
+    const bundled = buildFile ? await buildFile(inputFile) : undefined
+    if (buildFile) assert(bundled.file)
+    const file = buildFile ? bundled.file : inputFile
+    if (bundled?.errors.length > 0) return { ok: false, output: bundled.errors }
 
     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(input.source)
+    // 5 MiB just in case, timeout is fallback if timeout in script hangs, 50x as it can be adjusted per-script inside them
+    // Do we want to extract timeouts from script code instead? Also, hermes might be slower, so makes sense to increase
+    const execOpts = { maxBuffer: 5 * 1024 * 1024, timeout: (jestConfig?.testTimeout || 5000) * 50 }
+    try {
+      const fullArgs = [...binaryArgs, ...args, file]
+      const { code = 0, stdout, stderr } = await execFile(options.binary, fullArgs, execOpts)
+      return { ok: code === 0, output: [stdout, stderr] }
+    } catch (err) {
+      const { code, stdout = '', stderr = '', signal, killed } = err
+      if (code === null) {
+        assert(signal)
+        const message = `  ${signal}${killed ? ' (killed)' : ''}`
+        const comment = killed && signal === 'SIGTERM' ? '  Most likely due to timeout reached' : ''
+        return { ok: false, output: [stdout, stderr, message, comment] }
+      }
+
+      assert(Number.isInteger(code) && code > 0)
+      return { ok: false, output: [stdout, stderr] }
+    } finally {
+      if (bundled) await unlink(bundled.file)
+    }
+  }
+
+  const queue = new Queue(availableParallelism() - 1)
+  const runConcurrent = async (file) => {
+    await queue.claim()
+    try {
+      // need to await here
+      return await runOne(file)
+    } finally {
+      queue.release()
+    }
+  }
+
+  const haveColors = process.stdout.hasColors?.()
+  const colors = new Map(Object.entries(inspect.colors))
+  const color = (text, color) => {
+    if (!haveColors || text === '') return text
+    if (!colors.has(color)) throw new Error(`Unknown color: ${color}`)
+    const [start, end] = colors.get(color)
+    return `\x1B[${start}m${text}\x1B[${end}m`
+  }
+
+  const format = (chunk) => {
+    if (!haveColors) return chunk
+    return chunk
+      .replaceAll(/^✔ PASS /gmu, color('✔ PASS ', 'green'))
+      .replaceAll(/^⏭ SKIP /gmu, color('⏭ SKIP ', 'dim'))
+      .replaceAll(/^✖ FAIL /gmu, color('✖ FAIL ', 'red'))
+      .replaceAll(/^‼ FATAL /gmu, `${color('‼', 'red')} ${color(' FATAL ', 'bgRed')} `)
+  }
+
+  const failures = []
+  const tasks = files.map((file) => ({ file, task: runConcurrent(file) }))
+  const timeString = color('Total time', 'dim')
+  console.time(timeString)
+  for (const { file, task } of tasks) {
+    console.log(color(`# ${file}`, 'bold'))
+    const { ok, output } = await task
+    for (const chunk of output.map((x) => x.trimEnd()).filter(Boolean)) console.log(format(chunk))
+    if (!ok) failures.push(file)
   }
 
   if (failures.length > 0) {
     process.exitCode = 1
     const [total, passed, failed] = [files.length, files.length - failures.length, failures.length]
-    console.log(`Test suites failed: ${failed} / ${total} (passed: ${passed} / ${total})`)
-    console.log('Failed test suites:')
+    const failLine = color(`${failed} / ${total}`, 'red')
+    const passLine = color(`${passed} / ${total}`, 'green')
+    const suffix = passed > 0 ? color(` (passed: ${passLine})`, 'dim') : ''
+    console.log(`${color('Test suites failed:', 'bold')} ${failLine}${suffix}`)
+    console.log(color('Failed test suites:', 'red'))
     for (const file of failures) console.log(`  ${file}`) // joining with \n can get truncated, too big
   } else {
-    console.log(`All ${files.length} test suites passed`)
+    console.log(color(`All ${files.length} test suites passed`, 'green'))
   }
+
+  console.timeEnd(timeString)
 } else {
+  assert(!buildFile)
   assert(['node', c8].includes(options.binary), `Unexpected native engine: ${options.binary}`)
   assert(['node:test'].includes(options.engine))
   process.env.EXODUS_TEST_CONTEXT = options.engine

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.32",
+  "version": "1.0.0-rc.34",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -36,6 +36,8 @@
   "prettier": "@exodus/prettier",
   "files": [
     "bin/babel.cjs",
+    "bin/babel-worker.cjs",
+    "bin/bundle.js",
     "bin/jest.js",
     "bin/typescript.js",
     "bin/typescript.loader.js",
@@ -52,6 +54,7 @@
     "src/bundle-apis/globals.cjs",
     "src/bundle-apis/jest-message-util.js",
     "src/bundle-apis/jest-util.js",
+    "src/bundle-apis/node-buffer.cjs",
     "src/bundle-apis/util-format.cjs",
     "src/bundle-apis/ws.cjs",
     "src/dark.cjs",
@@ -69,6 +72,7 @@
     "src/jest.timers.js",
     "src/node.js",
     "src/tape.js",
+    "src/tape.cjs",
     "src/version.js",
     "!__tests__",
     "CHANGELOG.md"
@@ -88,15 +92,17 @@
   },
   "dependencies": {
     "@babel/core": "^7.0.0",
-    "@babel/plugin-transform-arrow-functions": "^7.0.0",
-    "@babel/plugin-transform-async-generator-functions": "^7.0.0",
+    "@babel/plugin-syntax-typescript": "^7.0.0",
     "@babel/plugin-transform-block-scoping": "^7.0.0",
     "@babel/plugin-transform-class-properties": "^7.0.0",
     "@babel/plugin-transform-classes": "^7.0.0",
+    "@babel/plugin-transform-private-methods": "^7.0.0",
     "@babel/register": "^7.0.0",
+    "@chalker/queue": "^1.0.0",
     "@ungap/url-search-params": "^0.2.2",
     "amaro": "^0.0.4",
     "assert": "^2.1.0",
+    "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",
     "c8": "^9.1.0",
     "constants-browserify": "^1.0.0",
@@ -113,6 +119,7 @@
     "querystring-es3": "^0.2.1",
     "stream-browserify": "^3.0.0",
     "text-encoding": "^0.7.0",
+    "timers-browserify": "^2.0.12",
     "tsx": "^4.16.2",
     "url": "^0.11.0",
     "util": "^0.12.5"

package/src/bundle-apis/crypto.cjs

@@ -2,4 +2,4 @@ const cb = require('crypto-browserify')
 const webcrypto = globalThis.crypto
 const randomUUID = () => webcrypto.randomUUID()
 const getRandomValues = (array) => webcrypto.getRandomValues(array)
-module.exports = { ...cb, webcrypto, subtle: webcrypto.subtle, randomUUID, getRandomValues }
+module.exports = { ...cb, webcrypto, subtle: webcrypto?.subtle, randomUUID, getRandomValues }

package/src/bundle-apis/fs.cjs

@@ -81,4 +81,8 @@ const existsSync = (file) => {
   err('existsSync', file)
 }
 
-module.exports = { ...stubs, existsSync, promises, constants, F_OK, R_OK, W_OK, X_OK }
+const readFileSync = (file /*, options */) => {
+  err('readFileSync', file)
+}
+
+module.exports = { ...stubs, existsSync, readFileSync, promises, constants, F_OK, R_OK, W_OK, X_OK }

package/src/bundle-apis/globals.cjs

@@ -1,3 +1,6 @@
+// We expect bundler to optimize out EXODUS_TEST_PLATFORM blocks
+/* eslint-disable sonarjs/no-collapsible-if, unicorn/no-lonely-if */
+
 if (!globalThis.global) globalThis.global = globalThis
 if (!globalThis.Buffer) globalThis.Buffer = require('buffer').Buffer
 if (!globalThis.console) {
@@ -24,6 +27,19 @@ if (!Array.prototype.at) {
   }
 }
 
+if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
+  // Fixed after 0.12, not present in 0.12
+  // Refs: https://github.com/facebook/hermes/commit/e8fa81328dd630e39975e6d16ac3e6f47f4cba06
+  if (!Promise.allSettled) {
+    const wrap = (element) =>
+      Promise.resolve(element).then(
+        (value) => ({ status: 'fulfilled', value }),
+        (reason) => ({ status: 'rejected', reason })
+      )
+    Promise.allSettled = (iterable) => Promise.all([...iterable].map((element) => wrap(element)))
+  }
+}
+
 if (globalThis.describe) delete globalThis.describe
 
 if (typeof process === 'undefined') {
@@ -48,7 +64,9 @@ if (typeof process === 'undefined') {
       if (globalThis.Deno) return // has native exitCode support
       if (process._exitCode !== 0) {
         setTimeout(() => {
-          throw new Error('Test failed')
+          const err = new Error('Test failed')
+          err.stack = ''
+          throw err
         }, 0)
       }
     },
@@ -57,6 +75,24 @@ if (typeof process === 'undefined') {
   globalThis.EXODUS_TEST_PROCESS = process
 }
 
+if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
+  let headerLogged = false
+  globalThis.HermesInternal?.enablePromiseRejectionTracker({
+    allRejections: true,
+    onUnhandled: (i, err) => {
+      globalThis.EXODUS_TEST_PROCESS.exitCode = 1
+      if (!headerLogged) {
+        console.log(`‼ FATAL Tests generated asynchronous activity after they ended.
+This activity created errors and would have caused tests to fail, but instead triggered unhandledRejection events`)
+        headerLogged = true
+      }
+
+      console.log(`Uncaught error #${i}: ${err}`)
+      globalThis.EXODUS_TEST_PROCESS._maybeProcessExitCode()
+    },
+  })
+}
+
 if (
   process.env.EXODUS_TEST_PLATFORM === 'hermes' ||
   (process.env.EXODUS_TEST_PLATFORM === 'jsc' && !globalThis.clearTimeout)

package/src/bundle-apis/node-buffer.cjs

@@ -0,0 +1,3 @@
+// For node.js Buffers to have the same ref / be fast
+const { Buffer, Blob, File } = globalThis
+module.exports = { Buffer, Blob, File, INSPECT_MAX_BYTES: 50, kMaxLength: 2 ** 31 - 1 }

package/src/bundle-apis/util-format.cjs

@@ -1,4 +1,4 @@
-const { inspect, isString, isNull, isObject } = require('util/util.js') // dep
+const { inspect, isString, isNull, isObject } = require('util/') // dep
 
 // Patched impl from require('util'), added %i
 

package/src/engine.pure.cjs

@@ -69,21 +69,21 @@ async function runContext(context) {
 
     // TODO: try/catch for hooks?
     for (const c of stack) for (const hook of c.hooks.beforeEach) await runFunction(hook, context)
+    const guard = { id: null, failed: false }
+    guard.promise = new Promise((resolve) => {
+      guard.id = setTimeout(() => {
+        guard.failed = true
+        resolve()
+      }, options.timeout || 5000)
+    })
     try {
-      const guard = { id: null, failed: false }
-      guard.promise = new Promise((resolve) => {
-        guard.id = setTimeout(() => {
-          guard.failed = true
-          resolve()
-        }, options.timeout || 5000)
-      })
       await Promise.race([guard.promise, runFunction(fn, context)])
-      clearTimeout(guard.id)
       if (guard.failed) throw new Error('timeout reached')
     } catch (e) {
       error = e ?? 'Unknown error'
     }
 
+    clearTimeout(guard.id)
     stack.reverse()
     for (const c of stack) for (const hook of c.hooks.afterEach) await runFunction(hook, context)
 
@@ -109,17 +109,29 @@ async function run() {
   assert(context === context.root)
   await runContext(context).catch((error) => {
     // Should not throw under regular circumstances
-    console.log('Fatal: ', error)
+    console.log('‼ FATAL', error)
     abstractProcess.exitCode = 1
   })
   abstractProcess._maybeProcessExitCode?.()
 }
 
-function describe(...args) {
+async function describe(...args) {
   const { name, options, fn } = parseArgs(args)
   enterContext(name, options)
   context.options = options
-  if (!options.skip) fn(context) // todo: callback
+  // todo: callback support?
+  if (!options.skip) {
+    try {
+      const res = fn(context)
+      // we don't need to be async if fn is sync
+      if (isPromise(res)) await res
+    } catch (error) {
+      console.log('✖ FAIL', context.fullName)
+      console.log('  describe() body threw an error:', error)
+      abstractProcess.exitCode = 1
+    }
+  }
+
   exitContext()
 }
 
@@ -216,7 +228,7 @@ class MockTimers {
   }
 
   runAll() {
-    this.tick(Math.max(0, ...this.#queue.map((x) => x.at)))
+    this.tick(Math.max(0, ...this.#queue.map((x) => x.at - this.#elapsed)))
   }
 
   setTime(milliseconds) {
@@ -224,15 +236,21 @@ class MockTimers {
   }
 
   #setTimeout(fn, delay, ...args) {
-    this.#queue.push({ type: 'timeout', fn, at: delay + this.#elapsed, args })
+    const id = { type: 'timeout', fn, at: delay + this.#elapsed, args }
+    this.#queue.push(id)
+    return id
   }
 
   #setInterval(fn, delay, ...args) {
-    this.#queue.push({ type: 'interval', fn, at: delay + this.#elapsed, interval: delay, args })
+    const id = { type: 'interval', fn, at: delay + this.#elapsed, interval: delay, args }
+    this.#queue.push(id)
+    return id
   }
 
   #setImmediate(fn, ...args) {
-    this.#queue.push({ type: 'immediate', fn, args })
+    const id = { type: 'immediate', fn, args }
+    this.#queue.push(id)
+    return id
   }
 
   #clearTimeout(id) {
@@ -248,50 +266,12 @@ class MockTimers {
   }
 }
 
-class MockedFunction extends Function {
-  get mock() {
-    return this._mock
-  }
-}
-
 const mock = {
   module: undefined,
   timers: new MockTimers(),
   fn: (original = () => {}, implementation = original) => {
     let impl = implementation
-    const mocked = function (...args) {
-      const call = {
-        arguments: args,
-        // eslint-disable-next-line unicorn/error-message
-        stack: new Error(), // todo: recheck location
-        target: undefined,
-        this: this,
-      }
-
-      mocked.mock.calls.push(call)
-
-      try {
-        // todo: what's if it a promise
-        if (this instanceof mocked) {
-          impl.apply(this, args)
-          call.result = call.target = this
-        } else {
-          call.result = impl.apply(this, args)
-        }
-
-        call.error = undefined
-      } catch (err) {
-        call.result = undefined
-        call.error = err
-        throw err
-      }
-
-      return call.result
-    }
-
-    Object.setPrototypeOf(mocked, MockedFunction.prototype)
-
-    mocked._mock = {
+    const _mock = {
       calls: [],
       get callCount() {
         return this.calls.length
@@ -307,14 +287,64 @@ const mock = {
         }
       },
       resetCalls: () => {
-        mocked._mock.calls.length = 0
+        _mock.calls.length = 0
       },
       restore: () => {
         impl = original
       },
     }
 
-    return mocked
+    return new Proxy(function () {}, {
+      __proto__: null,
+      apply(fn, _this, args) {
+        // eslint-disable-next-line unicorn/error-message
+        const call = { arguments: args, stack: new Error(), target: undefined, this: _this } // todo: recheck .stack location
+
+        try {
+          call.result = impl.apply(_this, args)
+          call.error = undefined
+        } catch (err) {
+          call.result = undefined
+          call.error = err
+          throw err
+        } finally {
+          _mock.calls.push(call)
+        }
+
+        return call.result
+      },
+      construct(target, args) {
+        // eslint-disable-next-line unicorn/error-message
+        const call = { arguments: args, stack: new Error(), target } // todo: recheck .stack location
+
+        try {
+          call.result = call.this = new impl(...args) // eslint-disable-line new-cap
+          call.error = undefined
+        } catch (err) {
+          call.result = undefined
+          call.error = err
+          throw err
+        } finally {
+          _mock.calls.push(call)
+        }
+
+        return call.result
+      },
+      get: (fn, key) => {
+        if (key === 'mock') return _mock
+        const target = key !== 'prototype' && key in fn ? fn : impl
+        return target[key]
+      },
+      set: (fn, key, value) => {
+        const target = key !== 'prototype' && key in fn ? fn : impl
+        target[key] = value
+        return true
+      },
+      getOwnPropertyDescriptor(fn, key) {
+        const target = key !== 'prototype' && key in fn ? fn : impl
+        return Object.getOwnPropertyDescriptor(target, key)
+      },
+    })
   },
 }
 

package/src/jest.config.js

@@ -64,11 +64,11 @@ export const jestConfig = () => {
 
 export async function loadJestConfig(...args) {
   let rawConfig
-  if (process.env.EXODUS_TEST_JEST_CONFIG) {
-    rawConfig = JSON.parse(process.env.EXODUS_TEST_JEST_CONFIG)
-  } else {
+  if (process.env.EXODUS_TEST_JEST_CONFIG === undefined) {
     const { readJestConfig } = await import('./jest.config.fs.js')
     rawConfig = await readJestConfig(...args)
+  } else {
+    rawConfig = JSON.parse(process.env.EXODUS_TEST_JEST_CONFIG)
   }
 
   config = normalizeJestConfig(rawConfig)

package/src/jest.environment.js

@@ -32,12 +32,16 @@ export const specialEnvironments = {
     dependencies: ['@pollyjs/core', 'setup-polly-jest', 'setup-polly-jest/lib/common'],
     setup: async (require, engine) => {
       const { getTestNamePath } = await import('./dark.cjs')
+      // polly has bad defer impl in case if it finds MessageChannel but not process.* (e.g. on deno), forever blocking
+      const { MessageChannel } = globalThis
+      if (MessageChannel) globalThis.MessageChannel = undefined
       const { Polly } = require('@pollyjs/core')
       const pollyJest = require('setup-polly-jest')
       const {
         JestPollyGlobals,
         createPollyContextAccessor,
       } = require('setup-polly-jest/lib/common')
+      if (MessageChannel) globalThis.MessageChannel = MessageChannel
       const pollyGlobals = new JestPollyGlobals(globalThis)
       pollyGlobals.isJestPollyEnvironment = true
       pollyJest.setupPolly = (options) => {

package/src/jest.js

@@ -94,7 +94,7 @@ const describe = (...args) => {
   inDescribe.push(fn)
   const optionsConcurrent = args?.at(-1)?.concurrency > 1
   if (optionsConcurrent) inConcurrent.push(fn)
-  const result = node.describe(...args, async () => {
+  const result = node.describe(...args, () => {
     const res = fn()
 
     // We do only block-level concurrency, not file-level

package/src/jest.snapshot.js

@@ -96,6 +96,20 @@ const snapInline = (obj, inline) => {
   getAssert().strictEqual(serialize(obj).trim(), inline.trim())
 }
 
+const deepMerge = (obj, matcher) => {
+  if (!obj || !matcher) return matcher
+  const proto = Object.getPrototypeOf(obj)
+  if (![Object.prototype, null].includes(proto)) return matcher
+  const protoM = Object.getPrototypeOf(matcher)
+  if (![Object.prototype, null].includes(protoM)) return matcher
+  // all matcher keys should be already in obj, as verified by toMatchObject prior to this
+  const map = new Map(Object.entries(matcher))
+  const merge = (key, value) => [key, map.has(key) ? deepMerge(value, map.get(key)) : value]
+  const res = Object.fromEntries(Object.entries(obj).map(([key, value]) => merge(key, value)))
+  Object.setPrototypeOf(res, proto)
+  return res
+}
+
 const snapOnDisk = (orig, matcher) => {
   if (matcher) {
     expect(orig).toMatchObject(matcher)
@@ -105,7 +119,7 @@ const snapOnDisk = (orig, matcher) => {
     state.numPassingAsserts--
   }
 
-  const obj = matcher ? { ...orig, ...matcher } : orig
+  const obj = matcher ? deepMerge(orig, matcher) : orig
   const escape = (str) => str.replaceAll(/([\\`])/gu, '\\$1')
 
   maybeSetupJestSnapshots()

package/src/tape.cjs

@@ -0,0 +1,15 @@
+let lib
+
+const loadLib = async () => {
+  if (!lib) lib = await import('./tape.js')
+  return lib
+}
+
+/* eslint-disable unicorn/no-await-expression-member */
+const test = async (...args) => (await loadLib()).test(...args)
+test.skip = async (...args) => (await loadLib()).test.skip(...args)
+test.only = async (...args) => (await loadLib()).test.only(...args)
+test.test = test
+/* eslint-enable unicorn/no-await-expression-member */
+
+module.exports = test

package/src/tape.js

@@ -1,4 +1,4 @@
-import { assert, assertLoose, test } from './engine.js'
+import { assert, assertLoose, test as nodeTest } from './engine.js'
 import { createCallerLocationHook } from './dark.cjs'
 import './version.js'
 
@@ -63,7 +63,7 @@ const aliases = {
   doesNotThrow: ['doesNotThrow'],
   fail: ['fail'],
   rejects: ['rejects'],
-  doesNotReject: ['resolves'],
+  doesNotReject: ['doesNotReject', 'resolves'],
 
   // specially handled ones as do not exist in t.assert / assert
   notOk: ['notOk', 'false', 'notok'],
@@ -156,5 +156,5 @@ function tapeWrap(test) {
   return tap
 }
 
-export const tape = tapeWrap(test)
-export default tape
+export const test = tapeWrap(nodeTest)
+export default test