spark-chamber 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Sylvester Keil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the " Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/bin/spark.cjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const console = require('node:console')
+const process = require('node:process')
+const { join } = require('node:path')
+const { spawn } = require('node:child_process')
+
+function resolve (module, resolver = require) {
+  try {
+    return resolver(module)
+  } catch {
+    return null
+  }
+}
+
+function run (electron) {
+  if (!electron) {
+    console.error(`
+      Cannot find 'electron' and $ELECTRON_PATH is not set.
+      Either set $ELECTRON_PATH or run 'npm install electron'.`)
+
+    process.exit(1)
+  } else {
+    let args = [
+      join(__dirname, '..'),
+      ...process.argv.slice(2)
+    ]
+
+    let child = spawn(electron, args)
+
+    child.stdout.pipe(process.stdout)
+    child.stderr.pipe(process.stderr)
+
+    child.on('exit', (code, signal) => {
+      if (signal)
+        process.kill(process.pid, signal)
+      else
+        process.exit(code)
+    })
+
+    process.on('SIGINT', () => {
+      child.kill('SIGINT')
+      child.kill('SIGTERM')
+    })
+  }
+}
+
+run(process.env.ELECTRON_PATH || resolve('electron'))

package/lib/args.js

@@ -0,0 +1,161 @@
+import { existsSync } from 'node:fs'
+import * as reporters from 'node:test/reporters'
+import { parseArgs } from 'node:util'
+import config, { configure } from './config.js'
+
+export const options = {
+  help: {
+    type: 'boolean',
+    short: 'h'
+  },
+  version: {
+    type: 'boolean',
+    short: 'v'
+  },
+  verbose: {
+    type: 'boolean',
+    short: 'V',
+    default: config.verbose
+  },
+  concurrency: {
+    type: 'string',
+    short: 'c'
+  },
+  'name-pattern': {
+    type: 'string',
+    short: 'g',
+    multiple: true
+  },
+  only: {
+    type: 'boolean'
+  },
+  'rerun-failures': {
+    type: 'string'
+  },
+  renderer: {
+    type: 'string',
+    short: 'r',
+    multiple: true
+  },
+  'skip-pattern': {
+    type: 'string',
+    short: 'x',
+    multiple: true
+  },
+  isolation: {
+    type: 'string',
+    short: 'i'
+  },
+  timeout: {
+    type: 'string',
+    short: 't'
+  },
+  'global-setup': {
+    type: 'string',
+    short: 'S'
+  },
+  ui: {
+    type: 'string'
+  },
+  url: {
+    type: 'string',
+    default: config.url
+  },
+  reporter: {
+    type: 'string',
+    short: 'R',
+    multiple: true
+  },
+  destination: {
+    type: 'string',
+    short: 'O',
+    multiple: true
+  },
+}
+
+export function parse (args) {
+  let { values, positionals, tokens } = parseArgs({
+    args,
+    options,
+    tokens: true,
+    allowPositionals: true,
+    strict: false
+  })
+
+  // Subtle: assuming these are Electron/Chromium switches!
+  values.switches = tokens
+    .filter(t => t.kind === 'option' && !(t.name in options))
+    .map(t => t.rawName)
+
+  if (positionals.length)
+    values.main = positionals
+
+  if (values.concurrency)
+    values.concurrency = Number(values.concurrency)
+
+  if (values.timeout)
+    values.timeout = Number(values.timeout)
+
+  if (values['name-pattern']) {
+    values.testNamePatterns = values['name-pattern']
+    delete values['name-pattern']
+  }
+
+  if (values['skip-pattern']) {
+    values.testSkipPatterns = values['skip-pattern']
+    delete values['skip-pattern']
+  }
+
+  if (values['rerun-failures']) {
+    values.rerunFailuresFilePath = values['rerun-failures']
+    delete values['rerun-failures']
+  }
+
+  if (values['global-setup']) {
+    values.globalSetupPath = values['global-setup']
+    delete values['global-setup']
+  }
+
+  values.reporter = values.reporter ?? ['spec']
+  values.destination = values.destination ?? ['stdout']
+
+  validateReporters(values.reporter, values.destination)
+  configure(values)
+
+  return values
+}
+
+function validateReporters (names, destinations) {
+  if (names.length !== destinations.length)
+    throw new Error('Each --reporter must have a matching --destination')
+
+  for (let name of names) {
+    if (!(name in reporters) && !existsSync(name))
+      throw new Error(`Unknown reporter: ${name}`)
+  }
+}
+
+export const usage = () => `Usage: spark [options] [files...]
+
+Arguments:
+  files                        main process test files (glob patterns)
+
+Options:
+  -r, --renderer <files>       renderer test files (repeatable, glob)
+  -g, --name-pattern <regex>   run matching tests (repeatable)
+  -x, --skip-pattern <regex>   skip matching tests (repeatable)
+  -c, --concurrency <n>        max concurrent test files
+  -i, --isolation <mode>       test isolation (none, process)
+  -t, --timeout <ms>           test timeout in ms
+      --ui <name>              test interface (bdd, tdd)
+      --url <url>              renderer page URL
+      --only                   run tests with { only: true }
+  -S, --global-setup <path>    module to run before tests
+      --rerun-failures <path>  rerun failures state file
+  -R, --reporter <name>        reporter name or path (repeatable)
+  -O, --destination <path>     output per reporter (repeatable)
+      --no-sandbox             disable Chromium sandbox
+  -V, --verbose                verbose output
+  -h, --help                   show this help
+  -v, --version                show version
+`

