@exodus/test 1.0.0-rc.46 → 1.0.0-rc.47

package/bin/jest.js

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

package/bin/reporter.js

@@ -0,0 +1,183 @@
+import assert from 'node:assert/strict'
+import { inspect } from 'node:util'
+import { relative, resolve } from 'node:path'
+import { spec as SpecReporter } from 'node:test/reporters'
+
+const { FORCE_COLOR, CI, GITHUB_WORKSPACE, LERNA_PACKAGE_NAME } = process.env
+const haveColors = process.stdout.hasColors?.() || FORCE_COLOR === '1' // 0 is already handled by hasColors()
+const colors = new Map(Object.entries(inspect.colors))
+const dim = CI ? 'gray' : 'dim'
+
+const uriReplacer = (x) => `%${x.codePointAt(0).toString(16).padStart(2, '0').toUpperCase()}`
+const escapeGitHubValue = (k, v) => `${k}=${String(v ?? '').replace(/[%\r\n:,]/gu, uriReplacer)}`
+const escapeGitHub = (s) => String(s || 'Unknown error').replace(/[%\r\n]/gu, uriReplacer)
+const serializeGitHub = (entries) => entries.map(([k, v]) => escapeGitHubValue(k, v)).join(',')
+
+export 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`
+}
+
+// Used for pure engine output formatting
+export 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(/^⚠ WARN /gmu, color('⚠ WARN ', 'blue'))
+    .replaceAll(/^‼ FATAL /gmu, `${color('‼', 'red')} ${color(' FATAL ', 'bgRed')} `)
+}
+
+const formatTime = (ms) => (ms ? color(` (${ms}ms)`, dim) : '')
+const formatSuffix = (d) => `${formatTime(d.details.duration_ms)}${d.todo ? ' # TODO' : ''}`
+
+const groupCI = CI && !process.execArgv.includes('--watch') && !LERNA_PACKAGE_NAME // lerna+nx groups already
+export const timeLabel = color('Total time', dim)
+export const head = groupCI ? () => {} : (file) => console.log(color(`# ${file}`, 'bold'))
+export const middle = (file, ok, ms) => {
+  if (!groupCI) return
+  console.log(`::group::${ok ? '✅' : '❌'} ${color(file, 'bold')}${formatTime(ms)}`)
+}
+
+export const tail = groupCI ? () => console.log('::endgroup::') : () => {}
+export const summary = (files, failures) => {
+  if (failures.length > 0) {
+    const [total, passed, failed] = [files.length, files.length - failures.length, failures.length]
+    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(color(`All ${files.length} test suites passed`, 'green'))
+  }
+}
+
+const cleanLine = (line) =>
+  line.trimStart().startsWith('at ') ? line.replace(`(file://${GITHUB_WORKSPACE}/`, '(') : line
+const cleanWorkspace = (e) => (CI && GITHUB_WORKSPACE ? e.split('\n').map(cleanLine).join('\n') : e)
+const SKIPPED_TRACE_LINES =
+  /\n^(\x1B\[90m)? +at [ a-zA-Z.]+ \(node:(async_hooks|internal\/test_runner\/test):\d+:\d+\)(\x1B\[39m)?$/gmu // eslint-disable-line no-control-regex
+const notPrintedError = (e) => e?.code === 'ERR_TEST_FAILURE' && e?.failureType === 'subtestsFailed' // skipped from printing details
+const extractError = ({ details: { error }, ...data }, file) => {
+  if (!error) return ''
+  if (error.cause) delete error.cause.matcherResult // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
+  const selected = error.cause || error
+  const body = inspect(selected, { colors: haveColors }).replaceAll(SKIPPED_TRACE_LINES, '')
+
+  let loc = { file, line: data.line, col: data.column }
+  const validLine = (l) => l.startsWith('at ') && l.replace(/:\d+:\d+\)$/, '').endsWith(`/${file}`)
+  const line = (selected.stack || '').split('\n').find((l) => validLine(l.trimStart()))
+  const match = line?.match(/:(\d+):(\d+)\)$/)
+  if (match) loc = { file, line: Number(match[1]), col: Number(match[2]) }
+
+  return { body: cleanWorkspace(body), loc }
+}
+
+try {
+  // Welp, in some cases there is no other way to tell the entry point
+  // E.g. when the test file is just an import of another one, the reported 'file' is the imported one
+  // We want to know the original entry points instead
+  const runner = await import('node:internal/test_runner/runner') // eslint-disable-line @exodus/import/no-unresolved
+  const { FileTest } = runner.default || runner
+  const { addToReport } = FileTest.prototype
+  FileTest.prototype.addToReport = function (item, ...rest) {
+    if (item?.type === 'test:start' && !item.data.entry) {
+      item.data.entry = this.loc?.file || (this.name && resolve(this.name)) // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
+    }
+
+    return addToReport.call(this, item, ...rest)
+  }
+} catch {}
+
+export default async function nodeTestReporterExodus(source) {
+  const spec = new SpecReporter()
+  spec.on('data', (data) => {
+    console.log(data.toString('utf8'))
+  })
+
+  const log = []
+  const print = (msg) => (groupCI ? log.push(msg) : console.log(msg))
+  const dump = () => {
+    middle(file, !failedFiles.has(file))
+    for (const line of log) console.log(line)
+    log.length = 0
+    tail()
+  }
+
+  const files = new Set()
+  const failedFiles = new Set()
+  const cwd = process.cwd()
+  const path = []
+  let file
+  const diagnostic = []
+  const delayed = []
+  const isTopLevelTest = ({ nesting, line, column, name, file }) =>
+    nesting === 0 && line === 1 && column === 1 && file.endsWith(name) && resolve(name) === file // some events have data.file resolved, some not)
+  const processNewFile = (data) => {
+    const newFile = relative(cwd, data.entry || data.file) // some events have data.file resolved, some not
+    if (newFile === file) return
+    if (file !== undefined) dump()
+    file = newFile
+    assert(files.has(file), 'Cound not determine file')
+    head(file)
+  }
+
+  for await (const { type, data } of source) {
+    // Ignored: test:complete (no support on older Node.js), test:plan, test:dequeue, test:enqueue
+    switch (type) {
+      case 'test:dequeue':
+        if (data.nesting === 0 && !Object.hasOwn(data, 'file')) files.add(relative(cwd, data.name)) // old-style
+        if (isTopLevelTest(data)) files.add(relative(cwd, data.file))
+        break
+      case 'test:start':
+        processNewFile(data)
+        path.push(data.name)
+        while (delayed.length > 0) print(delayed.shift())
+        break
+      case 'test:pass':
+        const label = data.skip ? color('⏭ SKIP ', dim) : color('✔ PASS ', 'green')
+        print(`${label}${path.join(' > ')}${formatSuffix(data)}`)
+        assert(path.pop() === data.name)
+        break
+      case 'test:fail':
+        print(`${color('✖ FAIL ', 'red')}${path.join(' > ')}${formatSuffix(data)}`)
+        assert(path.pop() === data.name)
+        if (!data.todo) failedFiles.add(file)
+        if (!notPrintedError(data.details.error)) {
+          const { body, loc } = extractError(data, relative(cwd, data.file)) // might be different from current file if in subimport
+          if (!data.todo && CI && loc.line != null && loc.col != null) {
+            print(`::error ${serializeGitHub(Object.entries(loc))}::${escapeGitHub(body)}`)
+          } else if (body) {
+            print(`${body.replace(/^/gmu, '  ')}\n`)
+          }
+        }
+
+        break
+      case 'test:watch:drained':
+        assert(!groupCI, 'Can not mix --watch with CI grouping')
+        console.log(color(`ℹ waiting for changes as we are in --watch mode`, 'blue'))
+        break
+      case 'test:diagnostic':
+        if (/^suites \d+$/.test(data.message)) break // we count suites = files
+        diagnostic.push(color(`ℹ ${data.message}`, 'blue'))
+        break
+      case 'test:stderr':
+      case 'test:stdout':
+        const handle = path.length > 0 ? print : (arg) => delayed.push(arg)
+        handle(data.message.replace(/\n$/, '')) // these are printed at test:start
+        break
+      case 'test:coverage':
+        spec.write({ type, data }) // let spec reporter handle that
+        break
+    }
+  }
+
+  dump()
+  for (const line of diagnostic) console.log(line)
+  summary([...files], [...failedFiles])
+}

