@exodus/test 1.0.0-rc.109 → 1.0.0-rc.110

package/README.md

@@ -1,21 +1,53 @@
 # @exodus/test
 
+[![](https://flat.badgen.net/npm/v/@exodus/test)](https://npmjs.org/package/@exodus/test)
+[![](https://flat.badgen.net/github/release/ExodusOSS/test?icon=github)](https://github.com/ExodusOSS/test/releases)
+[![](https://flat.badgen.net/npm/license/@exodus/test)](https://github.com/ExodusOSS/test/blob/HEAD/LICENSE)
+[![](https://flat.badgen.net/github/checks/ExodusOSS/test/main?icon=github)](https://github.com/ExodusOSS/test/actions/workflows/checks.yml?query=branch%3Amain)
+[![](https://img.shields.io/github/stars/ExodusOSS/test)](https://github.com/ExodusOSS/test/stargazers)
+
 A runner for `node:test`, `jest`, and `tape` test suites on top of `node:test` (and any runtime).
 
-It can run your existing tests on [all runtimes and also browsers](#engines), with snapshots and module mocks.
+---
+
+It can run your existing tests on [all runtimes and also browsers](#engines), with snapshots and module mocks:
+
+[![Node.js](https://img.shields.io/badge/Node.js-338750?style=flat-square&logo=Node.js&logoColor=FFF)](https://nodejs.org/api/test.html)
+[![Deno](https://img.shields.io/badge/Deno-121417?style=flat-square&logo=Deno&logoColor=FFF)](https://deno.com/)
+[![Bun](https://img.shields.io/badge/Bun-F472B6?style=flat-square&logo=Bun&logoColor=FFF)](https://bun.sh/)
+[![Electron](https://img.shields.io/badge/Electron-2F3242?style=flat-square&logo=Electron&logoColor=A2ECFB)](http://electronjs.org/)\
+[![Chrome](https://img.shields.io/badge/Chrome-4285F4?style=flat-square&logo=GoogleChrome&logoColor=FFF)](https://www.chromium.org/Home/)
+[![WebKit](https://img.shields.io/badge/WebKit-006CFF?style=flat-square&logo=Safari&logoColor=FFF)](http://webkit.org/)
+[![Firefox](https://img.shields.io/badge/Firefox-FF7139?style=flat-square&logo=Firefox&logoColor=FFF)](https://github.com/mozilla-firefox)
+[![Brave](https://img.shields.io/badge/Brave-F0F0F0?style=flat-square&logo=Brave)](https://github.com/brave)
+[![Microsoft Edge](https://img.shields.io/badge/Edge-0078D7?style=flat-square)](https://github.com/microsoftedge)
+[![Servo](https://img.shields.io/badge/Servo-009D9A?style=flat-square)](https://servo.org/)\
+[![Hermes](https://img.shields.io/badge/Hermes-282C34?style=flat-square&logo=React)](https://hermesengine.dev)
+[![V8](https://img.shields.io/badge/V8-4285F4?style=flat-square&logo=V8&logoColor=white)](https://v8.dev/docs/d8)
+[![JavaScriptCore](https://img.shields.io/badge/JavaScriptCore-006CFF?style=flat-square)](https://docs.webkit.org/Deep%20Dive/JSC/JavaScriptCore.html)
+[![SpiderMonkey](https://img.shields.io/badge/SpiderMonkey-FFD681?style=flat-square)](https://spidermonkey.dev/)
+[![QuickJS](https://img.shields.io/badge/QuickJS-E58200?style=flat-square)](https://github.com/quickjs-ng/quickjs)
+[![XS](https://img.shields.io/badge/XS-0B307A?style=flat-square)](https://github.com/Moddable-OpenSource/moddable-xst)
+[![GraalJS](https://img.shields.io/badge/GraalJS-C74634?style=flat-square)](https://github.com/oracle/graaljs)
+[![Boa](https://img.shields.io/badge/Boa-F3FF00?style=flat-square)](https://github.com/boa-dev/boa)
+[![Escargot](https://img.shields.io/badge/Escargot-1428A0?style=flat-square)](https://github.com/Samsung/escargot)
+[![engine262](https://img.shields.io/badge/engine262-f0db4f?style=flat-square&logo=javascript&logoColor=000)](https://github.com/engine262/engine262)
+
+Compatible with tests written in:
+
+[![node:test](https://img.shields.io/badge/node:test-338750?style=for-the-badge&logo=Node.js&logoColor=FFF)](#using-with-nodetest-tests)
+[![Jest](https://img.shields.io/badge/Jest-C21325?style=for-the-badge&logo=jest&logoColor=fff)](#migrating-from-jest)
+[![tape](https://img.shields.io/badge/tape-6c5353?style=for-the-badge)](#migrating-from-tape)
+
+See [documentation](https://exodusoss.github.io/test/).
 
 ## Features
 
 - Native ESM, including in Jest tests
-- Esbuild on the fly for babelified ESM interop (enable via `--esbuild`)
-- TypeScript support in both transform (through [tsx](https://tsx.is/), enable via `--esbuild`)
-  and typestrip (via `--typescript`) modes
-- Runs on Node.js [node:test](https://nodejs.org/api/test.html), Bun, Deno, Electron,
-  [v8 CLI](https://v8.dev/docs/d8), JSC, [Hermes](https://hermesengine.dev), [SpiderMonkey](https://spidermonkey.dev/),
-  Chrome, Firefox, WebKit, Brave, Microsoft Edge, [Servo](https://servo.org/),
-  [QuickJS](https://github.com/quickjs-ng/quickjs), [XS](https://github.com/Moddable-OpenSource/moddable-xst),
-  [GraalJS](https://github.com/oracle/graaljs), [Escargot](https://github.com/Samsung/escargot),
-  [Boa](https://github.com/boa-dev/boa), and even [engine262](https://github.com/engine262/engine262).
+- Esbuild on the fly for old faux-ESM interop (enable via `--esbuild`)
+- TypeScript support
+- Runs anywhere (including Hermes, the [React Native](https://reactnative.dev/) JavaScript engine)
+- Use snapshots to cross-compare between runtimes, browsers and barebones (including Hermes)
 - Testsuite-agnostic — can run any file as long as it sets exit code based on test results
 - Built-in [Jest](https://jestjs.io) compatibility (with `--jest`), including `jest.*` global
   - Up to ~10x faster depending on the original setup
@@ -35,7 +67,73 @@ It can run your existing tests on [all runtimes and also browsers](#engines), wi
 - Unlike `bun:test`, it runs test files in isolated contexts \
   Bun leaks globals / side effects between test files ([ref](https://github.com/oven-sh/bun/issues/6024)),
   and has incompatible `test()` lifecycle / order
-- Also features a tape API for drop-in replacement
+
+## Getting started
+
+First install with `npm install --save-dev @exodus/test` (or with your favorite package manager)
+
+Then, add this to `package.json` scripts (or see [engines example](https://github.com/ExodusOSS/bytes/blob/v1.11.0/package.json#L25-L42)):
+
+```json
+  "test": "exodus-test"
+```
+
+That's it. It works zero-config.
+
+See [Options](#options) to change defaults, e.g. to enable Jest globals with `--jest`.
+
+To use [Engines](#engines) on CI, see e.g. GitHub CI config of [@exodus/bytes](https://github.com/ExodusOSS/bytes/blob/main/.github/workflows/test.yml).
+
+### Using with node:test tests
+
+You don't need to change the tests or any extra configuration on top of [Getting started](#getting-started).
+
+It just works out of the box, and on Node.js native `node:test` is used under the hood.
+
+Using this script is similar to `node --test`:
+
+```json
+  "test": "exodus-test"
+```
+
+But, unlike bare `node --test` it supports [engines](#engines) and the [GitHub CI reporter](#github-actions).
+
+### Migrating from Jest
+
+Use this in `package.json` scripts:
+
+```json
+  "test": "exodus-test --jest"
+```
+
+If that doesn't work (e.g. some deps are faux-ESM), add `--esbuild` to transpile those:
+
+```json
+  "test": "exodus-test --jest --esbuild"
+```
+
+To adjust module mocks for native ESM support, see [Module mocking in ESM](#module-mocking-in-esm).
+
+Some complex setups with React Native don't work yet.
+
+### Migrating from tape
+
+Use this in `package.json` scripts:
+
+```json
+  "test": "exodus-test"
+```
+
+Great! Now your tape tests run on top of `node:test`, and are also runnable in browsers / barebone [engines](#engines).
+
+> [!TIP]
+> You can optionally replace `tape` imports with `@exodus/test/tape`
+> to be able to be individually run them with just `node ./path-to-file.js`:
+>
+> ```js
+> import test from '@exodus/test/tape' // ESM
+> const test = require('@exodus/test/tape') // CJS
+> ```
 
 ## Engines
 
@@ -67,7 +165,7 @@ Use `--engine` (or `EXODUS_TEST_ENGINE=`) to specify one of:
     - `brave:puppeteer` — Brave
     - `msedge:puppeteer` — Microsoft Edge
   - Bundle
-    - `servo:bundle` — Servo (expects it to be installed in the system or in PATH)
+    - `servo:bundle` — Servo (expects it to be installed in the system)
 - Barebone engines (system-provided or installed with `npx jsvu` / `npx esvu`):
   - `v8:bundle` — [v8 CLI](https://v8.dev/docs/d8) (Chrome/Blink/Node.js JavaScript engine)
   - `jsc:bundle` — [JavaScriptCore](https://docs.webkit.org/Deep%20Dive/JSC/JavaScriptCore.html) (Safari/WebKit JavaScript engine)
@@ -81,9 +179,39 @@ Use `--engine` (or `EXODUS_TEST_ENGINE=`) to specify one of:
   - `engine262:bundle` - [engine262](https://github.com/engine262/engine262), the per-spec implementation of ECMA-262
     (install with [esvu](https://npmjs.com/package/esvu))
 
+## Options
+
+- `--jest` — register jest test helpers as global variables, also load `jest.config.*` configuration options
+
+- `--esbuild` — use esbuild loader, also enables Typescript support on old Node.js
+
+- `--typescript` — enable Typescript type stripping (only needed on older Node.js versions which don't have it natively)
+
+- `--babel` — use babel loader (slower than `--esbuild`, makes sense if you have a special config)
+
+- `--coverage` — enable coverage, prints coverage output (varies by coverage engine)
+
+- `--coverage-engine c8` — use c8 coverage engine (default), also generates `./coverage/` dirs
+
+- `--coverage-engine node` — use Node.js builtint coverage engine
+
+- `--watch` — operate in watch mode and re-run tests on file changes
+
+- `--only` — only run the tests marked with `test.only`
+
+- `--passWithNoTests` — do not error when no test files were found
+
+- `--write-snapshots` — write snapshots instead of verifying them (has `--test-update-snapshots` alias)
+
+- `--test-force-exit` — force exit after tests are done
+
+- `--engine` — specify one of [Engines](#engines) to run on
+
 ## Reporter samples
 
-#### CLI (but uses colors when output supports them, e.g. in terminal):
+### CLI
+
+Uses colors when output supports them, e.g. in terminal.
 
 ```console
 # tests/jest/expect.mock.test.js
@@ -100,7 +228,9 @@ Use `--engine` (or `EXODUS_TEST_ENGINE=`) to specify one of:
 ✔ PASS mock.invocationCallOrder (4.221042ms)
 ```
 
-#### GitHub Actions collapses test results per-file, like this:
+### GitHub Actions
+
+Collapses test results per-file, like this:
 
 <details>
  <summary>✅ <strong>tests/jest/lifecycle.test.js</strong></summary>
@@ -132,44 +262,6 @@ Use `--engine` (or `EXODUS_TEST_ENGINE=`) to specify one of:
 
 See live output in [CI](https://github.com/ExodusOSS/test/actions/workflows/checks.yaml)
 
-## Library
-
-### List of exports
-
-- `@exodus/test/node` — `node:test` API, working under non-Node.js platforms
-
-- `@exodus/test/jest` — `jest` implementation
-
-- `@exodus/test/tape` — `tape` mock (can also be helpful when moving from `tap`)
-
-## Binary
-
-Just use `"test": "exodus-test"`
-
-### Options
-
-- `--jest` — register jest test helpers as global variables, also load `jest.config.*` configuration options
-
-- `--esbuild` — use esbuild loader, also enables Typescript support
-
-- `--babel` — use babel loader (slower than `--esbuild`, makes sense if you have a special config)
-
-- `--coverage` — enable coverage, prints coverage output (varies by coverage engine)
-
-- `--coverage-engine c8` — use c8 coverage engine (default), also generates `./coverage/` dirs
-
-- `--coverage-engine node` — use Node.js builtint coverage engine
-
-- `--watch` — operate in watch mode and re-run tests on file changes
-
-- `--only` — only run the tests marked with `test.only`
-
-- `--passWithNoTests` — do not error when no test files were found
-
-- `--write-snapshots` — write snapshots instead of verifying them (has `--test-update-snapshots` alias)
-
-- `--test-force-exit` — force exit after tests are done
-
 ## Module mocking in ESM
 
 Module mocks in ESM is a common source of confusion, as Jest in most old setups does not run real ESM,

package/bin/index.js

@@ -19,7 +19,7 @@ import { glob as globImplementation } from '../src/glob.cjs'
 const DEFAULT_PATTERNS = [`**/?(*.)+(spec|test).?([cm])[jt]s?(x)`] // do not trust magic dirs by default
 const bundleOpts = { pure: true, bundle: true, esbuild: true, ts: 'auto' }
 const bareboneOpts = { ...bundleOpts, barebone: true }
-const hermesA = ['-w', '-Xmicrotask-queue'] // -Xes6-class fails with -O0 / -Og, --block-scoping fails in default, any of that is bad
+const hermesA = ['-w', '-Xmicrotask-queue', '-eager'] // -Xes6-class fails with -O0 / -Og, --block-scoping fails in default, any of that is bad
 const hermesS = [...hermesA, '-Xes6-block-scoping']
 const denoA = ['run', '--allow-all'] // also will set DENO_COMPAT=1 env flag below
 const denoT = ['test', '--allow-all']
@@ -45,6 +45,7 @@ const ENGINES = new Map(
     'hermes:bundle': { binary: 'hermes', binaryArgs: hermesA, target: 'es2018', ...bareboneOpts },
     'shermes:bundle': { binary: 'shermes', binaryArgs: hermesS, target: 'es2018', ...bareboneOpts },
     'spidermonkey:bundle': { binary: 'spidermonkey', ...bareboneOpts },
+    'ladybird-js:bundle': { binary: 'ladybird-js', binaryArgs: ['-i'], ...bareboneOpts },
     'engine262:bundle': { binary: 'engine262', ...bareboneOpts },
     'quickjs:bundle': { binary: 'quickjs', binaryArgs: ['--std'], ...bareboneOpts },
     'xs:bundle': { binary: 'xs', ...bareboneOpts },
@@ -66,8 +67,9 @@ const ENGINES = new Map(
     'msedge:playwright': { binary: 'msedge', browsers: 'playwright', ...bundleOpts },
   })
 )
-const barebonesOk = ['v8', 'd8', 'spidermonkey', 'quickjs', 'xs', 'hermes', 'shermes']
-const barebonesUnhandled = ['jsc', 'escargot', 'boa', 'graaljs', 'jerry', 'engine262', 'servo']
+const bareOk = ['v8', 'd8', 'spidermonkey', 'quickjs', 'xs', 'hermes', 'shermes']
+const bareUnhandled = ['jsc', 'escargot', 'boa', 'graaljs', 'jerry', 'engine262', 'servo']
+const bareIncomplete = ['ladybird-js']
 
 const getEnvFlag = (name) => {
   if (!Object.hasOwn(process.env, name)) return
@@ -353,10 +355,13 @@ if (process.env.EXODUS_TEST_IGNORE) {
 
 // This might be used in presets, so has to be loaded before jest
 if (options.flow && !options.bundle) args.push('--import', import.meta.resolve('../loader/flow.js'))
-if (['node:test', 'electron-as-node:test', 'deno:test'].includes(options.engine)) {
-  // Do not need node:test override
-} else if (options.engine === 'deno:pure') {
-  args.push('--import-map', import.meta.resolve('../loader/deno-import-map.json'))
+if (['node:test', 'electron-as-node:test', 'deno:test', 'deno:pure'].includes(options.engine)) {
+  args.push('--import', import.meta.resolve('../loader/remap.cjs'))
+  if (options.engine === 'deno:test') {
+    args.push('--import-map', import.meta.resolve('../loader/deno-import-map.json'))
+  } else if (options.engine === 'deno:pure') {
+    args.push('--import-map', import.meta.resolve('../loader/deno-import-map.pure.json'))
+  }
 } else if (!options.bundle) {
   args.push(options.loader ?? '-r', import.meta.resolve('../loader/node-test.js'))
 }
@@ -489,7 +494,7 @@ async function glob(patterns, { ignore, cwd }) {
 
 if (patterns.length === 0) patterns.push(...DEFAULT_PATTERNS) // defaults
 const globbed = await glob(patterns, { ignore })
-const allfiles = filter ? globbed.filter(filter) : globbed
+const allfiles = (filter ? globbed.filter(filter) : globbed).sort()
 
 if (allfiles.length === 0) {
   if (options.passWithNoTests) {
@@ -653,7 +658,7 @@ async function launch(binary, args, opts = {}, buffering = false) {
     return browsers.run(runner, args, { binary, devtools, dropNetwork, timeout, throttle })
   }
 
-  const barebones = [...barebonesOk, ...barebonesUnhandled]
+  const barebones = [...bareOk, ...bareUnhandled, ...bareIncomplete]
   assertBinary(binary, ['node', 'bun', 'deno', 'electron', 'workerd', ...barebones])
   if (binary === c8 && process.platform === 'win32') {
     ;[binary, args] = ['node', [binary, ...args]]
@@ -684,9 +689,10 @@ if (options.pure) {
   }
 
   setEnv('EXODUS_TEST_CONTEXT', 'pure')
-  warnHuman(`${engineName} is experimental and may not work an expected`)
-  const missUnhandled = barebonesUnhandled.includes(options.platform) || isBrowserLike
+  const missUnhandled = bareUnhandled.includes(options.platform) || isBrowserLike
+  const isIncomplete = bareIncomplete.includes(options.platform)
   if (missUnhandled) warnHuman(`Warning: ${engineName} does not have unhandled rejections tracking`)
+  if (isIncomplete) warnHuman(`Warning: ${engineName} support is incomplete`)
 
   const runOne = async (inputFile) => {
     const bundled = buildFile ? await buildFile(inputFile) : undefined
@@ -700,7 +706,19 @@ if (options.pure) {
 
     const file = buildFile ? bundled.fileHtml ?? bundled.file : inputFile
     const failedBare = 'EXODUS_TEST_FAILED_EXIT_CODE_1'
-    const cleanOut = (out) => out.replaceAll(`\n${failedBare}\n`, '\n').replaceAll(failedBare, '')
+    const cleanOut = (out, ok) => {
+      if (options.engine === 'ladybird-js:bundle') {
+        // It wrapps all prints/console.log in double quotes for strings, and escapes \b \n \v \f \r \, but does not wrap "
+        const unmap = { __proto__: null, b: '\b', n: '\n', v: '\v', f: '\f', r: '\r' }
+        const fix = (x) => x.slice(1, -1).replaceAll(/\\([bnvfr\\])/gu, (s) => unmap[s[1]] ?? s[1])
+        const lineMapper = (x) => (x.startsWith('"') && x.endsWith('"') ? fix(x) : x)
+        out = out.split('\n').map(lineMapper).join('\n')
+      }
+
+      out = out.replaceAll(`\n${failedBare}\n`, '\n').replaceAll(failedBare, '')
+      return out || (ok ? `✔ PASS ${file}` : `✖ FAIL ${file}`)
+    }
+
     // 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 timeout = (options.testTimeout || jestConfig?.testTimeout || 5000) * 50
@@ -711,11 +729,11 @@ if (options.pure) {
       const ms = Number(process.hrtime.bigint() - start) / 1e6
       if (stdout.includes(failedBare)) return { ok: false, output: [cleanOut(stdout), stderr], ms }
       const ok = code === 0 && !/^(✖ FAIL|‼ FATAL) /mu.test(stdout)
-      return { ok, output: [stdout, stderr], ms }
+      return { ok, output: [cleanOut(stdout, ok), stderr], ms }
     } catch (err) {
       const ms = Number(process.hrtime.bigint() - start) / 1e6
       const { code, stderr = '', signal, killed } = err
-      const stdout = cleanOut(err.stdout || '')
+      const stdout = cleanOut(err.stdout || '', false)
       if (code === null) {
         assert(signal)
         const message = `  ${signal}${killed ? ' (killed)' : ''}`

package/loader/deno-import-map.json

@@ -1,6 +1,5 @@
 {
   "imports": {
-    "node:test": "../src/node.js",
     "@jest/globals": "../src/jest.js",
     "tape": "../src/tape.js",
     "tape-promise/tape": "../src/tape.js",

package/loader/deno-import-map.pure.json

@@ -0,0 +1,9 @@
+{
+  "imports": {
+    "node:test": "../src/node.js",
+    "@jest/globals": "../src/jest.js",
+    "tape": "../src/tape.js",
+    "tape-promise/tape": "../src/tape.js",
+    "micro-should": "../src/jest.js"
+  }
+}

package/loader/node-test.js

@@ -12,3 +12,5 @@ Object.assign(testActual, test)
 const nodeModule = require('node:module')
 const syncBuiltinESMExports = nodeModule.syncBuiltinESMExports || nodeModule.syncBuiltinExports // old bun has it under a different name
 if (syncBuiltinESMExports) syncBuiltinESMExports()
+
+require('./remap.cjs')

package/loader/remap.cjs

@@ -0,0 +1,26 @@
+const nodeModule = require('node:module')
+const { pathToFileURL } = require('node:url')
+
+const remap = new Map(Object.entries(require('./deno-import-map.json').imports))
+const resolveFile = (f) => require.resolve(f.endsWith('tape.js') ? `${f.slice(0, -2)}cjs` : f)
+
+function resolve(specifier, context, nextResolve) {
+  if (!remap.has(specifier)) return nextResolve(specifier)
+  return { url: pathToFileURL(resolveFile(remap.get(specifier))).toString(), shortCircuit: true }
+}
+
+if (nodeModule.registerHooks) {
+  nodeModule.registerHooks({ resolve })
+} else if (globalThis.Bun) {
+  const { mock } = require('bun:test')
+  for (const [k, v] of remap) mock.module(k, () => (v.endsWith('jest.js') ? import(v) : require(v)))
+} else {
+  if (nodeModule.register) nodeModule.register('./remap.loader.js', pathToFileURL(__filename))
+  if (nodeModule._resolveFilename) {
+    const { _resolveFilename } = nodeModule
+    nodeModule._resolveFilename = function (request, parent, isMain, options) {
+      if (remap.has(request)) return resolveFile(remap.get(request))
+      return _resolveFilename.call(this, request, parent, isMain, options)
+    }
+  }
+}

package/loader/remap.loader.js

@@ -0,0 +1,9 @@
+// ESM version is the same as for Deno
+import deno from './deno-import-map.json' with { type: 'json' }
+
+const remap = new Map(Object.entries(deno.imports))
+
+export function resolve(specifier, context, nextResolve) {
+  if (!remap.has(specifier)) return nextResolve(specifier)
+  return { url: new URL(remap.get(specifier), import.meta.url).toString(), shortCircuit: true }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.109",
+  "version": "1.0.0-rc.110",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusOSS/test",
@@ -19,21 +19,41 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": "^20.18.0 || >=22.6.0"
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
   },
   "type": "module",
   "bin": {
     "exodus-test": "bin/index.js"
   },
   "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
     "./node-test-reporter": "./bin/reporter.js",
     "./loader/jest": "./loader/jest.js",
-    "./benchmark": "./src/benchmark.js",
-    "./expect": "./src/expect.cjs",
-    "./jest": "./src/jest.js",
-    "./mock": "./src/mock.js",
-    "./node": "./src/node.js",
+    "./benchmark": {
+      "types": "./src/benchmark.d.ts",
+      "default": "./src/benchmark.js"
+    },
+    "./expect": {
+      "types": "./src/expect.d.ts",
+      "default": "./src/expect.cjs"
+    },
+    "./jest": {
+      "types": "./src/jest.d.ts",
+      "default": "./src/jest.js"
+    },
+    "./mock": {
+      "types": "./src/mock.d.ts",
+      "default": "./src/mock.js"
+    },
+    "./node": {
+      "types": "./src/node.d.ts",
+      "default": "./src/node.js"
+    },
     "./tape": {
+      "types": "./src/tape.d.ts",
       "import": "./src/tape.js",
       "require": "./src/tape.cjs"
     }
@@ -49,14 +69,18 @@
     "bin/reporter.js",
     "loader/babel.cjs",
     "loader/deno-import-map.json",
+    "loader/deno-import-map.pure.json",
     "loader/esbuild.js",
     "loader/esbuild.optional.js",
     "loader/flow.js",
     "loader/jest.js",
+    "loader/remap.cjs",
+    "loader/remap.loader.js",
     "loader/node-test.js",
     "loader/typescript.js",
     "loader/typescript.loader.js",
     "src/benchmark.js",
+    "src/benchmark.d.ts",
     "src/dark.cjs",
     "src/engine.js",
     "src/engine.node.cjs",
@@ -65,8 +89,12 @@
     "src/engine.select.cjs",
     "src/exodus.js",
     "src/expect.cjs",
+    "src/expect.d.ts",
     "src/glob.cjs",
+    "src/index.js",
+    "src/index.d.ts",
     "src/jest.js",
+    "src/jest.d.ts",
     "src/jest.config.js",
     "src/jest.config.fs.js",
     "src/jest.environment.js",
@@ -76,10 +104,13 @@
     "src/jest.snapshot.js",
     "src/jest.timers.js",
     "src/mock.js",
+    "src/mock.d.ts",
     "src/node.js",
+    "src/node.d.ts",
     "src/pretty-format.cjs",
     "src/replay.js",
     "src/tape.js",
+    "src/tape.d.ts",
     "src/tape.cjs",
     "src/timers-track.js",
     "src/version.js",
@@ -88,8 +119,7 @@
     "jest.js",
     "mock.js",
     "node.js",
-    "tape.js",
-    "CHANGELOG.md"
+    "tape.js"
   ],
   "scripts": {
     "test:_bundle": "EXODUS_TEST_IGNORE='tests/{{jest-extended,inband}/**,jest-when/when.test.*,jest/jest.resetModules.*,jest/mock/jest.mock.mocks-dir.test.js}' npm run test --",
@@ -124,6 +154,7 @@
     "test:hermes": "EXODUS_TEST_ENGINE=hermes:bundle npm run test:_bundle --",
     "test:shermes": "EXODUS_TEST_ENGINE=shermes:bundle npm run test:_bundle --",
     "test:spidermonkey": "EXODUS_TEST_ENGINE=spidermonkey:bundle npm run test:_bundle --",
+    "test:ladybird-js": "EXODUS_TEST_ENGINE=ladybird-js:bundle npm run test:_bundle --",
     "test:servo": "EXODUS_TEST_ENGINE=servo:bundle npm run test:_bundle --",
     "test:engine262": "EXODUS_TEST_ENGINE=engine262:bundle npm run test:_bundle --",
     "test:quickjs": "EXODUS_TEST_ENGINE=quickjs:bundle npm run test:_bundle --",
@@ -135,6 +166,7 @@
     "test:fetch": "node ./bin/index.js --jest --drop-network --engine node:pure 'tests/replay/*.test.js'",
     "test:jsdom": "EXODUS_TEST_JEST_CONFIG='{\"testMatch\":[\"**/*.jsdom-test.js\"],\"testEnvironment\":\"jsdom\", \"rootDir\": \".\"}' ./bin/index.js --jest",
     "coverage": "node ./bin/index.js --jest --esbuild --coverage",
+    "typedoc": "typedoc && mkdir -p doc/assets && cp -r theme/styles doc/assets/",
     "playwright": "node ./bin/index.js --playwright",
     "esvu": "esvu",
     "jsvu": "jsvu",
@@ -145,14 +177,14 @@
   "optionalDependencies": {
     "@chalker/queue": "^1.0.1",
     "@exodus/replay": "^1.0.0-rc.9",
-    "@exodus/test-bundler": "1.0.0-rc.10",
+    "@exodus/test-bundler": "1.0.0-rc.11",
     "c8": "^9.1.0",
     "expect": "^30.2.0",
     "fast-glob": "^3.2.11",
     "playwright-core": "^1.52.0",
     "pretty-format": "^30.2.0",
     "puppeteer-core": "^24.14.0",
-    "tsx": "^4.20.6"
+    "tsx": "^4.21.0"
   },
   "devDependencies": {
     "@exodus/eslint-config": "^5.24.0",
@@ -161,7 +193,7 @@
     "@types/jest-when": "^3.5.2",
     "@types/node": "^24.0.11",
     "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "electron": "^37.3.1",
+    "electron": "^38.7.0",
     "eslint": "^8.44.0",
     "esvu": "^1.2.16",
     "jest": "^29.7.0",
@@ -170,9 +202,10 @@
     "jest-serializer-ansi-escapes": "^3.0.0",
     "jest-when": "^3.6.0",
     "jsdom": "^26.1.0",
-    "jsvu": "^3.0.0",
+    "jsvu": "^3.0.3",
     "prettier": "^3.0.3",
-    "workerd": "^1.20250826.0"
+    "typedoc": "^0.28.16",
+    "workerd": "^1.20251217.0"
   },
   "peerDependencies": {
     "@babel/register": "^7.0.0",

package/src/benchmark.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark utilities for performance testing
+ *
+ * ```js
+ * import { benchmark } from '@exodus/test/benchmark'
+ * ```
+ *
+ * Can be used with or without `@exodus/test` test runner.
+ * @module @exodus/test/benchmark
+ */
+
+/**
+ * Benchmark options
+ * @inline
+ */
+export interface BenchmarkOptions {
+  /** Array of arguments to pass to the benchmark function */
+  args?: any[]
+  /** Timeout in milliseconds (default: 1000) */
+  timeout?: number
+  /** Skip this benchmark */
+  skip?: boolean
+}
+
+/**
+ * Runs a benchmark
+ * @param name - Name of the benchmark
+ * @param options - Benchmark options
+ * @param fn - Function to benchmark
+ */
+export declare function benchmark<A>(
+  name: string,
+  options: BenchmarkOptions & { args: A[] },
+  fn: (arg: A) => any | Promise<any>
+): Promise<void>
+export declare function benchmark(
+  name: string,
+  options: BenchmarkOptions & { args?: undefined },
+  fn: (arg: number) => any | Promise<any>
+): Promise<void>

package/src/engine.pure.cjs

@@ -137,9 +137,10 @@ async function runContext(context) {
     const guard = { id: null, failed: false }
     const timeout = options.timeout || Number(process.env.EXODUS_TEST_TIMEOUT) || 5000
     guard.promise = new Promise((resolve) => {
-      if (process.env.EXODUS_TEST_PLATFORM === 'engine262') {
+      if (['engine262', 'ladybird-js'].includes(process.env.EXODUS_TEST_PLATFORM)) {
         // parallel timeouts are slowing down everything on engine262
         // so we let only the host timeout to catch us, not individual test timeout
+        // ladybird-js has no timers but has a maximium promise chain length, so it breaks
         return
       }
 

package/src/expect.d.ts

@@ -0,0 +1,29 @@
+/**
+ * [Jest Expect](https://jestjs.io/docs/expect)-compatible API, but much faster
+ *
+ * If you are using Jest globals, you don't have to import this manually.
+ *
+ * Just run `@exodus/test` with `--jest` flag and use global `expect`.
+ *
+ * See [Jest Expect documentation](https://jestjs.io/docs/expect).
+ *
+ * If you want to import it directly:
+ * ```js
+ * import { expect } from '@exodus/test/expect'
+ * ```
+ *
+ * This short-cuts most common cases and tries to avoid loading `expect` altogether,
+ * but for everything that can't be bypassed (e.g. test failures) it uses real `expect`.
+ *
+ * Everything including output formatting matches Jest `expect`.
+ * @module @exodus/test/expect
+ */
+
+export type { Expect } from 'expect'
+export declare const expect: import('expect').Expect
+
+/**
+ * Load the expect library (for internal use)
+ * @internal
+ */
+export declare function loadExpect(reason?: string): import('expect').Expect

package/src/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ### The `@exodus/test` package consists of submodules, there is no single export.
+ * Import specific submodules instead.
+ *
+ * Straightforward setups:
+ * 1. Import `node:test` and run with `@exodus/test`
+ * 2. Use jest globals and run with `@exodus/test --jest`
+ * 3. Import `@exodus/test/tape` instead of tape or tap and run with `@exodus/test` (or `node`)
+ *
+ * See [README](https://github.com/ExodusOSS/test/blob/main/README.md).
+ */
+declare module '@exodus/test' {}

package/src/index.js

@@ -0,0 +1,11 @@
+throw new Error(
+  `This package consists of submodules, there is no single export. Import specific submodules instead.
+
+Straightforward setups:
+  1. Import node:test and run with @exodus/test
+  2. Use jest globals and run with @exodus/test --jest
+  3. Import @exodus/test/tape instead of tape or tap and run with @exodus/test (or node)
+
+See README: https://github.com/ExodusOSS/test/blob/main/README.md
+`
+)

package/src/jest.d.ts

@@ -0,0 +1,28 @@
+/**
+ * [Jest](https://jestjs.io/)-compatible API, but much faster, ESM friendly, and based on `node:test`
+ *
+ * You likely don't have to import this manually.
+ *
+ * Just run `@exodus/test` with `--jest` flag.
+ *
+ * See [Jest API documentation](https://jestjs.io/docs/api).
+ *
+ * If you want to run Jest test files with just `node` (or without `--jest` flag), do e.g.:
+ * ```js
+ * import { describe, test, expect, jest } from '@exodus/test/jest'
+ * import { beforeEach, afterEach, beforeAll, afterAll } from '@exodus/test/jest'
+ * ```
+ * @module @exodus/test/jest
+ */
+
+// Re-export Jest types from @jest/globals
+export { describe, test, it, jest, beforeEach, afterEach, beforeAll, afterAll } from '@jest/globals'
+export type { expect, Expect } from './expect.d.ts'
+
+/**
+ * Alias for test()
+ *
+ * For using the resolution as a drop-in replacement for libs expecting `should()`
+ * @hidden
+ */
+export declare function should(name: string, fn: () => void | Promise<void>, timeout?: number): void

package/src/jest.environment.js

@@ -13,7 +13,8 @@ export const specialEnvironments = {
         runScripts: 'dangerously',
         virtualConsole,
       })
-      virtualConsole.sendTo(console, { omitJSDOMErrors: true })
+      const forwardTo = virtualConsole.forwardTo ? 'forwardTo' : 'sendTo'
+      virtualConsole[forwardTo](console, { omitJSDOMErrors: true })
       virtualConsole.on('jsdomError', (error) => {
         throw error
       })

package/src/mock.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Extra mocking and testing utilities
+ *
+ * - Record / replay / inspect `fetch()` sessions
+ * - Record / replay / inspect `WebSocket` sessions
+ * - Speed up timers
+ * - Debug (or assert no) active timers
+ * @module @exodus/test/mock
+ */
+
+/// <reference types="node" />
+
+/**
+ * Network replay utilities
+ */
+
+/** Records fetch calls and returns a fetch function */
+export declare function fetchRecord(options?: any): typeof fetch
+
+/** Replays fetch calls from recording and returns a fetch function */
+export declare function fetchReplay(): typeof fetch
+
+/** Records WebSocket calls and returns a WebSocket constructor */
+export declare function websocketRecord(options?: any): typeof WebSocket
+
+/** Replays WebSocket calls from recording and returns a WebSocket constructor */
+export declare function websocketReplay(options?: any): typeof WebSocket
+
+/**
+ * Timer tracking and debugging utilities
+ */
+
+/** Enables timer tracking */
+export declare function timersTrack(): void
+
+/** Outputs debug information about active timers */
+export declare function timersDebug(): void
+
+/** Lists all active timers */
+export declare function timersList(): any[]
+
+/** Asserts no timers are active */
+export declare function timersAssert(): void
+
+/**
+ * Speeds up timers by the given rate
+ * @param rate - Speed multiplier (e.g., 2 means 2x faster)
+ * @param options - Configuration options
+ * @param options.apis - Array of APIs to speed up (default: ['setTimeout', 'setInterval', 'Date'])
+ */
+export declare function timersSpeedup(
+  rate: number,
+  options?: { apis?: ('setTimeout' | 'setInterval' | 'Date')[] }
+): void

package/src/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * [node:test](https://nodejs.org/api/test.html)-compatible API
+ *
+ * You most likely don't have to import this manually, just use `node:test`.
+ *
+ * Example:
+ * ```js
+ * import { test, describe } from 'node:test'
+ * ```
+ *
+ * This import is what `@exodus/test` will resolve that to on non-Node.js engines,
+ * e.g. browsers and barebones.
+ *
+ * See [node:test documentation](https://nodejs.org/api/test.html).
+ * @module @exodus/test/node
+ */
+
+/// <reference types="node" />
+
+// Re-export from node:test module
+export { describe, test, it, beforeEach, afterEach, before, after, mock, snapshot } from 'node:test'

package/src/node.js

@@ -7,4 +7,4 @@ function setResolveSnapshotPath() {
 
 export const snapshot = { setDefaultSnapshotSerializers, setResolveSnapshotPath }
 
-export { mock, describe, test, beforeEach, afterEach, before, after } from './engine.js'
+export { mock, describe, test, beforeEach, afterEach, before, after, test as it } from './engine.js'

package/src/tape.cjs

@@ -9,6 +9,7 @@ const loadLib = async () => {
 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.onFinish = async (...args) => (await loadLib()).test.onFinish(...args)
 test.test = test
 /* eslint-enable unicorn/no-await-expression-member */
 

package/src/tape.d.ts

@@ -0,0 +1,166 @@
+/**
+ * [tape](https://npmjs.com/package/tape)-compatible API
+ *
+ * Replace your `tape` imports with `@exodus/test/tape` and it will run on top of `node:test`.
+ *
+ * And will be runnable in browsers / barebone engines with `@exodus/test`.
+ *
+ * Example:
+ * ```js
+ * import test from '@exodus/test/tape' // ESM
+ * const test = require('@exodus/test/tape') // CJS
+ * ```
+ * @module @exodus/test/tape
+ */
+
+/// <reference types="node" />
+
+/**
+ * Tape test context/assertion object
+ */
+export interface Test {
+  /** Plans the number of assertions */
+  plan(count: number): void
+
+  /** Ends the test */
+  end(): void
+
+  /** Skips the test */
+  skip(msg?: string): void
+
+  /** Marks test as todo */
+  todo(msg?: string): void
+
+  /** Adds a comment */
+  comment(msg: string): void
+
+  /** Nested test */
+  test(name: string, cb: (t: Test) => void): void
+  test(name: string, opts: TestOptions, cb: (t: Test) => void): void
+
+  /** Assertions */
+
+  /** Assert that value is truthy */
+  ok(value: any, msg?: string): void
+  true(value: any, msg?: string): void
+  assert(value: any, msg?: string): void
+
+  /** Assert that value is falsy */
+  notOk(value: any, msg?: string): void
+  false(value: any, msg?: string): void
+  notok(value: any, msg?: string): void
+
+  /** Assert strict equality */
+  equal(actual: any, expected: any, msg?: string): void
+  equals(actual: any, expected: any, msg?: string): void
+  isEqual(actual: any, expected: any, msg?: string): void
+  is(actual: any, expected: any, msg?: string): void
+  strictEqual(actual: any, expected: any, msg?: string): void
+  strictEquals(actual: any, expected: any, msg?: string): void
+
+  /** Assert strict inequality */
+  notEqual(actual: any, expected: any, msg?: string): void
+  notEquals(actual: any, expected: any, msg?: string): void
+  notStrictEqual(actual: any, expected: any, msg?: string): void
+  notStrictEquals(actual: any, expected: any, msg?: string): void
+  doesNotEqual(actual: any, expected: any, msg?: string): void
+  isNotEqual(actual: any, expected: any, msg?: string): void
+  isNot(actual: any, expected: any, msg?: string): void
+  not(actual: any, expected: any, msg?: string): void
+  isInequal(actual: any, expected: any, msg?: string): void
+
+  /** Assert loose equality */
+  looseEqual(actual: any, expected: any, msg?: string): void
+  looseEquals(actual: any, expected: any, msg?: string): void
+
+  /** Assert loose inequality */
+  notLooseEqual(actual: any, expected: any, msg?: string): void
+  notLooseEquals(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep strict equality */
+  deepEqual(actual: any, expected: any, msg?: string): void
+  deepEquals(actual: any, expected: any, msg?: string): void
+  isEquivalent(actual: any, expected: any, msg?: string): void
+  same(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep strict inequality */
+  notDeepEqual(actual: any, expected: any, msg?: string): void
+  notDeepEquals(actual: any, expected: any, msg?: string): void
+  notEquivalent(actual: any, expected: any, msg?: string): void
+  notDeeply(actual: any, expected: any, msg?: string): void
+  notSame(actual: any, expected: any, msg?: string): void
+  isNotDeepEqual(actual: any, expected: any, msg?: string): void
+  isNotDeeply(actual: any, expected: any, msg?: string): void
+  isNotEquivalent(actual: any, expected: any, msg?: string): void
+  isInequivalent(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep loose equality */
+  deepLooseEqual(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep loose inequality */
+  notDeepLooseEqual(actual: any, expected: any, msg?: string): void
+
+  /** Assert function throws */
+  throws(fn: () => any, expected?: RegExp | Function, msg?: string): void
+
+  /** Assert function does not throw */
+  doesNotThrow(fn: () => any, expected?: RegExp | Function, msg?: string): void
+
+  /** Assert promise rejects */
+  rejects(promise: Promise<any>, expected?: RegExp | Function, msg?: string): Promise<void>
+
+  /** Assert promise resolves */
+  resolves(promise: Promise<any>, msg?: string): Promise<void>
+  doesNotReject(promise: Promise<any>, expected?: RegExp | Function, msg?: string): Promise<void>
+
+  /** Force a passing assertion */
+  pass(msg?: string): void
+
+  /** Force a failing assertion */
+  fail(msg?: string): void
+
+  /** Assert no error */
+  error(err: any, msg?: string): void
+  ifError(err: any, msg?: string): void
+  ifErr(err: any, msg?: string): void
+  iferror(err: any, msg?: string): void
+
+  /** Custom assertion function */
+  assertion(fn: Function, ...args: any[]): void
+}
+
+/**
+ * Test options
+ */
+export interface TestOptions {
+  skip?: boolean
+  todo?: boolean
+  timeout?: number
+  concurrency?: number
+}
+
+/**
+ * Test function
+ */
+export interface TestFunction {
+  /** Run a test */
+  (name: string, cb: (t: Test) => void): void
+  (name: string, opts: TestOptions, cb: (t: Test) => void): void
+  (cb: (t: Test) => void): void
+  (opts: TestOptions, cb: (t: Test) => void): void
+
+  /** Only run this test */
+  only: TestFunction
+
+  /** Skip this test */
+  skip: TestFunction
+
+  /** Register a callback to run after all tests finish */
+  onFinish(fn: () => void): void
+}
+
+declare const test: TestFunction
+
+export { test }
+
+export default test

package/src/tape.js

@@ -155,6 +155,7 @@ function tapeWrap(test) {
   if (test.skip) tap.skip = tapeWrap(test.skip)
   if (test.only) tap.only = tapeWrap(test.only)
   tap.onFinish = (fn) => after(fn)
+  tap.test = tap // circular
   return tap
 }
 

package/tape.js

@@ -1 +1,2 @@
 export * from './src/tape.js'
+export { default } from './src/tape.js'

package/CHANGELOG.md

@@ -1,3 +0,0 @@
-## 1.0.0
-
-Initial release