package/lib/config.js

@@ -0,0 +1,13 @@
+const config = {
+  url: 'spark://chamber',
+  verbose: false
+}
+
+export default config
+
+export function configure (opts) {
+  for (let key in opts) {
+    if (key in config)
+      config[key] = opts[key]
+  }
+}

package/lib/coverage.js

@@ -0,0 +1,65 @@
+export async function startInspector (out) {
+  let { Session } = await import('node:inspector/promises')
+  let session = new Session()
+  session.connect()
+  await session.post('Profiler.enable')
+  await session.post('Profiler.startPreciseCoverage', {
+    callCount: true,
+    detailed: true
+  })
+
+  return async () => {
+    let { result } = await session.post('Profiler.takePreciseCoverage')
+    await session.post('Profiler.stopPreciseCoverage')
+    await session.post('Profiler.disable')
+    session.disconnect()
+    return writeCoverage(out, result)
+  }
+}
+
+export async function startDebugger (out, webContents) {
+  let dbg = webContents.debugger
+  dbg.attach()
+  await dbg.sendCommand('Profiler.enable')
+  await dbg.sendCommand('Profiler.startPreciseCoverage', {
+    callCount: true,
+    detailed: true
+  })
+
+  return async () => {
+    let { result } = await dbg.sendCommand('Profiler.takePreciseCoverage')
+    await dbg.sendCommand('Profiler.stopPreciseCoverage')
+    await dbg.sendCommand('Profiler.disable')
+    dbg.detach()
+    return writeCoverage(out, result)
+  }
+}
+
+function writeCoverage (out, result) {
+  let files = []
+
+  for (let entry of result) {
+    if (!entry.url.startsWith('file://')) continue
+
+    let functions = []
+    for (let fn of entry.functions) {
+      if (fn.functionName) {
+        functions.push({
+          name: fn.functionName,
+          count: fn.ranges[0].count
+        })
+      }
+    }
+
+    if (functions.length) {
+      files.push({
+        path: new URL(entry.url).pathname,
+        functions
+      })
+    }
+  }
+
+  let data = { nesting: 0, summary: { files } }
+  out?.write({ type: 'test:coverage', data })
+  return data
+}

package/lib/force-exit.cjs

@@ -0,0 +1,10 @@
+const process = require('node:process')
+const { after } = require('node:test')
+
+// Because Electron's event loop does not drain,
+// tests spawned with isolation: 'process' never exit.
+// The after hook runs when all tests complete via root.run(),
+// giving us a chance to force exit.
+after(() => {
+  setImmediate(() => process.exit())
+})

package/lib/init.js

