browser-ava 1.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2021-2022 by arlac77
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,32 @@
+[![npm](https://img.shields.io/npm/v/browser-ava.svg)](https://www.npmjs.com/package/browser-ava)
+[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Open Bundle](https://bundlejs.com/badge-light.svg)](https://bundlejs.com/?q=browser-ava)
+[![downloads](http://img.shields.io/npm/dm/browser-ava.svg?style=flat-square)](https://npmjs.org/package/browser-ava)
+[![GitHub Issues](https://img.shields.io/github/issues/arlac77/browser-ava.svg?style=flat-square)](https://github.com/arlac77/browser-ava/issues)
+[![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Farlac77%2Fbrowser-ava%2Fbadge\&style=flat)](https://actions-badge.atrox.dev/arlac77/browser-ava/goto)
+[![Coverage Status](https://coveralls.io/repos/arlac77/browser-ava/badge.svg)](https://coveralls.io/github/arlac77/browser-ava)
+# browser-ava
+Run ava tests in the browser
+
+
+## What it does
+
+If your code does not depend on any node api (process, fs, ...) then this runner allows to run your ava test inside the browser.
+
+### Running your tests
+
+```console
+browser-ava --webkit --chromium --firefox tests/*.mjs
+```
+
+
+## limitations
+
+- only supports ESM
+
+
+## install
+
+```console
+npm -g install browser-ava
+```

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "browser-ava",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Run ava tests in the browser",
+  "keywords": [
+    "ava",
+    "runner",
+    "test",
+    "testing"
+  ],
+  "contributors": [
+    {
+      "name": "Markus Felten",
+      "email": "markus.felten@gmx.de"
+    }
+  ],
+  "license": "BSD-2-Clause",
+  "bin": {
+    "browser-ava": "src/browser-ava-cli.mjs"
+  },
+  "scripts": {
+    "test": "npm run test:ava",
+    "test:ava": "ava --timeout 2m tests/*.mjs",
+    "cover": "c8 -x 'tests/**/*' --temp-directory build/tmp ava --timeout 2m tests/*.mjs && c8 report -r lcov -o build/coverage --temp-directory build/tmp"
+  },
+  "dependencies": {
+    "commander": "^9.4.1",
+    "es-module-lexer": "^1.0.5",
+    "koa": "^2.13.4",
+    "koa-static": "^5.0.0",
+    "playwright": "^1.27.1",
+    "ws": "^8.9.0"
+  },
+  "devDependencies": {
+    "ava": "^5.0.1",
+    "c8": "^7.12.0",
+    "execa": "^6.1.0",
+    "semantic-release": "^19.0.5"
+  },
+  "engines": {
+    "node": ">=16.18.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arlac77/browser-ava.git"
+  },
+  "bugs": {
+    "url": "https://github.com/arlac77/browser-ava/issues"
+  },
+  "homepage": "https://github.com/arlac77/browser-ava#readme",
+  "template": {
+    "inheritFrom": [
+      "arlac77/template-arlac77-github",
+      "arlac77/template-node-app"
+    ]
+  }
+}

package/src/browser/ava.mjs

@@ -0,0 +1,87 @@
+/**
+ * Holds all tests
+ */
+export const testModules = [];
+
+/**
+ * Collect all tests into testModules
+ */
+export default function test(body, ...args) {
+  let title;
+  if (typeof body === "string") {
+    title = body;
+    body = args.shift();
+  }
+
+  if (body.title) {
+    title = body.title(title, ...args);
+  }
+
+  const def = { title, body, args };
+  testModules.at(-1).tests.push(def);
+  return def;
+}
+
+test.failing = (...args) => {
+  test(...args).failing = true;
+};
+
+test.skip = (...args) => {
+  test(...args).skip = true;
+};
+
+test.only = (...args) => {
+  test(...args).only = true;
+};
+
+test.serial = (...args) => {
+  test(...args).serial = true;
+};
+
+test.todo = title => {
+  const def = { title, todo: true };
+  testModules.at(-1).tests.push(def);
+};
+
+test.serial.todo = test.todo;
+
+test.before = (...args) => {
+  const def = { args };
+  testModules.at(-1).before.push(def);
+  return def;
+};
+
+test.serial.before = (...args) => {
+  test.before(...args).serial = true;
+};
+
+test.after = (...args) => {
+  const def = { args };
+  testModules.at(-1).after.push(def);
+  return def;
+};
+test.after.always = (...args) => {
+  test.after(...args).always = true;
+};
+
+test.serial.after = (...args) => {
+  test.after(...args).serial = true;
+};
+
+test.beforeEach = (...args) => {
+  const def = { args };
+  testModules.at(-1).beforeEach.push(def);
+  return def;
+};
+test.beforeEach.always = (...args) => {
+  test.beforeEach(...args).always = true;
+};
+
+test.afterEach = (...args) => {
+  const def = { args };
+  testModules.at(-1).afterEach.push(def);
+  return def;
+};
+test.afterEach.always = () => {
+  test.afterEach(...args).always = true;
+};

package/src/browser/eql.mjs

@@ -0,0 +1,73 @@
+export function isEqual(a, b) {
+  if (a !== undefined && b === undefined) {
+    return false;
+  }
+
+  if (isScalar(a)) {
+    return Object.is(a, b);
+  }
+
+  if (Array.isArray(a)) {
+    if (a.length === b.length) {
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  if (typeof a === "object") {
+    if (a instanceof Set) {
+      return (
+        b instanceof Set &&
+        a.size === b.size &&
+        [...a].every((value) => b.has(value))
+      );
+    }
+    if (a instanceof Map) {
+      if (!(b instanceof Map) || a.size !== b.size) {
+        return false;
+      }
+      for (const [k, v] of a.entries()) {
+        if (!isEqual(v, b.get(k))) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    for (const key of new Set(Object.keys(a).concat(Object.keys(b)))) {
+      if (!isEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  return true;
+}
+
+const scalarTypes = new Set([
+  "symbol",
+  "undefined",
+  "string",
+  "number",
+  "bigint",
+  "boolean",
+]);
+
+export function isScalar(a) {
+  return (
+    scalarTypes.has(typeof a) ||
+    a instanceof String ||
+    a instanceof Number ||
+    a instanceof Function ||
+    a === null
+  );
+}

package/src/browser/index.css

@@ -0,0 +1,40 @@
+
+.running {
+    font-weight: bold;
+}
+
+.passed {
+    color: #006100;
+    background-color: #c6efce;
+}
+
+.failed {
+    color: #9c0006;
+    background-color: #ffc7ce;
+}
+
+.todo, .skip {
+    color: #9c6500;
+    background-color: #ffeb9c;
+}
+#summary {
+    font-weight: bold;
+    padding: 20px 50px;
+}
+.hidePassed ~ ul>li.passed,
+.hidePassed>ul>li.passed {display: none;}
+.module{
+    cursor: pointer;
+}
+.module::marker {
+    content: "▼ ";//⮟
+}
+.module.hidePassed::marker {
+    content: "▶ ";//➤
+}
+li:has(>.module)::marker {
+    content: "▼ ";//⮟
+}
+li:has(>.module.hidePassed)::marker {
+    content: "▶ ";//➤
+}

package/src/browser/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf8" />
+    <meta name="application-name" content="AVA test runner"/>
+    <title>AVA test runner</title>
+    <link rel="stylesheet" href="index.css" />
+    <script type="module" src="runtime.mjs"></script>
+  </head>
+  <body>
+    <button id="run">run</button>
+    <div id="tests"></div>
+    <div id="summary"></div>
+  </body>
+</html>

package/src/browser/runtime.mjs

@@ -0,0 +1,427 @@
+import { testModules } from "./ava.mjs";
+import { calculateSummary, summaryMessages, pluralize, stringify } from "./util.mjs";
+import { isEqual } from "./eql.mjs";
+
+let ws = new WebSocket(`ws://${location.host}`);
+ws.onerror = console.error;
+
+/*
+ forward console info,log,error to the server
+ */
+for (const slot of ["log", "info", "error"]) {
+  const former = console[slot];
+
+  console[slot] = (...args) => {
+    if (ws) {
+      ws.send(stringify({ action: slot, data: args }));
+    }
+    former(...args);
+  };
+}
+
+ws.onmessage = async message => {
+  const data = JSON.parse(message.data);
+  switch (data.action) {
+    case "load":
+      {
+        testModules.length = 0;
+        let errors = 0;
+        for (const tm of data.data) {
+          tm.logs = [];
+          tm.tests = [];
+          tm.before = [];
+          tm.after = [];
+          tm.beforeEach = [];
+          tm.afterEach = [];
+          testModules.push(tm);
+          try {
+            await import(new URL(tm.url, import.meta.url));
+          } catch (e) {
+            errors++;
+            console.error(e.toString());
+            tm.logs.push(`error importing ${tm.url} ${e}`);
+          }
+        }
+
+        displayTests();
+        if (errors === 0) {
+          ws.send(stringify({ action: "ready" }));
+        }
+      }
+      break;
+    case "run": {
+      await runTestModules();
+    }
+  }
+};
+
+async function displayTests() {
+  function renderTest(t) {
+    return `<li class="test ${
+      t.passed === true
+        ? "passed"
+        : t.passed === false
+        ? "failed"
+        : t.skip
+        ? "skip"
+        : t.todo
+        ? "todo"
+        : ""
+    }">${t.title} <span>${
+      t.assertions
+        ? t.assertions
+            .filter(a => !a.passed)
+            .map(a => (a.title || "") + " " + (a.message || ""))
+            .join(" ")
+        : ""
+    }</span>${t.message ? t.message : ""}</li>`;
+  }
+
+  function renderModule(tm) {
+    const passedTestsCount = tm.tests.filter(t => t.passed).length;
+    const allTestsCount = tm.tests.length;
+    return `<li id="${tm.file}" class="module${
+      passedTestsCount === allTestsCount ? " passed" : ""
+    }">
+      <span class="moduleName">${tm.file}</span>
+      <span class="moduleSummary"> ( ${passedTestsCount} / ${allTestsCount} ${pluralize(
+      "test",
+      allTestsCount
+    )} passed )</span>
+      <div class="logs">${tm.logs.join("<br/>")}</div>
+      <ul>${tm.tests.map(renderTest).join("\n")}</ul>
+      </li>`;
+  }
+
+  const tests = document.getElementById("tests");
+  tests.innerHTML = `<ul class="wrapper"><li>
+      <span class="all module">ALL TESTS</span>
+      <ul class="allTests">${testModules.map(renderModule).join("\n")}</ul>
+      </li></ul>`;
+
+  tests.querySelectorAll(".module").forEach(elem => {
+    elem.onclick = switchPassed;
+    manualSwitchPassed(elem);
+  });
+  function switchPassed() {
+    manualSwitchPassed(this);
+    console.log(this);
+  }
+  function manualSwitchPassed(elem) {
+    elem.classList.toggle("hidePassed");
+  }
+
+  document.getElementById("summary").innerHTML = summaryMessages(
+    calculateSummary(testModules)
+  )
+    .map(m => m.html)
+    .join("");
+}
+
+async function execHooks(hooks, t) {
+  if (hooks.length > 0) {
+    await Promise.all(
+      hooks.map(async h => {
+        h.args[typeof h.args[0] === "string" ? 1 : 0](t);
+      })
+    );
+  }
+}
+
+async function runTest(parent, tm, test) {
+  if (!test.skip && !test.todo) {
+    const t = testContext(test, parent);
+
+    try {
+      await execHooks(tm.beforeEach, t);
+
+      if (t.ms) {
+        t.timer = setTimeout(() => {
+          t.passed = false;
+          t.log("Test timeout exceeded");
+        }, t.ms);
+      }
+
+      await test.body(t, ...test.args);
+
+      if (t.timer) {
+        clearTimeout(t.timer);
+        delete t.timer;
+      }
+
+      for (const td of t.teardowns.reverse()) {
+        await td();
+      }
+
+      await execHooks(tm.afterEach, t);
+
+      if (test.assertions.length === 0) {
+        test.passed = false;
+        test.message = "Test finished without running any assertions";
+      } else {
+        test.passed = !test.assertions.find(
+          a => a.passed !== true && !a.skipped
+        );
+
+        if (t.planned !== undefined && t.planned !== test.assertions.length) {
+          test.passed = false;
+          test.message = `Planned for ${t.planned} assertions, but got ${test.assertions.length}`;
+        }
+      }
+    } catch (e) {
+      test.passed = false;
+      test.message = e;
+    }
+  }
+}
+
+const runButton = document.getElementById("run");
+
+/**
+ * run serial tests before all others
+ */
+async function runTestModule(tm) {
+  runButton.classList.add("running");
+
+  try {
+    tm.logs = [];
+
+    const t = {
+      context: {},
+      log(...args) {
+        tm.logs.push(args);
+      }
+    };
+
+    await execHooks(tm.before, t);
+
+    for (const test of tm.tests.filter(test => test.serial)) {
+      await runTest(t, tm, test);
+    }
+
+    await Promise.all(
+      tm.tests.filter(test => !test.serial).map(test => runTest(t, tm, test))
+    );
+
+    await execHooks(tm.after, t);
+  } finally {
+    runButton.classList.remove("running");
+  }
+}
+
+async function runTestModules() {
+  await Promise.all(testModules.map(tm => runTestModule(tm)));
+
+  ws.send(stringify({ action: "result", data: testModules }));
+
+  displayTests();
+}
+
+runButton.onclick = runTestModules;
+
+function testContext(def, parentContext) {
+  def.assertions = [];
+  def.logs = [];
+
+  function throwsExpectationHandler(e, expectation, title) {
+    if (expectation !== undefined) {
+      for (const slot of ["name", "code", "is"]) {
+        if (expectation[slot] !== undefined) {
+          if (expectation[slot] !== e[slot]) {
+            def.assertions.push({
+              passed: false,
+              message: `expected ${slot}=${expectation[slot]} but got ${e[slot]}`,
+              title
+            });
+            return;
+          }
+        }
+      }
+      if (expectation.message !== undefined) {
+        const slot = "message";
+        if (expectation.message instanceof RegExp) {
+          if (!expectation.message.test(e.message)) {
+            def.assertions.push({
+              passed: false,
+              message: `${slot} does not match ${expectation[slot]}`,
+              title
+            });
+            return;
+          }
+        }
+
+        if (typeof expectation.message === "string") {
+          if (expectation[slot] !== e[slot]) {
+            def.assertions.push({
+              passed: false,
+              message: `expected ${slot}=${expectation[slot]} but got ${e[slot]}`,
+              title
+            });
+            return;
+          }
+        }
+      }
+    }
+
+    def.assertions.push({ passed: true, title });
+  }
+
+  const assertions = {
+    pass(title) {
+      def.assertions.push({ passed: true, title });
+    },
+    fail(title) {
+      def.assertions.push({
+        passed: false,
+        title,
+        message: "Test failed via `t.fail()`"
+      });
+    },
+
+    throws(a, expectation, title) {
+      try {
+        a();
+        def.assertions.push({
+          passed: false,
+          title,
+          message: "Expected exception to be thrown"
+        });
+      } catch (e) {
+        throwsExpectationHandler(e, expectation, title);
+      }
+    },
+
+    async throwsAsync(a, expectation, title) {
+      try {
+        await a();
+        def.assertions.push({
+          passed: false,
+          title,
+          message: "Expected exception to be thrown"
+        });
+      } catch (e) {
+        throwsExpectationHandler(e, expectation, title);
+      }
+    },
+
+    notThrows(a, title) {
+      try {
+        a();
+      } catch (e) {
+        def.assertions.push({
+          passed: false,
+          title,
+          message: `Unexpected exception ${e}`
+        });
+      }
+    },
+
+    async notThrowsAsync(a, title) {
+      try {
+        await a();
+      } catch (e) {
+        def.assertions.push({
+          passed: false,
+          title,
+          message: `Unexpected exception ${e}`
+        });
+      }
+    },
+
+    deepEqual(a, b, title) {
+      def.assertions.push({
+        passed: isEqual(a, b),
+        message: `${a} != ${b}`,
+        title
+      });
+    },
+    notDeepEqual(a, b, title) {
+      def.assertions.push({
+        passed: !isEqual(a, b),
+        message: `${a} = ${b}`,
+        title
+      });
+    },
+
+    regex(contents, regex, message) {
+      def.assertions.push({
+        passed: contents.match(regex) ? true : false,
+        message: `${contents} matches ${regex}`
+      });
+    },
+    notRegex(contents, regex, message) {
+      def.assertions.push({
+        passed: contents.match(regex) ? false : true,
+        message: `${contents} matches ${regex}`
+      });
+    },
+
+    is(a, b, title) {
+      def.assertions.push({
+        passed: Object.is(a, b),
+        message: `${a} != ${b}`,
+        title
+      });
+    },
+    not(a, b, title) {
+      def.assertions.push({
+        passed: !Object.is(a, b),
+        message: `${a} = ${b}`,
+        title
+      });
+    },
+
+    true(value, title) {
+      def.assertions.push({
+        passed: value === true,
+        message: `${value} != true`,
+        title
+      });
+    },
+    truthy(value, title) {
+      def.assertions.push({
+        passed: value ? true : false,
+        message: `${value} is not truthy`,
+        title
+      });
+    },
+    false(value, title) {
+      def.assertions.push({
+        passed: value === false,
+        message: `${value} != false`,
+        title
+      });
+    },
+    falsy(value, title) {
+      def.assertions.push({
+        passed: value ? false : true,
+        message: `${value} is not falsy`,
+        title
+      });
+    }
+  };
+
+  Object.values(assertions).forEach(
+    assertion => (assertion.skip = () => def.assertions.push({ skipped: true }))
+  );
+
+  return {
+    ...assertions,
+    ...parentContext,
+    teardowns: [],
+    title: def.title,
+    log(...args) {
+      def.logs.push(args);
+    },
+
+    plan(count) {
+      this.planned = count;
+    },
+    teardown(fn) {
+      this.teardowns.push(fn);
+    },
+    timeout(ms) {
+      this.ms = ms;
+    }
+  };
+}

package/src/browser/util.mjs

@@ -0,0 +1,72 @@
+export function calculateSummary(testModules) {
+  let failed = 0,
+    knownFailure = 0,
+    todo = 0,
+    skip = 0,
+    passed = 0;
+
+  for (const tm of testModules) {
+    for (const test of tm.tests) {
+      if (test.skip) {
+        skip++;
+      } else {
+        if (test.todo) {
+          todo++;
+        } else {
+          if (test.passed) {
+            passed++;
+          } else {
+            if (test.failing) {
+              knownFailure++;
+            } else {
+              if (test.passed === false) {
+                failed++;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { passed, failed, knownFailure, skip, todo };
+}
+
+export function pluralize(word, number) {
+  return number > 1 ? word + "s" : word;
+}
+export function summaryMessages(summary) {
+  const messages = [];
+
+  function message(number, word, template, colorClass = "") {
+    if (number >= 1) {
+      const text = template
+        .replace(/{number}/, number)
+        .replace(/{word}/, pluralize(word, number));
+      messages.push({
+        colorClass,
+        text,
+        html: `<div class="${colorClass}">${text}</div>`
+      });
+    }
+  }
+
+  message(summary.passed, "test", "{number} {word} passed", "passed");
+  message(summary.failed, "test", "{number} {word} failed", "failed");
+  message(summary.knownFailure, "failure", "{number} known {word}", "failed");
+  message(summary.skip, "test", "{number} {word} skipped", "skip");
+  message(summary.todo, "test", "{number} {word} todo", "todo");
+
+  return messages;
+}
+
+/**
+ * @TODO HACK to be able to sent BigInt
+ */
+export function stringify(...args) {
+  const former = BigInt.prototype.toJSON;
+  BigInt.prototype.toJSON = (v) => v.toString();
+  const string = JSON.stringify(...args);
+  BigInt.prototype.toJSON = former;
+  return string;
+}

package/src/browser-ava-cli.mjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { init, parse } from "es-module-lexer";
+import { chromium, firefox, webkit } from "playwright";
+import Koa from "koa";
+import Static from "koa-static";
+import { WebSocketServer } from "ws";
+import { program, Option } from "commander";
+import { calculateSummary, summaryMessages } from "./browser/util.mjs";
+import { resolveImport } from "./resolver.mjs";
+
+const utf8EncodingOptions = { encoding: "utf8" };
+
+const { version, description } = JSON.parse(
+  readFileSync(
+    new URL("../package.json", import.meta.url).pathname,
+    utf8EncodingOptions
+  )
+);
+
+const knownBrowsers = {
+  chromium: chromium,
+  firefox: firefox,
+  webkit: webkit,
+  safari: webkit
+};
+
+const browsers = [];
+let openBrowsers = [];
+
+Object.entries(knownBrowsers).forEach(([name, browser]) => {
+  program.option(`--${name}`, `run tests against ${name} browser`, () =>
+    browsers.push(browser)
+  );
+});
+
+program
+  .description(description)
+  .version(version)
+  .addOption(
+    new Option("-p, --port <number>", "server port to use")
+      .default(8080)
+      .env("PORT")
+  )
+  .addOption(
+    new Option("-b, --browser <name>", "browser to use").env("BROWSER")
+  )
+  .option("--headless", "hide browser window", false)
+  .option(
+    "--no-keep-open",
+    "keep browser-ava and the page open after execution",
+    true
+  )
+  .argument("<tests...>")
+  .action(async (tests, options) => {
+    if (options.browser) {
+      browsers.push(knownBrowsers[options.browser]);
+    }
+
+    if (browsers.length === 0) {
+      console.error(
+        "No browsers selected use --webkit, --chromium and/or --firefox"
+      );
+      process.exit(2);
+    }
+
+    await init;
+
+    tests = tests.map(file => {
+      return { url: resolve(process.cwd(), file), file };
+    });
+
+    const { server, wss } = await createServer(tests, options);
+
+    async function shutdown(failed, force) {
+      if (!options.keepOpen || force) {
+        await Promise.all(openBrowsers.map(browser => browser.close()));
+        server.close();
+        process.exit(force ? 2 : failed ? 1 : 0);
+      }
+    }
+
+    let errors = 0;
+
+    wss.on("connection", ws => {
+      ws.on("message", async data => {
+        data = JSON.parse(data);
+        switch (data.action) {
+          case "info":
+            console.info(...data.data);
+            break;
+          case "log":
+            console.log(...data.data);
+            break;
+          case "error":
+            errors++;
+            console.error(...data.data);
+            await shutdown(undefined, true);
+            break;
+
+          case "ready":
+            ws.send(JSON.stringify({ action: "run" }));
+            break;
+          case "result":
+            const summary = calculateSummary(data.data);
+
+            for (const m of summaryMessages(summary)) {
+              console.log(m.text);
+            }
+
+            await shutdown(summary.failed);
+        }
+      });
+
+      ws.send(
+        JSON.stringify({
+          action: "load",
+          data: tests
+        })
+      );
+    });
+
+    openBrowsers = await Promise.all(
+      browsers.map(async b => {
+        const browser = await b.launch({ headless: options.headless });
+        const page = await browser.newPage();
+        await page.goto(`http://localhost:${options.port}/index.html`);
+        return browser;
+      })
+    );
+  });
+
+program.parse(process.argv);
+
+
+async function loadAndRewriteImports(file) {
+  let body = await readFile(file, utf8EncodingOptions);
+
+  const [imports] = parse(body);
+
+  let d = 0;
+
+  for (const i of imports) {
+    let m;
+
+    if (i.n === "ava") {
+      //  m = new URL("browser/ava.mjs", import.meta.url).pathname;
+      m = "/ava.mjs";
+    }
+
+    if (!m) {
+      m = await resolveImport(i.n, resolve(process.cwd(), file));
+    }
+
+    if (m) {
+      body = body.substring(0, i.s + d) + m + body.substring(i.e + d);
+      d += m.length - i.n.length;
+    } else {
+      console.warn(`Unable to resolve "${i.n}" may lead to import errors`);
+    }
+  }
+
+  return body;
+}
+
+async function createServer(tests, options) {
+  const app = new Koa();
+
+  app.use(Static(new URL("./browser", import.meta.url).pathname));
+
+  app.on("error", console.error);
+
+  app.use(async (ctx, next) => {
+    const path = ctx.request.path;
+
+    if (path.endsWith(".mjs") || path.endsWith(".js")) {
+      ctx.response.type = "text/javascript";
+      ctx.body = await loadAndRewriteImports(path);
+      return;
+    }
+
+    await next();
+  });
+
+  const server = await new Promise((resolve, reject) => {
+    const server = app.listen(options.port, error => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(server);
+      }
+    });
+  });
+
+  const wss = new WebSocketServer({ server });
+
+  return {
+    server,
+    wss
+  };
+}

package/src/resolver.mjs

@@ -0,0 +1,114 @@
+import { join, dirname, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+
+const utf8EncodingOptions = { encoding: "utf8" };
+
+/**
+ * Order in which imports are searched
+ * @see {https://nodejs.org/dist/latest/docs/api/packages.html#imports}
+ */
+const importsConditionOrder = ["browser", "default"];
+
+/**
+ * Order in which exports are searched
+ * @see {https://nodejs.org/dist/latest/docs/api/packages.html#exports}
+ */
+const exportsConditionOrder = ["browser", "import", ".", "default"];
+
+/**
+ * find module inside a package
+ * @param {string} parts
+ * @param {Object} pkg package.json content
+ * @returns {string|undefined} module file name relative to package
+ */
+export function resolveExports(parts, pkg) {
+  function matchingCondition(value) {
+    switch (typeof value) {
+      case "string":
+        return value;
+      case "object":
+        for (const condition of exportsConditionOrder) {
+          if (value[condition]) {
+            return value[condition];
+          }
+        }
+    }
+  }
+
+  if (parts[0] === pkg.name) {
+    switch (parts.length) {
+      case 1:
+        return matchingCondition(pkg.exports) || pkg.main || "index.js";
+      default:
+        return matchingCondition(pkg.exports["./" + parts.slice(1).join("/")]);
+    }
+  }
+}
+
+export function resolveImports(name, pkg) {
+  if (name.match(/^#/)) {
+    const importSlot = pkg.imports[name];
+    if (importSlot) {
+      for (const condition of importsConditionOrder) {
+        if (importSlot[condition]) {
+          return importSlot[condition];
+        }
+      }
+    }
+  }
+}
+
+async function loadPackage(path) {
+  try {
+    return JSON.parse(
+      await readFile(join(path, "package.json"), utf8EncodingOptions)
+    );
+  } catch (e) {
+    if (e.code !== "ENOTDIR" && e.code !== "ENOENT") {
+      throw e;
+    }
+  }
+}
+
+async function findPackage(path) {
+  while (path.length) {
+    const pkg = await loadPackage(path);
+    if (pkg) {
+      return {
+        path,
+        pkg
+      };
+    }
+    path = dirname(path);
+  }
+}
+
+/**
+ * Maps import url from node to browser view. 
+ * @param {string} name module to resolve
+ * @param {string} file where to start resolving (base) 
+ * @returns {Promise<string>} resolved import url
+ */
+export async function resolveImport(name, file) {
+  if (name.match(/^[\/\.]/)) {
+    return resolve(dirname(file), name);
+  }
+  let { pkg, path } = await findPackage(file);
+
+  const parts = name.split(/\//);
+
+  const e = resolveExports(parts, pkg) || resolveImports(name, pkg);
+
+  if (e) {
+    return join(path, e);
+  }
+
+  while (path.length > 1) {
+    const p = join(path, "node_modules", parts[0]);
+    pkg = await loadPackage(p);
+    if (pkg) {
+      return join(p, resolveExports(parts, pkg));
+    }
+    path = dirname(dirname(path));
+  }
+}