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

package/bin/browsers.js

@@ -29,7 +29,7 @@ export const close = () => Promise.all(Object.values(launched).map((p) => p.then
 
 async function newPage(runner, browser, { binary, dropNetwork }) {
   const context = await (browser.newContext ? browser.newContext() : browser.createBrowserContext())
-  if (dropNetwork && context.setOffline) await context.setOffline(true)
+  if (dropNetwork && context.setOffline && binary !== 'webkit') await context.setOffline(true) // WebKit crashes if this is done prior to navigation to /dev/null
   let page
   try {
     page = await context.newPage()
@@ -40,6 +40,9 @@ async function newPage(runner, browser, { binary, dropNetwork }) {
     return newPage(runner, browser, { binary, dropNetwork })
   }
 
+  await page.goto('file:///dev/null') // Need to load a secure origin for e.g. crypto.subtle to be available
+
+  if (dropNetwork && context.setOffline) await context.setOffline(true)
   if (dropNetwork && page.setOfflineMode) await page.setOfflineMode(true)
   assert(!dropNetwork || context.setOffline || page.setOfflineMode)
   return { context, page }
@@ -55,7 +58,6 @@ export async function run(runner, args, { binary, devtools, dropNetwork, timeout
   assert(Object.hasOwn(launchers, runner), 'Unexpected runner')
   if (!launched[runner]) launched[runner] = launchers[runner]({ binary, devtools })
   const { page, context } = await newPage(runner, await launched[runner], { binary, dropNetwork })
-  await page.goto('file:///dev/null') // Need to load a secure origin for e.g. crypto.subtle to be available
 
   page.on('console', (message) => {
     const type = message.type()

package/bin/index.js

@@ -21,28 +21,29 @@ import * as browsers from './browsers.js'
 const bindir = dirname(fileURLToPath(import.meta.url))
 const DEFAULT_PATTERNS = [`**/?(*.)+(spec|test).?([cm])[jt]s?(x)`] // do not trust magic dirs by default
 
-const bundleOptions = { pure: true, bundle: true, esbuild: true, ts: 'auto' }
+const bundleOpts = { pure: true, bundle: true, esbuild: true, ts: 'auto' }
+const bareboneOpts = { ...bundleOpts, barebone: true }
 const hermesAv = ['-Og', '-Xmicrotask-queue']
 const ENGINES = new Map(
   Object.entries({
     'node:test': { binary: 'node', pure: false, hasImportLoader: true, ts: 'flag', haveIsOk: true },
     'node:pure': { binary: 'node', pure: true, hasImportLoader: true, ts: 'flag', haveIsOk: true },
-    'node:bundle': { binary: 'node', ...bundleOptions },
+    'node:bundle': { binary: 'node', ...bundleOpts },
     'bun:pure': { binary: 'bun', pure: true, hasImportLoader: false, ts: 'auto' },
-    'bun:bundle': { binary: 'bun', ...bundleOptions },
+    'bun:bundle': { binary: 'bun', ...bundleOpts },
     'electron-as-node:test': { binary: 'electron', pure: false, hasImportLoader: true, ts: 'flag' },
     'electron-as-node:pure': { binary: 'electron', pure: true, hasImportLoader: true, ts: 'flag' },
-    'electron-as-node:bundle': { binary: 'electron', ...bundleOptions },
-    'deno:bundle': { binary: 'deno', binaryArgs: ['run'], target: 'deno1', ...bundleOptions },
-    'd8:bundle': { binary: 'd8', ...bundleOptions },
-    'jsc:bundle': { binary: 'jsc', ...bundleOptions, target: 'safari13' },
-    'hermes:bundle': { binary: 'hermes', binaryArgs: hermesAv, target: 'es2018', ...bundleOptions },
+    'electron-as-node:bundle': { binary: 'electron', ...bundleOpts },
+    'deno:bundle': { binary: 'deno', binaryArgs: ['run'], target: 'deno1', ...bundleOpts },
+    'd8:bundle': { binary: 'd8', ...bareboneOpts },
+    'jsc:bundle': { binary: 'jsc', target: 'safari13', ...bareboneOpts },
+    'hermes:bundle': { binary: 'hermes', binaryArgs: hermesAv, target: 'es2018', ...bareboneOpts },
     // Browser engines
-    'chrome:puppeteer': { binary: 'chrome', browsers: 'puppeteer', ...bundleOptions },
-    'chromium:playwright': { binary: 'chromium', browsers: 'playwright', ...bundleOptions },
-    'firefox:puppeteer': { binary: 'firefox', browsers: 'puppeteer', ...bundleOptions },
-    'firefox:playwright': { binary: 'firefox', browsers: 'playwright', ...bundleOptions },
-    'webkit:playwright': { binary: 'webkit', browsers: 'playwright', ...bundleOptions },
+    'chrome:puppeteer': { binary: 'chrome', browsers: 'puppeteer', ...bundleOpts },
+    'chromium:playwright': { binary: 'chromium', browsers: 'playwright', ...bundleOpts },
+    'firefox:puppeteer': { binary: 'firefox', browsers: 'puppeteer', ...bundleOpts },
+    'firefox:playwright': { binary: 'firefox', browsers: 'playwright', ...bundleOpts },
+    'webkit:playwright': { binary: 'webkit', browsers: 'playwright', ...bundleOpts },
   })
 )
 
@@ -239,6 +240,8 @@ setEnv('EXODUS_TEST_ENGINE', options.engine) // e.g. 'hermes:bundle', 'node:bund
 setEnv('EXODUS_TEST_PLATFORM', options.binary) // e.g. 'hermes', 'node'
 setEnv('EXODUS_TEST_TIMEOUT', options.testTimeout)
 setEnv('EXODUS_TEST_IS_BROWSER', options.browsers ? '1' : '')
+setEnv('EXODUS_TEST_IS_BAREBONE', options.barebone ? '1' : '')
+setEnv('EXODUS_TEST_ENVIRONMENT', options.bundle ? 'bundle' : '') // perhaps switch to _IS_BUNDLED?
 
 assert(!options.devtools || options.browsers, '--devtools can be only used with browser engines')
 
@@ -312,7 +315,9 @@ if (options.jest) {
   const { loadJestConfig } = await import('../src/jest.config.js')
   const config = await loadJestConfig(process.cwd())
   jestConfig = config
-  if (!options.bundle) {
+  if (options.bundle) {
+    setEnv('EXODUS_TEST_JEST_CONFIG', JSON.stringify(jestConfig))
+  } else {
     args.push(options.hasImportLoader ? '--import' : '-r', resolve(bindir, 'jest.js'))
   }
 

package/bin/reporter.js

@@ -27,6 +27,7 @@ export const format = (chunk) => {
   return chunk
     .replaceAll(/^✔ PASS /gmu, color('✔ PASS ', 'green'))
     .replaceAll(/^⏭ SKIP /gmu, color('⏭ SKIP ', dim))
+    .replaceAll(/^ℹ DIAGNOSTIC /gmu, color('ℹ DIAGNOSTIC ', 'blue'))
     .replaceAll(/^✖ FAIL /gmu, color('✖ FAIL ', 'red'))
     .replaceAll(/^⚠ WARN /gmu, color('⚠ WARN ', 'blue'))
     .replaceAll(/^‼ FATAL /gmu, `${color('‼', 'red')} ${color(' FATAL ', 'bgRed')} `)

package/bundler/bundle.js

@@ -1,8 +1,8 @@
 import assert from 'node:assert/strict'
-import { readFile } from 'node:fs/promises'
+import { readFile, readdir } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { basename, dirname, extname, resolve, join } from 'node:path'
+import { basename, dirname, extname, resolve, join, relative } from 'node:path'
 import { createRequire } from 'node:module'
 import { randomUUID as uuid, randomBytes } from 'node:crypto'
 import * as esbuild from 'esbuild'
@@ -68,7 +68,6 @@ export const init = async ({ platform, jest, flow, target, jestConfig, outdir, e
   }
 }
 
-const barebone = new Set(['hermes', 'jsc', 'd8'])
 const hermesSupported = {
   arrow: false,
   class: false, // we get a safeguard check this way that it's not used
@@ -111,7 +110,11 @@ const loadSourceFileBase = async (filepath) => {
 }
 
 export const build = async (...files) => {
-  const specificLoadPipeline = []
+  const envOverride = { FORCE_COLOR: '0', NO_COLOR: '1' }
+  const getEnv = (key) => (Object.hasOwn(envOverride, key) ? envOverride[key] : process.env[key]) // We know key is safe as it comes from regex below
+  const specificLoadPipeline = [
+    (src) => src.replace(/\b(?:process\.env\.([A-Z0-9_]+))\b/gu, (_, x) => stringify(getEnv(x))),
+  ]
   const loadSourceFile = async (filepath) => {
     let contents = await loadSourceFileBase(filepath)
     for (const transform of specificLoadPipeline) contents = await transform(contents, filepath)
@@ -124,7 +127,7 @@ export const build = async (...files) => {
   const stringify = (x) => ([undefined, null].includes(x) ? `${x}` : JSON.stringify(x))
 
   if (!['node', 'electron'].includes(options.platform)) {
-    if (barebone.has(options.platform)) {
+    if (process.env.EXODUS_TEST_IS_BAREBONE) {
       const entropy = randomBytes(options.entropySize ?? 5 * 1024).toString('base64')
       input.push(`globalThis.EXODUS_TEST_CRYPTO_ENTROPY = ${stringify(entropy)};`)
     }
@@ -168,7 +171,7 @@ export const build = async (...files) => {
   const buildWrap = async (opts) => esbuild.build(opts).catch((err) => err)
   let main = input.join(';\n')
   const exit = `EXODUS_TEST_PROCESS.exitCode = 1; EXODUS_TEST_PROCESS._maybeProcessExitCode();`
-  if (barebone.has(options.platform)) {
+  if (process.env.EXODUS_TEST_IS_BAREBONE) {
     main = `try {\n${main}\n} catch (err) { print(err); ${exit} }`
   } else if (process.env.EXODUS_TEST_IS_BROWSER) {
     main = `try {\n${main}\n} catch (err) { console.error(err); ${exit} }`
@@ -176,23 +179,67 @@ export const build = async (...files) => {
 
   const fsfiles = await getPackageFiles(filename ? dirname(resolve(filename)) : process.cwd())
   const fsFilesContents = new Map()
-  specificLoadPipeline.push(async (source) => {
-    const cwd = process.cwd()
-    for (const re of [/readFileSync\('([^'\\]+)'[),]/gu, /readFileSync\("([^"\\]+)"[),]/gu]) {
-      for (const match of source.matchAll(re)) {
-        let file = match[1]
-        if (file && /^[a-z0-9@_./-]+$/iu.test(file)) {
-          file = resolve(file)
-          if (!file.startsWith(`${cwd}/`)) continue
-          const data = await readFile(file, 'base64')
-          if (fsFilesContents.has(file)) {
-            assert(fsFilesContents.get(file) === data)
-          } else {
-            fsFilesContents.set(file, data)
-          }
-        }
+  const fsFilesDirs = new Map()
+  const cwd = process.cwd()
+  const fixturesRegex = /(fixtures|samples)/u
+  const aggressiveExtensions = /\.(json|txt|hex)$/u // These are bundled when just used in path.join and by wildcard from fixtures/
+  const fileAllowed = (f) =>
+    f && f.startsWith(`${cwd}/`) && resolve(f) === f && /^[a-z0-9@_./-]+$/iu.test(relative(cwd, f))
+
+  const fsFilesAdd = async (file) => {
+    if (!fileAllowed(file)) return
+    try {
+      const data = await readFile(file, 'base64')
+      if (fsFilesContents.has(file)) {
+        assert(fsFilesContents.get(file) === data)
+      } else {
+        fsFilesContents.set(file, data)
       }
+    } catch (e) {
+      if (e.code !== 'ENOENT') throw e
     }
+  }
+
+  const fixturesSeen = { fs: false, fixtures: false, bundled: false }
+  const fsFilesBundleFixtures = async (reason) => {
+    if (fixturesSeen.bundled || !filename) return
+    if (reason === 'fs' || reason === 'fixtures') fixturesSeen[reason] = true
+    if (!fixturesSeen.fs || !fixturesSeen.fixtures) return
+    fixturesSeen.bundled = true
+    const dir = dirname(resolve(filename))
+    for (const name of await readdir(dir, { recursive: true })) {
+      const parent = dirname(name)
+      if (!fixturesRegex.test(parent)) continue // relative dir path should look like a fixtures dir
+
+      // Save as directory entry into parent dir
+      const subdir = resolve(dir, parent)
+      if (fileAllowed(subdir)) {
+        if (!fsFilesDirs.has(subdir)) fsFilesDirs.set(subdir, [])
+        fsFilesDirs.get(subdir).push(basename(name))
+      }
+
+      // Save to files
+      const file = resolve(dir, name)
+      if (aggressiveExtensions.test(file)) await fsFilesAdd(file)
+    }
+  }
+
+  specificLoadPipeline.push(async (source, filepath) => {
+    for (const m of source.matchAll(/readFileSync\(\s*(?:"([^"\\]+)"|'([^'\\]+)')[),]/gu)) {
+      await fsFilesAdd(resolve(m[1] || m[2])) // resolves from cwd
+    }
+
+    // E.g. path.join(import.meta.dirname, './fixtures/data.json'), dirname is inlined by loadPipeline already
+    const dir = dirname(filepath)
+    for (const m of source.matchAll(/join\(\s*("[^"\\]+"),\s*(?:"([^"\\]+)"|'([^'\\]+)')\s*\)/gu)) {
+      if (m[1] !== JSON.stringify(dir)) continue // only allow files relative to dirname, from loadPipeline
+      const file = resolve(dir, m[2] || m[3])
+      if (aggressiveExtensions.test(file)) await fsFilesAdd(file) // only bundle path.join for specific extensions used as test fixtures
+    }
+
+    // Both conditions should happen for deep fixtures inclusion
+    if (/(readdir|readFile|exists)Sync/u.test(source)) await fsFilesBundleFixtures('fs')
+    if (fixturesRegex.test(source)) await fsFilesBundleFixtures('fixtures')
 
     return source
   })
@@ -219,11 +266,12 @@ export const build = async (...files) => {
     'fs/promises': api('fs-promises.cjs'),
     http: api('http.cjs'),
     https: api('https.cjs'),
-    os: resolveRequire('os-browserify'),
+    os: resolveRequire('os-browserify/browser.js'), // 'main' entry point is noop, we want browser entry
     path: resolveRequire('path-browserify'),
     querystring: resolveRequire('querystring-es3'),
     stream: resolveRequire('stream-browserify'),
     timers: resolveRequire('timers-browserify'),
+    tty: api('tty.cjs'),
     url: api('url.cjs'),
     util: dirname(resolveRequire('util/')),
     zlib: resolveRequire('browserify-zlib'),
@@ -241,23 +289,6 @@ export const build = async (...files) => {
     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'), // always 'bundle'
-      'process.env.EXODUS_TEST_PLATFORM': stringify(process.env.EXODUS_TEST_PLATFORM), // e.g. 'hermes', 'node'
-      'process.env.EXODUS_TEST_ENGINE': stringify(process.env.EXODUS_TEST_ENGINE), // e.g. 'hermes:bundle', 'node:bundle'
-      'process.env.EXODUS_TEST_IS_BROWSER': stringify(process.env.EXODUS_TEST_IS_BROWSER), // '1' or ''
-      'process.env.EXODUS_TEST_JEST_CONFIG': stringify(JSON.stringify(options.jestConfig)),
-      'process.env.EXODUS_TEST_EXECARGV': stringify(process.env.EXODUS_TEST_EXECARGV),
-      'process.env.EXODUS_TEST_ONLY': stringify(process.env.EXODUS_TEST_ONLY),
-      'process.env.EXODUS_TEST_TIMEOUT': stringify(process.env.EXODUS_TEST_TIMEOUT),
-      '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',
@@ -271,6 +302,7 @@ export const build = async (...files) => {
       EXODUS_TEST_RECORDINGS: stringify(EXODUS_TEST_RECORDINGS),
       EXODUS_TEST_FSFILES: stringify(fsfiles), // TODO: can we safely use relative paths?
       EXODUS_TEST_FSFILES_CONTENTS: stringify([...fsFilesContents.entries()]),
+      EXODUS_TEST_FSDIRS: stringify([...fsFilesDirs.entries()]),
     },
     alias: {
       // Jest, tape and node:test
@@ -295,7 +327,7 @@ export const build = async (...files) => {
       'node-gyp-build': api('empty/function-throw.cjs'),
       ws: api('ws.cjs'),
     },
-    sourcemap: barebone.has(options.platform) ? 'inline' : 'linked', // FIXME?
+    sourcemap: process.env.EXODUS_TEST_IS_BAREBONE ? 'inline' : 'linked', // FIXME?
     sourcesContent: false,
     keepNames: true,
     format: 'iife',
@@ -311,9 +343,8 @@ export const build = async (...files) => {
           onLoad({ filter: /\.[cm]?[jt]sx?$/, 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 (barebone.has(options.platform)) {
+            if (process.env.EXODUS_TEST_IS_BAREBONE) {
               const maybeNative = filepath.replace(/(\.[cm]?[jt]sx?)$/u, '.native$1')
               if (existsSync(maybeNative)) filepath = maybeNative
             }
@@ -340,9 +371,10 @@ export const build = async (...files) => {
   let res = await buildWrap(config)
   assert.equal(res instanceof Error, res.errors.length > 0)
 
-  if (fsFilesContents.size > 0) {
+  if (fsFilesContents.size > 0 || fsFilesDirs.size > 0) {
     // re-run as we detected that tests depend on fsReadFileSync contents
     config.define.EXODUS_TEST_FSFILES_CONTENTS = stringify([...fsFilesContents.entries()])
+    config.define.EXODUS_TEST_FSDIRS = stringify([...fsFilesDirs.entries()])
     res = await buildWrap(config)
     assert.equal(res instanceof Error, res.errors.length > 0)
   }

package/bundler/modules/fs.cjs

@@ -75,38 +75,49 @@ const stubs = Object.fromEntries(mainKeys.map((key) => [key, () => err(key)]))
 const stubsPromises = Object.fromEntries(promisesKeys.map((key) => [key, async () => err(key)]))
 const promises = { ...stubsPromises, constants }
 
-// eslint-disable-next-line no-undef
-const fsFiles = typeof EXODUS_TEST_FSFILES === 'undefined' ? null : new Set(EXODUS_TEST_FSFILES)
-const existsSync = (file) => {
-  if (fsFiles?.has(file)) return true
-  err('existsSync', file)
+const decode = (source, sourceEncoding, encoding) => {
+  if (encoding && sourceEncoding === encoding) return source
+  const data = Buffer.from(source, sourceEncoding)
+  return encoding === undefined ? data : data.toString(encoding)
+}
+
+const getOptions = (arg, options) => {
+  if (typeof arg !== 'string') throw new Error('first argument should be string')
+  const file = resolve(process.cwd(), arg)
+  if (typeof options === 'string') return { file, encoding: options, rest: {} }
+  if (options === undefined) return { file, rest: {} }
+  if (typeof options !== 'object') throw new Error('Unexpected options')
+  const { encoding: enc, ...rest } = options
+  if (enc !== undefined && typeof enc !== 'string') throw new Error('encoding should be a string')
+  return { file, encoding: enc, rest }
 }
 
 const fsFilesContents =
   // eslint-disable-next-line no-undef
   typeof EXODUS_TEST_FSFILES_CONTENTS === 'undefined' ? null : new Map(EXODUS_TEST_FSFILES_CONTENTS)
-const readFileSync = (file, options) => {
-  let encoding
-  if (typeof options === 'string') {
-    encoding = options
-  } else if (options !== undefined) {
-    if (typeof options !== 'object') throw new Error('Unexpected readFileSync options')
-    const { encoding: enc, ...rest } = options
-    if (enc !== undefined && typeof enc !== 'string') throw new Error('encoding should be a string')
-    encoding = enc
-    if (Object.keys(rest).length > 0) throw new Error('Unsupported readFileSync options')
-  }
+const readFileSync = (arg, options) => {
+  const { file, encoding, rest } = getOptions(arg, options)
+  if (Object.keys(rest).length > 0) throw new Error('Unsupported readFileSync options')
+  if (fsFilesContents?.has(file)) return decode(fsFilesContents.get(file), 'base64', encoding)
+  err('readFileSync', file)
+}
 
-  if (typeof file !== 'string') throw new Error('file argument should be string')
-  file = resolve(process.cwd(), file)
-  if (fsFilesContents?.has(file)) {
-    const data = Buffer.from(fsFilesContents.get(file), 'base64')
-    if (encoding?.toLowerCase().replace('-', '') === 'utf8') return data.toString('utf8')
-    if (encoding === undefined) return data
-    throw new Error('Unsupported encoding')
-  }
+// eslint-disable-next-line no-undef
+const fsDir = typeof EXODUS_TEST_FSDIRS === 'undefined' ? null : new Map(EXODUS_TEST_FSDIRS)
+const readdirSync = (arg, options) => {
+  const { file: dir, encoding, rest } = getOptions(arg, options)
+  if (Object.keys(rest).length > 0) throw new Error('Unsupported readdirSync options')
+  const enc = encoding === 'buffer' ? undefined : encoding || 'utf8'
+  if (fsDir?.has(dir)) return fsDir.get(dir).map((name) => decode(name, 'utf8', enc))
+  err('readdirSync', dir)
+}
 
-  err('readFileSync', file)
+// eslint-disable-next-line no-undef
+const fsFiles = typeof EXODUS_TEST_FSFILES === 'undefined' ? null : new Set(EXODUS_TEST_FSFILES)
+const existsSync = (file) => {
+  if (fsFiles?.has(file) || fsFilesContents?.has(file) || fsDir?.has(file)) return true
+  err('existsSync', file)
 }
 
-module.exports = { ...stubs, existsSync, readFileSync, promises, constants, F_OK, R_OK, W_OK, X_OK }
+const implemented = { existsSync, readFileSync, readdirSync }
+module.exports = { ...stubs, ...implemented, promises, constants, F_OK, R_OK, W_OK, X_OK }

package/bundler/modules/globals.cjs

@@ -3,22 +3,39 @@
 
 if (!globalThis.global) globalThis.global = globalThis
 if (!globalThis.Buffer) globalThis.Buffer = require('buffer').Buffer
-if (!globalThis.console) {
-  // eslint-disable-next-line no-undef
-  globalThis.console = { log: print, error: print, warn: print, info: print, debug: print }
-}
 
-// Otherwise e.g. errors (and some other objects) are hard to unwrap via the API
+const consoleKeys = ['log', 'error', 'warn', 'info', 'debug', 'trace']
+if (!globalThis.console) globalThis.console = Object.fromEntries(consoleKeys.map((k) => [k, print])) // eslint-disable-line no-undef
+
+// In browsers e.g. errors (and some other objects) are hard to unwrap via the API
 // So we just stringify everything instead on the sender side
-if (process.env.EXODUS_TEST_IS_BROWSER) {
+// In barebone, we don't want console.log({x:10}) to print "[Object object]"", we want "{ x: 10 }"
+if (process.env.EXODUS_TEST_IS_BROWSER || process.env.EXODUS_TEST_IS_BAREBONE) {
   const utilFormat = require('exodus-test:util-format')
-  for (const type of ['log', 'error', 'warn', 'info', 'debug']) {
+  for (const type of consoleKeys) {
     if (!Object.hasOwn(console, type)) continue
     const orig = console[type].bind(console)
     console[type] = (...args) => orig(utilFormat(...args))
   }
 }
 
+if (!console.time || !console.timeEnd) {
+  const start = new Map()
+  const now = globalThis.performance?.now ? performance.now.bind(performance) : Date.now.bind(Date) // d8 and jsc have performance.now()
+  const warn = (text) => console.error(`Warning: ${text}`)
+  console.time = (key = 'default') => {
+    if (start.has(key)) return warn(`Label '${key}' already exists for console.time()`) // Does not reset
+    start.set(key, now()) // Start late
+  }
+
+  console.timeEnd = (key = 'default') => {
+    const ms = now() // End early
+    if (!start.has(key)) return warn(`No such label '${key}' for console.timeEnd()`)
+    console.log(`${key}: ${ms - start.get(key)}ms`)
+    start.delete(key)
+  }
+}
+
 if (!globalThis.fetch) {
   globalThis.fetch = () => {
     throw new Error('Fetch not supported')
@@ -116,40 +133,53 @@ This activity created errors and would have caused tests to fail, but instead tr
 
 if (
   process.env.EXODUS_TEST_PLATFORM === 'hermes' ||
-  (process.env.EXODUS_TEST_PLATFORM === 'jsc' && !globalThis.clearTimeout) ||
-  (process.env.EXODUS_TEST_PLATFORM === 'd8' && !globalThis.clearTimeout)
+  (process.env.EXODUS_TEST_IS_BAREBONE && !globalThis.clearTimeout)
 ) {
   // Ok, we have broken timers, let's hack them around
   let i = 0
   const timers = new Map()
-  const { setTimeout, clearTimeout } = globalThis
-  const dateNow = Date.now
-  const precision = clearTimeout ? Infinity : 10 // have to tick this fast for clearTimeout to work
+  const repeating = new Set()
+  const { setTimeout: setTimeoutOriginal, clearTimeout: clearTimeoutOriginal } = globalThis
+  const dateNow = Date.now.bind(Date)
+  const precision = clearTimeoutOriginal ? Infinity : 10 // have to tick this fast for clearTimeout to work
 
-  globalThis.setTimeout = (fn, time, ...args) => {
+  const setTimeout = (fn, time, ...args) => {
     const id = `ht${i++}`
-    const now = dateNow()
+    let started = dateNow()
     const tick = () => {
       if (!timers.has(id)) return
-      const remaining = now + time - dateNow()
+      const remaining = started + time - dateNow()
       if (remaining < 0) {
-        timers.delete(id)
+        if (repeating.has(id)) {
+          started = dateNow()
+          timers.set(id, setTimeoutOriginal(tick, Math.min(precision, time)))
+        } else {
+          timers.delete(id)
+        }
+
         fn(...args)
       } else {
-        timers.set(id, setTimeout(tick, Math.min(precision, remaining)))
+        timers.set(id, setTimeoutOriginal(tick, Math.min(precision, remaining)))
       }
     }
 
-    timers.set(id, setTimeout(tick, Math.min(precision, time)))
+    timers.set(id, setTimeoutOriginal(tick, Math.min(precision, time)))
+    return id
+  }
+
+  globalThis.setTimeout = setTimeout
+  globalThis.setInterval = (fn, time, ...args) => {
+    const id = setTimeout(fn, time, ...args)
+    repeating.add(id)
     return id
   }
 
-  globalThis.clearTimeout = (id) => {
+  globalThis.clearTimeout = globalThis.clearInterval = (id) => {
     if (!timers.has(id)) return
-    clearTimeout?.(timers.get(id))
+    clearTimeoutOriginal?.(timers.get(id))
     timers.delete(id)
+    repeating.delete(id)
   }
-  // TODO: setInterval, clearInterval
 }
 
 if (!globalThis.crypto?.getRandomValues && globalThis.EXODUS_TEST_CRYPTO_ENTROPY) {
@@ -193,11 +223,7 @@ if (globalThis.crypto?.getRandomValues && !globalThis.crypto?.randomUUID) {
 
 if (!globalThis.crypto.subtle) globalThis.crypto.subtle = {} // For getRandomValues detection
 
-if (
-  process.env.EXODUS_TEST_PLATFORM === 'hermes' ||
-  process.env.EXODUS_TEST_PLATFORM === 'jsc' ||
-  process.env.EXODUS_TEST_PLATFORM === 'd8'
-) {
+if (process.env.EXODUS_TEST_IS_BAREBONE) {
   if (!globalThis.URLSearchParams) globalThis.URLSearchParams = require('@ungap/url-search-params')
   if (!globalThis.TextEncoder || !globalThis.TextDecoder) {
     const { TextEncoder, TextDecoder } = require('exodus-test:text-encoding-utf')

package/bundler/modules/text-encoding-utf.cjs

@@ -56,8 +56,7 @@ function TextDecoder(encoding = UTF8, options = {}) {
   encoding = normalizeEncoding(encoding)
   assertUTF8orUTF16LE(encoding)
 
-  const { fatal = true, ignoreBOM = false, stream = false } = options
-  if (fatal !== true) throw new Error('disabling "fatal" mode is not supported')
+  const { fatal = false, ignoreBOM = false, stream = false } = options
   if (ignoreBOM !== false) throw new Error('option "ignoreBOM" is not supported')
   if (stream !== false) throw new Error('option "stream" is not supported')
 
@@ -67,11 +66,25 @@ function TextDecoder(encoding = UTF8, options = {}) {
   defineFinal(this, 'ignoreBOM', ignoreBOM)
 }
 
+// Note: https://npmjs.com/package/buffer has a bug
+// Buffer.from([0xf0, 0x90, 0x80]).toString().length should be 1, but it is 3 in https://npmjs.com/package/buffer
+// Buffer.from([0xf0, 0x80, 0x80]).toString().length should be 3, see https://github.com/nodejs/node/issues/16894
 TextDecoder.prototype.decode = function (buf) {
   if (buf === undefined) return ''
   assertBufferSource(buf)
   if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)
-  return buf.toString(this.encoding)
+  const res = buf.toString(this.encoding)
+  if (this.fatal && res.includes('\uFFFD')) {
+    // We have a replacement symbol, recheck if output matches input
+    const reconstructed = Buffer.from(res, this.encoding)
+    if (Buffer.compare(buf, reconstructed) !== 0) {
+      const err = new TypeError('The encoded data was not valid for encoding utf-8')
+      err.code = 'ERR_ENCODING_INVALID_ENCODED_DATA'
+      throw err
+    }
+  }
+
+  return res
 }
 
 module.exports = { TextEncoder, TextDecoder }

package/bundler/modules/tty.cjs

@@ -0,0 +1,10 @@
+module.exports = {
+  isatty: () => false,
+  // Not arrows as those are classes and can be called with new
+  ReadStream() {
+    throw new Error('tty.ReadStream unsupported in bundled mode')
+  },
+  WriteStream() {
+    throw new Error('tty.WriteStream unsupported in bundled mode')
+  },
+}

package/bundler/modules/util-format.cjs

@@ -1,7 +1,12 @@
 const { inspect: inspectOrig, isString, isNull, isObject } = require('util/') // dep
 
 // Print errors without square brackets
-const inspect = (obj, opts) => (obj instanceof Error ? String(obj) : inspectOrig(obj, opts))
+const trim = (x) => x.trim()
+const validLine = (x) => x && x !== '@'
+const padLine = (line) => `    ${line}`
+const pad = (stack) => stack.split('\n').map(trim).filter(validLine).map(padLine).join('\n')
+const errorStr = (e) => (e.stack.startsWith(`${e}\n`) ? e.stack : `${e}\n${pad(e.stack)}`.trimEnd())
+const inspect = (obj, opts) => (obj instanceof Error ? errorStr(obj) : inspectOrig(obj, opts))
 
 // Patched impl from require('util'), added %i
 const formatRegExp = /%[%dijs]/g

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.69",
+  "version": "1.0.0-rc.70",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -60,6 +60,7 @@
     "bundler/modules/jest-util.js",
     "bundler/modules/node-buffer.cjs",
     "bundler/modules/text-encoding-utf.cjs",
+    "bundler/modules/tty.cjs",
     "bundler/modules/url.cjs",
     "bundler/modules/util-format.cjs",
     "bundler/modules/ws.cjs",
@@ -130,7 +131,7 @@
     "@babel/plugin-transform-private-methods": "^7.0.0",
     "@babel/register": "^7.0.0",
     "@chalker/queue": "^1.0.0",
-    "@exodus/replay": "^1.0.0-rc.4",
+    "@exodus/replay": "^1.0.0-rc.6",
     "@ungap/url-search-params": "^0.2.2",
     "amaro": "^0.0.5",
     "assert": "^2.1.0",
@@ -148,7 +149,7 @@
     "jsdom": "^24.1.0",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
-    "playwright-core": "^1.51.1",
+    "playwright-core": "^1.52.0",
     "pretty-format": "^29.7.0",
     "puppeteer-core": "^24.6.0",
     "querystring-es3": "^0.2.1",

package/src/engine.pure.cjs

@@ -84,6 +84,10 @@ class Context {
     if (!this.#hooks?.[type]) return
     for (const hook of this.#hooks[type]) await runFunction(hook, context)
   }
+
+  diagnostic(message) {
+    console.log(`ℹ DIAGNOSTIC ${message}`)
+  }
 }
 
 function enterContext(name, options) {

package/src/jest.js

@@ -231,7 +231,9 @@ export const jest = {
       fetchRecord,
       fetchReplay,
       fetchNoop: () => {
-        globalThis.fetch = jest.fn()
+        // We can't use pure noop, it will break chained fetch().then(), so let's reject
+        const fetch = () => Promise.reject(new Error('fetch is disabled by mock.fetchNoop()'))
+        globalThis.fetch = jest.fn(fetch)
         return globalThis.fetch
       },
       websocketRecord,