@@ -0,0 +1,36 @@
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { app, protocol } from 'electron'
+
+export function registerScheme () {
+  protocol.registerSchemesAsPrivileged([{
+    scheme: 'spark',
+    privileges: { standard: true, secure: true }
+  }])
+}
+
+export function handleScheme () {
+  if (!protocol.isProtocolHandled('spark')) {
+    protocol.handle('spark', () => new Response('<html></html>', {
+      headers: { 'content-type': 'text/html' }
+    }))
+  }
+}
+
+export function setupPaths () {
+  let tmp = mkdtempSync(join(tmpdir(), `${app.getName()}-`))
+
+  app.setPath('appData', tmp)
+  app.setPath('cache', join(tmp, 'cache'))
+  app.setPath('logs', join(tmp, 'logs'))
+  app.setPath('crashDumps', join(tmp, 'crashDumps'))
+}
+
+if (!app.isReady()) {
+  if (app.getName() === 'spark')
+    setupPaths()
+
+  registerScheme()
+  app.whenReady().then(handleScheme)
+}

package/lib/log.js

@@ -0,0 +1,30 @@
+import { styleText } from 'node:util'
+import config from './config.js'
+
+export default function log (level, ...args) {
+  log[level ?? 'info']?.(...args)
+}
+
+export function debug (...args) {
+  if (config.verbose)
+    console.error(styleText('gray', args.shift()), ...args)
+}
+
+export function info (...args) {
+  console.log(...args)
+}
+
+export function warn (...args) {
+  console.warn(styleText('yellow', `[WARN]: ${args.shift()}`), ...args)
+}
+
+export function error (err, ...args) {
+  if (err instanceof Error) {
+    console.error(styleText('red', `[ERROR]: ${err.message}`), ...args)
+    console.error(styleText('gray', err.stack))
+  } else {
+    console.error(styleText('red', `[ERROR]: ${err}`), ...args)
+  }
+}
+
+Object.assign(log, { debug, info, warn, error })

package/lib/main.js

@@ -0,0 +1,97 @@
+import { createWriteStream } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import { pathToFileURL } from 'node:url'
+import * as reporters from 'node:test/reporters'
+import { app } from 'electron'
+import './init.js'
+import log, { debug, info, error } from './log.js'
+import { parse, usage } from './args.js'
+import { run } from './spark.js'
+import { report, tap } from './stream.js'
+
+try {
+  let opts = parse()
+
+  if (opts.help)
+    quit(usage())
+  if (opts.version)
+    quit(`${app.getVersion()} (${process.versions.electron})`)
+
+  debug(`Using: ${app.getPath('appData')}`)
+
+  delete process.env.NODE_TEST_CONTEXT
+  let setup = maybeImport(opts.globalSetupPath)
+
+  app
+    .on('window-all-closed', () => {})
+    .whenReady()
+    .then(() => setup)
+    .then(async ({ globalSetup, globalTeardown }) => {
+      await globalSetup?.()
+      try {
+        return runTests(opts)
+      } finally {
+        await globalTeardown?.()
+      }
+    })
+    .then(([summary]) => {
+      app.exit(summary.counts.failed)
+    })
+    .catch(fail)
+
+} catch (e) {
+  fail(e)
+}
+
+async function runTests ({
+  reporter,
+  destination,
+  ...opts
+}) {
+  let source = run({
+    ...opts,
+    onConsole (e) { log(e.level, e.message) }
+  })
+
+  return report(
+    source,
+    await resolveReporters(reporter, destination),
+    tap('test:summary')
+  )
+}
+
+function maybeImport (moduleName) {
+  return moduleName
+    ? import(pathToFileURL(resolve(moduleName)))
+    : Promise.resolve({})
+}
+
+function resolveReporters (names, destinations) {
+  return Promise.all(names.map(async (name, i) => [
+    await resolveReporter(name),
+    resolveDestination(destinations[i])
+  ]))
+}
+
+function resolveReporter (name) {
+  return (name in reporters)
+    ? reporters[name]
+    : import(pathToFileURL(resolve(name))).then(m => m.default)
+}
+
+function resolveDestination (dest) {
+  if (dest === 'stdout') return process.stdout
+  if (dest === 'stderr') return process.stderr
+  return createWriteStream(dest)
+}
+
+function quit (reason) {
+  info(reason)
+  app.exit(0)
+}
+
+function fail (err) {
+  error(err)
+  app.exit(1)
+}

package/lib/preload.cjs