package/bundler/babel-worker.cjs

@@ -0,0 +1,62 @@
+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')
+  const tryLoadPlugin = (name) => {
+    // Try unwrapping plugin names, as otherwise Babel tries to require them from the wrong dir,
+    // which breaks strict directory structure under pnpm in some setups
+    try {
+      if (typeof name === 'string' && name.startsWith('@babel/plugin-')) return require(name)
+    } catch {}
+
+    return name
+  }
+
+  parentPort.on('message', ({ port, code: input, options }) => {
+    try {
+      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      if (options.plugins) options.plugins = options.plugins.map((name) => tryLoadPlugin(name))
+      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/bundler/bundle.js

@@ -0,0 +1,292 @@
+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, extname, 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, resolvers) => {
+  const snapshots = []
+  for (const file of files) {
+    for (const resolver of resolvers) {
+      const snapshotFile = join(...resolver(dirname(file), basename(file)))
+      try {
+        snapshots.push([snapshotFile, await readFile(snapshotFile, 'utf8')])
+      } catch (e) {
+        if (e.code !== 'ENOENT') throw e
+      }
+    }
+  }
+
+  return snapshots
+}
+
+const loadPipeline = [
+  function (source, 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))
+  },
+]
+
+const options = {}
+
+export const init = async ({ platform, jest, flow, target, jestConfig, outdir }) => {
+  Object.assign(options, { platform, jest, flow, target, jestConfig, outdir })
+
+  if (options.flow) {
+    const { default: flowRemoveTypes } = await import('flow-remove-types')
+    loadPipeline.unshift((source) => flowRemoveTypes(source, { pretty: true }).toString())
+  }
+
+  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', 'd8'].includes(options.platform)) {
+      const entropy = randomBytes(5 * 1024).toString('base64')
+      input.push(`globalThis.EXODUS_TEST_CRYPTO_ENTROPY = ${stringify(entropy)};`)
+    }
+
+    await importSource('./modules/globals.cjs')
+  }
+
+  if (options.jest) {
+    const { jestConfig } = options
+    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 || []))
+    }
+
+    if (preload.length === 0) {
+      input.push(`globalThis.EXODUS_TEST_PRELOADED = []`)
+    } else {
+      assert(jestConfig.rootDir)
+      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('../bin/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, [
+    (dir, name) => [dir, `${name}.snapshot`], // node:test
+    (dir, name) => [dir, '__snapshots__', `${name}.snap`], // jest
+  ])
+  const EXODUS_TEST_RECORDINGS = await readSnapshots(files, [
+    (dir, name) => [dir, '__recordings__', 'fetch', `${name}.json`],
+    (dir, name) => [dir, '__recordings__', 'websocket', `${name}.json`],
+  ])
+  const buildWrap = async (opts) => esbuild.build(opts).catch((err) => err)
+  let main = input.join(';\n')
+  if (['jsc', 'hermes', 'd8'].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(`./modules/${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'), // 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_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.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_RECORDINGS: stringify(EXODUS_TEST_RECORDINGS),
+      EXODUS_TEST_FSFILES: stringify(fsfiles), // TODO: can we safely use relative paths?
+    },
+    alias: {
+      // Jest, tape and node:test
+      '@jest/globals': resolveImport('../src/jest.js'),
+      tape: resolveImport('../src/tape.cjs'),
+      'tape-promise/tape': resolveImport('../src/tape.cjs'),
+      'node:test': resolveImport('../src/node.js'),
+      // Inner
+      'exodus-test:util-format': api('util-format.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'),
+    },
+    sourcemap: ['hermes', 'jsc', 'd8'].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]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 (['jsc', 'hermes'].includes(options.platform)) {
+              const maybeNative = filepath.replace(/(\.[cm]?[jt]sx?)$/u, '.native$1')
+              if (existsSync(maybeNative)) filepath = maybeNative
+            }
+
+            const loader = extname(filepath).replace(/^\.[cm]?/, '') // TODO: a flag to force jsx/tsx perhaps
+            assert(['js', 'ts', 'jsx', 'tx'].includes(loader))
+
+            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/bundler/modules/ansi-styles.cjs

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

package/bundler/modules/assert-strict.cjs

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

package/bundler/modules/child_process.cjs

@@ -0,0 +1,10 @@
+const keys = 'ChildProcess,exec,execFile,execFileSync,execSync,fork,spawn,spawnSync'.split(',')
+
+const makeMethod = (key) => {
+  // Not an arrow as ChildProcess is a class and can be called with new
+  return function () {
+    throw new Error(`child_process.${key} unsupported in bundled mode`)
+  }
+}
+
+module.exports = Object.fromEntries(keys.map((key) => [key, makeMethod(key)]))

package/bundler/modules/crypto.cjs

@@ -0,0 +1,5 @@
+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 }

package/bundler/modules/empty/function-throw.cjs

@@ -0,0 +1,4 @@
+// Should not be an arrow function as might be used as a constructor
+module.exports = function () {
+  throw new Error('module unsupported in bundled mode')
+}

package/bundler/modules/empty/module-throw.cjs

@@ -0,0 +1 @@
+throw new Error('module unsupported in bundled mode')

package/bundler/modules/fs-promises.cjs

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