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

package/README.md

@@ -67,7 +67,7 @@ Use `--engine` (or `EXODUS_TEST_ENGINE=`) to specify one of:
     - `brave:puppeteer` — Brave
     - `msedge:puppeteer` — Microsoft Edge
 - Barebone engines (system-provided or installed with `npx jsvu` / `npx esvu`):
-  - `d8:bundle` — [v8 CLI](https://v8.dev/docs/d8) (Chrome/Blink/Node.js JavaScript engine)
+  - `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)
   - `hermes:bundle` — [Hermes](https://hermesengine.dev) (React Native JavaScript engine)
   - `spidermonkey:bundle` — [SpiderMonkey](https://spidermonkey.dev/) (Firefox/Gecko JavaScript engine)

package/bin/find-binary.js

@@ -65,6 +65,8 @@ function findBinaryOnce(name) {
       return findFile([jsvu, esvu], false)
     case 'electron':
       return require('electron')
+    case 'workerd':
+      return require.resolve('workerd/bin/workerd')
     case 'c8':
       return require.resolve('c8/bin/c8.js')
     case 'chrome':

package/bin/index.js

@@ -21,23 +21,25 @@ const bundleOpts = { pure: true, bundle: true, esbuild: true, ts: 'auto' }
 const bareboneOpts = { ...bundleOpts, barebone: true }
 const hermesA = ['-Og', '-Xmicrotask-queue']
 const denoA = ['run', '--allow-all'] // also will set DENO_COMPAT=1 env flag below
+const denoT = ['test', '--allow-all']
+const nodeTS = process.features.typescript ? 'auto' : 'flag'
 const ENGINES = new Map(
   Object.entries({
-    'node:test': { binary: 'node', pure: false, loader: '--import', ts: 'flag', haveIsOk: true },
-    'node:pure': { binary: 'node', pure: true, loader: '--import', ts: 'flag', haveIsOk: true },
-    'node:bundle': { binary: 'node', ...bundleOpts },
+    'node:test': { binary: 'node', loader: '--import', ts: nodeTS, haveIsOk: true },
+    'node:pure': { binary: 'node', pure: true, loader: '--import', ts: nodeTS, haveIsOk: true },
+    'node:bundle': { binary: 'node', binaryArgs: ['--expose-gc'], ...bundleOpts },
     'bun:test': { binary: 'bun', ts: 'auto' },
     'bun:pure': { binary: 'bun', pure: true, ts: 'auto' },
     'bun:bundle': { binary: 'bun', ...bundleOpts },
-    'electron-as-node:test': { binary: 'electron', pure: false, loader: '--import', ts: 'flag' },
+    'electron-as-node:test': { binary: 'electron', loader: '--import', ts: 'flag' },
     'electron-as-node:pure': { binary: 'electron', pure: true, loader: '--import', ts: 'flag' },
-    'electron-as-node:bundle': { binary: 'electron', ...bundleOpts },
+    'electron-as-node:bundle': { binary: 'electron', binaryArgs: ['--expose-gc'], ...bundleOpts },
     'electron:bundle': { binary: 'electron', electron: true, ...bundleOpts },
-    'deno:test': { binary: 'deno', pure: false, loader: '--preload', ts: 'auto' },
+    'deno:test': { binary: 'deno', binaryArgs: denoT, loader: '--preload', ts: 'auto' },
     'deno:pure': { binary: 'deno', binaryArgs: denoA, pure: true, loader: '--preload', ts: 'auto' },
     'deno:bundle': { binary: 'deno', binaryArgs: ['run'], target: 'deno1', ...bundleOpts },
     // Barebone engines
-    'd8:bundle': { binary: 'd8', ...bareboneOpts },
+    'v8:bundle': { binary: 'd8', binaryArgs: ['--expose-gc'], ...bareboneOpts },
     'jsc:bundle': { binary: 'jsc', target: 'safari13', ...bareboneOpts },
     'hermes:bundle': { binary: 'hermes', binaryArgs: hermesA, target: 'es2018', ...bareboneOpts },
     'spidermonkey:bundle': { binary: 'spidermonkey', ...bareboneOpts },
@@ -59,7 +61,7 @@ const ENGINES = new Map(
     'msedge:playwright': { binary: 'msedge', browsers: 'playwright', ...bundleOpts },
   })
 )
-const barebonesOk = ['d8', 'spidermonkey', 'quickjs', 'xs', 'hermes']
+const barebonesOk = ['v8', 'd8', 'spidermonkey', 'quickjs', 'xs', 'hermes']
 const barebonesUnhandled = ['jsc', 'escargot', 'boa', 'graaljs', 'engine262']
 
 const getEnvFlag = (name) => {
@@ -272,6 +274,7 @@ const { options, patterns } = parseOptions()
 
 const engineName = `${options.engine} engine` // used for warnings to user
 const engineFlagError = (flag) => `${engineName} does not support --${flag}`
+if (options.engine === 'd8:bundle') options.engine = 'v8:bundle' // compat
 const engineOptions = ENGINES.get(options.engine)
 assert(engineOptions, `Unknown engine: ${options.engine}`)
 Object.assign(options, engineOptions)
@@ -331,7 +334,6 @@ if (options.pure) {
 
   args.push('--expose-internals') // this is unoptimal and hopefully temporary, see rationale in src/dark.cjs
 } else if (options.engine === 'deno:test') {
-  args.push('test', '--allow-all')
   assert(!options.jest, 'deno:test engine does not support --jest yet')
 } else if (options.engine === 'bun:test') {
   args.push('test')
@@ -340,6 +342,8 @@ if (options.pure) {
   throw new Error('Unreachable')
 }
 
+if (!options.bundle && ['node', 'electron'].includes(options.platform)) args.push('--expose-gc') // for benchmarks
+
 const ignore = ['**/node_modules']
 let filter
 if (process.env.EXODUS_TEST_IGNORE) {
@@ -421,13 +425,16 @@ if (options.jest) {
   }
 }
 
+const cpus = availableParallelism()
+// increase from default cpus - 1 on default GH CI runners, but not on browsers which already use other processes
+if (!options.concurrency && isCI && !isBrowserLike && cpus === 2) options.concurrency = cpus
 if (options.concurrency) {
   const raw = options.concurrency
   let concurrency = raw
   if (typeof raw === 'string') {
     if (/^\d{1,15}%$/u.test(raw)) {
       const perc = Number(raw.slice(0, -1))
-      concurrency = Math.max(1, Math.round((perc * availableParallelism()) / 100))
+      concurrency = Math.max(1, Math.round((perc * cpus) / 100))
     } else {
       assert(/^\d{1,15}$/u.test(raw), `Wrong concurrency: ${raw}`)
       concurrency = Number(raw)
@@ -591,7 +598,7 @@ if (options.binary === 'electron') {
   }
 }
 
-if (options.barebone || options.binary === 'electron') {
+if (options.barebone || ['electron', 'workerd'].includes(options.binary)) {
   options.binary = findBinary(options.binary)
   options.binaryCanBeAbsolute = true
 }
@@ -648,7 +655,7 @@ async function launch(binary, args, opts = {}, buffering = false) {
   }
 
   const barebones = [...barebonesOk, ...barebonesUnhandled]
-  assertBinary(binary, ['node', 'bun', 'deno', 'electron', ...barebones, 'v8']) // v8 is an alias to d8
+  assertBinary(binary, ['node', 'bun', 'deno', 'electron', 'workerd', ...barebones])
   if (binary === c8 && process.platform === 'win32') {
     ;[binary, args] = ['node', [binary, ...args]]
   }
@@ -690,13 +697,12 @@ if (options.pure) {
 
     const failedBare = 'EXODUS_TEST_FAILED_EXIT_CODE_1'
     const cleanOut = (out) => out.replaceAll(`\n${failedBare}\n`, '\n').replaceAll(failedBare, '')
-    const { binaryArgs = [] } = options
     // 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
     const start = process.hrtime.bigint()
     try {
-      const fullArgs = [...binaryArgs, ...args, file]
+      const fullArgs = [...(options.binaryArgs ?? []), ...args, file]
       const { code = 0, stdout, stderr } = await launch(options.binary, fullArgs, { timeout }, true)
       const ms = Number(process.hrtime.bigint() - start) / 1e6
       if (stdout.includes(failedBare)) return { ok: false, output: [cleanOut(stdout), stderr], ms }
@@ -722,7 +728,7 @@ if (options.pure) {
   }
 
   const { Queue } = await import('@chalker/queue')
-  const queue = new Queue(options.concurrency || availableParallelism() - 1)
+  const queue = new Queue(options.concurrency || cpus - 1)
   const runConcurrent = async (file) => {
     await queue.claim()
     try {
@@ -758,7 +764,6 @@ if (options.pure) {
   assert(['node:test', 'electron-as-node:test', 'deno:test', 'bun:test'].includes(options.engine))
   setEnv('EXODUS_TEST_CONTEXT', 'node:test') // The context is always node:test in this branch
   assert(files.length > 0) // otherwise we can run recursively
-  assert(!options.binaryArgs)
   if (options.concurrency) args.push('--test-concurrency', options.concurrency)
   if (['--inspect', '--inspect-brk', '--inspect-wait'].includes(options.devtools)) {
     args.push(options.devtools)
@@ -770,7 +775,7 @@ if (options.pure) {
     )
   }
 
-  const { code } = await launch(options.binary, [...args, ...files])
+  const { code } = await launch(options.binary, [...(options.binaryArgs ?? []), ...args, ...files])
   process.exitCode = code
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.102",
+  "version": "1.0.0-rc.104",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -28,6 +28,7 @@
   "exports": {
     "./node-test-reporter": "./bin/reporter.js",
     "./loader/jest": "./loader/jest.js",
+    "./benchmark": "./src/benchmark.js",
     "./expect": "./src/expect.cjs",
     "./jest": "./src/jest.js",
     "./node": "./src/node.js",
@@ -54,6 +55,7 @@
     "loader/node-test.js",
     "loader/typescript.js",
     "loader/typescript.loader.js",
+    "src/benchmark.js",
     "src/dark.cjs",
     "src/engine.js",
     "src/engine.node.cjs",
@@ -112,9 +114,8 @@
     "test:chromium:playwright": "EXODUS_TEST_ENGINE=chromium:playwright npm run test:_bundle --",
     "test:firefox:playwright": "EXODUS_TEST_ENGINE=firefox:playwright npm run test:_bundle --",
     "test:webkit:playwright": "EXODUS_TEST_ENGINE=webkit:playwright npm run test:_bundle --",
-    "test:v8": "npm run test:d8 --",
     "test:javascriptcore": "npm run test:jsc --",
-    "test:d8": "EXODUS_TEST_ENGINE=d8:bundle npm run test:_bundle --",
+    "test:v8": "EXODUS_TEST_ENGINE=v8:bundle npm run test:_bundle --",
     "test:jsc": "EXODUS_TEST_ENGINE=jsc:bundle npm run test:_bundle --",
     "test:hermes": "EXODUS_TEST_ENGINE=hermes:bundle npm run test:_bundle --",
     "test:spidermonkey": "EXODUS_TEST_ENGINE=spidermonkey:bundle npm run test:_bundle --",
@@ -154,7 +155,7 @@
     "@types/jest-when": "^3.5.2",
     "@types/node": "^24.0.11",
     "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "electron": "^35.2.2",
+    "electron": "^37.3.1",
     "eslint": "^8.44.0",
     "esvu": "^1.2.16",
     "jest": "^29.7.0",
@@ -163,7 +164,8 @@
     "jest-when": "^3.6.0",
     "jsdom": "^26.1.0",
     "jsvu": "^3.0.0",
-    "prettier": "^3.0.3"
+    "prettier": "^3.0.3",
+    "workerd": "^1.20250826.0"
   },
   "peerDependencies": {
     "@babel/register": "^7.0.0",

package/src/benchmark.js

@@ -0,0 +1,54 @@
+const fRps = (rps) => (rps > 10 ? Math.round(rps).toLocaleString() : rps.toPrecision(2))
+const fTime = (ns) => {
+  const us = ns / 10n ** 3n
+  if (us < 2n) return `${ns}ns`
+  const ms = us / 10n ** 3n
+  if (ms < 2n) return `${us}μs`
+  const s = ms / 10n ** 3n
+  if (s < 10n) return `${ms}ms`
+  const min = s / 60n
+  return min < 5n ? `${s}s` : `${min}min`
+}
+
+const getTime = (() => {
+  if (globalThis.process) return () => process.hrtime.bigint()
+  if (globalThis.performance) return () => BigInt(Math.round(performance.now() * 1e6))
+  return () => BigInt(Math.round(Date.now() * 1e6))
+})()
+
+let gcWarned = false
+export async function benchmark(name, options, fn) {
+  if (typeof options === 'function') [fn, options] = [options, undefined]
+  if (options?.skip) return
+  const { args, timeout = 1000 } = options ?? {}
+
+  if (globalThis.gc) {
+    for (let i = 0; i < 4; i++) globalThis.gc()
+  } else if (!gcWarned) {
+    gcWarned = true
+    console.log('Warning: no gc() available\n')
+  }
+
+  let min, max
+  let total = 0n
+  let count = 0
+  while (true) {
+    const arg = args ? args[count % args.length] : count
+    count++
+    const start = getTime()
+    const val = fn(arg)
+    if (val instanceof Promise) await val
+    const stop = getTime()
+    const diff = stop - start
+    total += diff
+    if (min === undefined || min > diff) min = diff
+    if (max === undefined || max < diff) max = diff
+    if (total >= BigInt(timeout)) break
+  }
+
+  const mean = total / BigInt(count)
+  const rps = 1e9 / Number(mean)
+  console.log(`${name} x ${fRps(rps)} ops/sec @ ${fTime(mean)}/op (${fTime(min)}..${fTime(max)})`)
+
+  if (globalThis.gc) for (let i = 0; i < 4; i++) globalThis.gc()
+}