@@ -0,0 +1,26 @@
+const { argv } = require('node:process')
+const { ipcRenderer } = require('electron')
+const { createTestRunner } = require('./runner.js')
+
+window.ELECTRON_DISABLE_SECURITY_WARNINGS = true
+
+let opts = JSON.parse(
+  argv.find(a => a.startsWith('--spark=')).slice(8)
+)
+
+ipcRenderer.send('spark:ready')
+
+ipcRenderer.on('spark:start', () => {
+  createTestRunner({
+    ...opts,
+    setup (stream) {
+      stream
+        .on('data', (event) => {
+          ipcRenderer.send('spark:event', event)
+        })
+        .on('end', () => {
+          ipcRenderer.send('spark:done')
+        })
+    }
+  })
+})

package/lib/runner.js

@@ -0,0 +1,115 @@
+import assert from 'node:assert/strict'
+import { join } from 'node:path'
+import process from 'node:process'
+import test from 'node:test'
+import { expose } from './ui.cjs'
+
+const FORCE_EXIT = join(import.meta.dirname, 'force-exit.cjs')
+const UI = join(import.meta.dirname, 'ui.cjs')
+
+// Electron doesn't parse Node test flags from argv.
+// Build NODE_OPTIONS to forward them to child processes.
+function nodeOptions ({
+  only,
+  testNamePatterns,
+  testSkipPatterns,
+  timeout
+}) {
+  let opts = []
+
+  if (testNamePatterns)
+    for (let p of testNamePatterns)
+      opts.push(`--test-name-pattern=${p}`)
+
+  if (testSkipPatterns)
+    for (let p of testSkipPatterns)
+      opts.push(`--test-skip-pattern=${p}`)
+
+  if (only)
+    opts.push('--test-only')
+
+  if (timeout != null)
+    opts.push(`--test-timeout=${timeout}`)
+
+  return opts.join(' ')
+}
+
+// Tests with isolation: 'none' do not terminate
+// because they wait for the beforeExit event.
+// See https://github.com/nodejs/node/issues/57234
+function emitBeforeExit (stream) {
+  let pending = 0
+
+  stream
+    .on('test:enqueue', () => {
+      ++pending
+    })
+    .on('test:complete', () => {
+      if (--pending === 0)
+        setImmediate(() => process.emit('beforeExit'))
+    })
+}
+
+export function createTestRunner ({
+  coverage = false,
+  env = process.env,
+  execArgv = [],
+  isolation = 'none',
+  rerunFailuresFilePath,
+  setup,
+  ui,
+  watch = false,
+  ...opts
+} = {}) {
+  if (process.type === 'renderer') {
+    assert.equal(isolation, 'none',
+      'Test isolation not supported in renderer process')
+  }
+
+  switch (isolation) {
+    case 'none': {
+      expose(ui)
+      // For testNamePatterns, testSkipPatterns, only
+      // See https://github.com/nodejs/node/issues/57399
+      assert(!coverage,
+        'Test coverage not supported without isolation')
+      assert(!watch,
+        'Test watch option not supported without isolation')
+      break
+    }
+    case 'process': {
+      execArgv = ['--require', FORCE_EXIT, ...execArgv]
+
+      opts.env = {
+        ...env,
+        NODE_OPTIONS: [
+          env.NODE_OPTIONS,
+          nodeOptions(opts)
+        ].filter(Boolean).join(' ')
+      }
+
+      if (ui) {
+        execArgv.push('--require', UI)
+        opts.env.SPARK_UI = ui
+      }
+      break
+    }
+  }
+
+  if (rerunFailuresFilePath)
+    rerunFailuresFilePath = `${rerunFailuresFilePath}.${process.type}`
+
+  return test.run({
+    ...opts,
+    coverage,
+    execArgv,
+    isolation,
+    rerunFailuresFilePath,
+    setup (stream) {
+      setup?.(stream)
+      if (isolation === 'none')
+        emitBeforeExit(stream)
+    },
+    watch
+  })
+}

package/lib/spark.js

@@ -0,0 +1,132 @@
+import { once } from 'node:events'
+import { join } from 'node:path'
+import { PassThrough } from 'node:stream'
+import { app, BrowserWindow } from 'electron'
+import config from './config.js'
+import { startInspector, startDebugger } from './coverage.js'
+import { combine } from './stream.js'
+import { createTestRunner } from './runner.js'
+
+const defaultExecArgv = app.commandLine.hasSwitch('no-sandbox') ? ['--no-sandbox'] : []
+
+export function run ({ main, renderer, switches, reporter, destination, help, version, verbose, globalSetupPath, ...opts } = {}) {
+  if (switches?.length)
+    opts.execArgv = [...(opts.execArgv ?? []), ...switches]
+
+  let streams = []
+
+  if (main || !renderer)
+    streams.push(runMain({ globPatterns: main, ...opts }))
+
+  if (renderer)
+    streams.push(runRenderer({ globPatterns: renderer, ...opts }))
+
+  return combine(streams)
+}
+
+export function runMain ({ execArgv = defaultExecArgv, ...opts } = {}) {
+  if (!opts.coverage) return createTestRunner({ execArgv, ...opts })
+
+  let out = new PassThrough({ objectMode: true })
+
+  testMain({ out, execArgv, ...opts })
+    .then(() => out.end())
+    .catch(err => {
+      if (!out.destroyed) out.destroy(err)
+    })
+
+  return out
+}
+
+async function testMain ({ out, coverage, ...opts } = {}) {
+  if (coverage)
+    var stopInspector = await startInspector(out)
+
+  let stream = createTestRunner(opts)
+  let summary
+
+  for await (let event of stream) {
+    out?.write(event)
+
+    if (event.type === 'test:summary')
+      summary = event.data
+  }
+
+  if (coverage)
+    var lcov = await stopInspector()
+
+  return { summary, coverage: lcov }
+}
+
+export function runRenderer (opts = {}) {
+  let out = new PassThrough({ objectMode: true })
+
+  testRenderer({ out, ...opts })
+    .then(() => out.end())
+    .catch(err => {
+      if (!out.destroyed) out.destroy(err)
+    })
+
+  return out
+}
+
+async function testRenderer ({
+  out,
+  onConsole,
+  coverage,
+  url = config.url,
+  ...opts
+} = {}) {
+  let win = new BrowserWindow({
+    show: false,
+    webPreferences: {
+      additionalArguments: [`--spark=${JSON.stringify(opts)}`],
+      preload: join(import.meta.dirname, './preload.cjs'),
+      sandbox: false,
+      backgroundThrottling: false,
+      disableDialogs: true,
+      spellcheck: false
+    }
+  })
+
+  try {
+    let ac = new AbortController()
+    let { signal } = ac
+    let summary
+
+    win.webContents
+      .on('render-process-gone', (_, { exitCode, reason }) => {
+        ac.abort(new Error(`Renderer process exited: (${exitCode}) ${reason}`))
+      })
+      .on('console-message', (details) => {
+        onConsole?.(details)
+      })
+
+    win.webContents.ipc.on('spark:event', (_, event) => {
+      out?.write(event)
+
+      if (event.type === 'test:summary')
+        summary = event.data
+    })
+
+    win.loadURL(url)
+
+    await Promise.all([
+      once(win.webContents, 'dom-ready', { signal }),
+      once(win.webContents.ipc, 'spark:ready', { signal })
+    ])
+
+    if (coverage)
+      var stopDebugger = await startDebugger(out, win.webContents)
+
+    win.webContents.send('spark:start')
+    await once(win.webContents.ipc, 'spark:done', { signal })
+
+    if (coverage)
+      var lcov = await stopDebugger()
+
+    return { summary, coverage: lcov }
+  } finally {
+    if (!win.isDestroyed()) win.close()
+  }
+}

package/lib/stream.js

@@ -0,0 +1,92 @@
+import { PassThrough, Readable } from 'node:stream'
+
+export async function report (source, pairs, tapper) {
+  let values = []
+  if (tapper)
+    source = source.compose(tapper(data => values.push(data)))
+
+  await Promise.all(pairs.map(([reporter, dest]) => {
+    let stream = source.compose(reporter)
+    stream.pipe(dest)
+    return new Promise(resolve => stream.on('end', resolve))
+  }))
+  return values
+}
+
+export function tap (type) {
+  return (fn) => async function * (source) {
+    for await (let event of source) {
+      if (event.type === type) fn(event.data)
+      yield event
+    }
+  }
+}
+
+export function combine (sources) {
+  if (sources.length === 1) return sources[0]
+  return Readable.from(merge(sources), { objectMode: true })
+}
+
+async function * merge (sources) {
+  let n = sources.length
+  let planCount = 0
+  let plansSeen = 0
+  let summaries = []
+  let diagnostics = {}
+  let coverages = []
+
+  let pt = new PassThrough({ objectMode: true })
+  let pending = n
+
+  for (let source of sources) {
+    source.on('data', (event) => pt.write(event))
+    source.on('error', (err) => { if (!pt.destroyed) pt.destroy(err) })
+    source.on('end', () => { if (--pending === 0) pt.end() })
+  }
+
+  for await (let event of pt) {
+    let { type, data } = event
+
+    if (type === 'test:summary') {
+      summaries.push(data)
+      if (summaries.length === n) {
+        for (let [key, val] of Object.entries(diagnostics))
+          yield { type: 'test:diagnostic', data: { nesting: 0, message: `${key} ${val}` } }
+        for (let c of coverages) yield c
+        yield { type: 'test:summary', data: mergeSummaries(summaries) }
+      }
+      continue
+    }
+
+    if (type === 'test:coverage') { coverages.push(event); continue }
+
+    if (data?.nesting === 0) {
+      if (type === 'test:plan') {
+        planCount += data.count
+        if (++plansSeen === n)
+          yield { type: 'test:plan', data: { nesting: 0, count: planCount } }
+        continue
+      }
+      if (type === 'test:diagnostic') {
+        let [key, val] = data.message.split(' ')
+        diagnostics[key] = (diagnostics[key] ?? 0) + Number(val)
+        continue
+      }
+    }
+
+    yield event
+  }
+}
+
+function mergeSummaries (summaries) {
+  let counts = {}
+  for (let s of summaries) {
+    for (let [key, val] of Object.entries(s.counts))
+      counts[key] = (counts[key] ?? 0) + val
+  }
+  return {
+    ...summaries[0],
+    counts,
+    success: summaries.every((s) => s.success)
+  }
+}

package/lib/ui.cjs

@@ -0,0 +1,52 @@
+const process = require('node:process')
+const {
+  after,
+  afterEach,
+  before,
+  beforeEach,
+  describe,
+  it,
+  suite,
+  test
+} = require('node:test')
+
+function bdd (target = globalThis) {
+  Object.assign(target, {
+    after,
+    afterEach,
+    before,
+    beforeEach,
+    context: describe,
+    describe,
+    it,
+    specify: it
+  })
+}
+
+function tdd (target = globalThis) {
+  Object.assign(target, {
+    suite,
+    suiteSetup: before,
+    suiteTeardown: after,
+    setup: before,
+    teardown: after,
+    test
+  })
+}
+
+function expose (name, target = globalThis) {
+  switch (name) {
+    case 'bdd': return bdd(target)
+    case 'tdd': return tdd(target)
+  }
+}
+
+module.exports = {
+  expose,
+  bdd,
+  tdd
+}
+
+// Auto-assign as side-effect!
+if (process.env.SPARK_UI)
+  expose(process.env.SPARK_UI)

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "spark-chamber",
+  "productName": "spark",
+  "version": "0.1.0-alpha.0",
+  "description": "The Electron test runner",
+  "main": "lib/main.js",
+  "exports": {
+    ".": "./lib/spark.js",
+    "./config": "./lib/config.js",
+    "./init": "./lib/init.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "type": "module",
+  "bin": {
+    "spark": "./bin/spark.cjs"
+  },
+  "scripts": {
+    "lint": "eslint eslint.config.js bin lib test",
+    "prepublishOnly": "npm run lint && npm test",
+    "test": "npm run test:spark && npm run test:node",
+    "test:spark": "electron --no-sandbox . test/main/**/*.test.js -r test/renderer/**/*.test.js",
+    "test:node": "node --test test/cli.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inukshuk/spark.git"
+  },
+  "keywords": [
+    "electron",
+    "test",
+    "testing",
+    "coverage"
+  ],
+  "author": "Sylvester Keil <sylvester@keil.or.at>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/inukshuk/spark/issues"
+  },
+  "homepage": "https://github.com/inukshuk/spark#readme",
+  "engines": {
+    "node": ">=24"
+  },
+  "peerDependencies": {
+    "electron": ">=40"
+  },
+  "peerDependenciesMeta": {
+    "electron": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "electron": "^41.0.2",
+    "eslint": "^9.5.0",
+    "neostandard": "^0.13.0"
+  }
+}