@aljazmc/testero 0.4.3 → 0.5.0

package/bin/main.js

@@ -21,22 +21,33 @@ var init_pattern = __esm({
         __name(this, "Pattern");
       }
       #anchored;
+      #directories;
       #regex;
-      constructor(source) {
+      /** With the name of the setting the glob comes from, for its errors. */
+      constructor(source, setting = "glob") {
+        this.#directories = /[^/]\/+$/.test(source);
         const glob = source.replace(/^\.?\/+|\/+$/g, "");
-        this.#anchored = glob.includes("/");
-        this.#regex = new RegExp(`^${_Pattern.#toRegex(glob)}$`);
+        this.#anchored = glob.includes("/") || /^\.?\//.test(source);
+        this.#regex = new RegExp(
+          `^${_Pattern.#toRegex(glob, source, setting)}$`
+        );
       }
-      matches(path) {
+      /**
+       * Whether a path, or a folder it is in, matches. Whether the path itself
+       * is a folder matters to globs ending with `/`.
+       */
+      matches(path, directory = false) {
         const segments = path.split("/");
-        return segments.some(
-          (segment, index) => this.#regex.test(
+        return segments.some((segment, index) => {
+          if (this.#directories && index === segments.length - 1 && !directory)
+            return false;
+          return this.#regex.test(
             this.#anchored ? segments.slice(0, index + 1).join("/") : segment
-          )
-        );
+          );
+        });
       }
       /** Translates `**`, `*`, `?` and `{a,b}` alternatives, other characters match themselves. */
-      static #toRegex(glob) {
+      static #toRegex(glob, source, setting) {
         const tokens = {
           "**/": "(?:.*/)?",
           "**": ".*",
@@ -46,7 +57,7 @@ var init_pattern = __esm({
         let regex = "";
         let braces = 0;
         for (const [token] of glob.matchAll(/\*\*\/|\*\*|[\s\S]/g)) {
-          if (token in tokens) regex += tokens[token] ?? token;
+          if (Object.hasOwn(tokens, token)) regex += tokens[token];
           else if (token === "{") {
             braces++;
             regex += "(?:";
@@ -56,6 +67,10 @@ var init_pattern = __esm({
           } else if (token === "," && braces > 0) regex += "|";
           else regex += token.replace(/[.+^${}()|[\]\\]/g, "\\$&");
         }
+        if (braces > 0)
+          throw new Error(
+            `Invalid ${setting} ${JSON.stringify(source)}: a { is not closed by a }.`
+          );
         return regex;
       }
     };
@@ -74,18 +89,28 @@ var init_ignore = __esm({
       }
       #patterns;
       constructor(sources) {
-        this.#patterns = sources.map((source) => new Pattern(source));
+        this.#patterns = sources.map((source) => new Pattern(source, "ignore"));
       }
-      matches(path) {
+      /** Whether a path is ignored, globs ending with `/` only ignore folders. */
+      matches(path, directory = false) {
         const normalized = path.replaceAll("\\", "/").replace(/^\.\//, "");
-        return this.#patterns.some((pattern) => pattern.matches(normalized));
+        return this.#patterns.some(
+          (pattern) => pattern.matches(normalized, directory)
+        );
       }
     };
   }
 });
 
 // shared/config/src/config.ts
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 var Config;
@@ -103,6 +128,11 @@ var init_config = __esm({
       rules;
       /** What the config file set, before the defaults were merged in. */
       custom;
+      /**
+       * Reports files and folders that are left out, like a broken symlink, an
+       * unreadable folder or a file that is not UTF-8, as a warning by default.
+       */
+      warn = /* @__PURE__ */ __name((message) => console.log(`warn: ${message}`), "warn");
       constructor(options, root = process.cwd(), custom = {}) {
         this.root = root;
         this.ignore = new Ignore(options.ignore);
@@ -114,6 +144,7 @@ var init_config = __esm({
           const file = join(root, `${name}.config.${extension}`);
           if (existsSync(file)) {
             const { default: options } = await import(pathToFileURL(file).href);
+            _Config.#check(`${name}.config.${extension}`, options);
             return new _Config(
               _Config.merge(defaults, options),
               root,
@@ -123,12 +154,26 @@ var init_config = __esm({
         }
         return new _Config(defaults, root);
       }
+      /** Fails clearly on a config file that does not export the shape of the defaults. */
+      static #check(file, options) {
+        if (options === void 0) return;
+        if (options?.constructor !== Object)
+          throw new Error(
+            `${file} must export default an object, like { ignore: [], rules: {} }, not ${Array.isArray(options) ? "an array" : typeof options}.`
+          );
+        const { ignore } = options;
+        if (ignore !== void 0 && !(Array.isArray(ignore) && ignore.every((item) => typeof item === "string")))
+          throw new Error(`${file}: ignore must be a list of strings.`);
+      }
       /** Handles `--config`, writing the defaults to a TypeScript config file, or with `--config js` a JavaScript one. Returns whether it was given. */
       static init(name, defaults, argv = process.argv.slice(2), root = process.cwd()) {
-        const index = argv.indexOf("--config");
+        const index = argv.findIndex(
+          (arg) => arg === "--config" || arg.startsWith("--config=")
+        );
         if (index === -1) return false;
-        const next = argv[index + 1];
-        const extension = next === void 0 || next.startsWith("-") ? "ts" : next;
+        const [, inline] = argv[index].split(/=(.*)/s);
+        const next = inline ?? argv[index + 1];
+        const extension = next === void 0 || next === "" || next.startsWith("-") ? "ts" : next;
         try {
           console.log(
             `created: ${_Config.export(name, defaults, extension, root)}`
@@ -188,24 +233,93 @@ ${items.map((item) => `${inner}${item},
           merged[key] = _Config.merge(base[key], value);
         return merged;
       }
+      /**
+       * The files that are not ignored, relative to the root. Symlinks are
+       * followed, a folder by every path to it, but not into a folder it is in,
+       * which would never end; broken symlinks and unreadable folders are
+       * reported and left out, like pipes and other special files.
+       */
       *files(directory = "") {
-        const entries = readdirSync(join(this.root, directory), {
-          withFileTypes: true
-        });
+        yield* this.#walk(directory, /* @__PURE__ */ new Set());
+      }
+      *#walk(directory, ancestors) {
+        const absolute = join(this.root, directory);
+        let entries;
+        let real;
+        try {
+          real = realpathSync(absolute);
+          if (ancestors.has(real)) return;
+          entries = readdirSync(absolute, { withFileTypes: true });
+        } catch (error) {
+          this.warn(
+            `${directory || "."}: the folder cannot be read (${_Config.#reason(error)}), left out.`
+          );
+          return;
+        }
+        ancestors.add(real);
         for (const entry of entries) {
           const path = directory ? `${directory}/${entry.name}` : entry.name;
-          if (this.ignore.matches(path)) continue;
-          if (entry.isDirectory()) yield* this.files(path);
-          else yield path;
+          let kind = entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "other";
+          if (entry.isSymbolicLink())
+            try {
+              const target = statSync(join(this.root, path));
+              kind = target.isDirectory() ? "directory" : target.isFile() ? "file" : "other";
+            } catch (error) {
+              if (!this.ignore.matches(path))
+                this.warn(
+                  `${path}: a broken symlink (${_Config.#reason(error)}), left out.`
+                );
+              continue;
+            }
+          if (this.ignore.matches(path, kind === "directory")) continue;
+          if (kind === "directory") yield* this.#walk(path, ancestors);
+          else if (kind === "file") yield path;
         }
+        ancestors.delete(real);
       }
-      /** Text files that are not ignored and that accepts takes, binaries are skipped. */
+      /**
+       * Text files that are not ignored and that accepts takes. Binaries, with
+       * a NUL byte, are skipped; files that are not UTF-8 are reported and
+       * skipped, as writing them back as UTF-8 would change their text.
+       */
       *sources(accepts = () => true) {
+        const utf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
         for (const file of this.files()) {
           if (!accepts(file)) continue;
           const path = join(this.root, file);
-          const text = readFileSync(path, "utf8");
-          if (!text.includes("\0")) yield { file, path, text };
+          let bytes;
+          try {
+            bytes = readFileSync(path);
+          } catch (error) {
+            this.warn(
+              `${file}: the file cannot be read (${_Config.#reason(error)}), left out.`
+            );
+            continue;
+          }
+          if (bytes.includes(0)) continue;
+          let text;
+          try {
+            text = utf8.decode(bytes);
+          } catch {
+            this.warn(`${file}: not UTF-8, left out.`);
+            continue;
+          }
+          yield { file, path, text };
+        }
+      }
+      /** Why a file system call failed, in words. */
+      static #reason(error) {
+        const code = error?.code;
+        switch (code) {
+          case "ENOENT":
+            return "its target does not exist";
+          case "EACCES":
+          case "EPERM":
+            return "no permission";
+          case "ELOOP":
+            return "a loop of symlinks";
+          default:
+            return error instanceof Error ? error.message : String(error);
         }
       }
     };
@@ -223,9 +337,10 @@ var init_includes = __esm({
         __name(this, "Includes");
       }
       #globs;
-      constructor(globs) {
+      /** With the name of the setting the globs come from, for their errors. */
+      constructor(globs, setting = "includes") {
         this.#globs = globs.map((glob) => ({
-          pattern: new Pattern(glob.replace(/^!/, "")),
+          pattern: new Pattern(glob.replace(/^!/, ""), setting),
           included: !glob.startsWith("!")
         }));
       }
@@ -249,11 +364,152 @@ var init_src = __esm({
   }
 });
 
+// packages/testero/src/expect/equality.ts
+var Equality;
+var init_equality = __esm({
+  "packages/testero/src/expect/equality.ts"() {
+    "use strict";
+    Equality = class _Equality {
+      static {
+        __name(this, "Equality");
+      }
+      /** Whether a value matches by its own rule, like `expect.any(Number)`. */
+      static asymmetric(value) {
+        return typeof value === "object" && value !== null && typeof value.asymmetricMatch === "function";
+      }
+      /**
+       * Whether two values are deeply equal. Loosely, properties set to
+       * undefined count as missing; strictly, types and holes in arrays count.
+       */
+      static equals(a, b, strict = false) {
+        return _Equality.#equals(a, b, strict, [], []);
+      }
+      /** Whether received has every property expected has, recursively, like `toMatchObject`. */
+      static matches(received, expected) {
+        if (_Equality.asymmetric(expected))
+          return expected.asymmetricMatch(received);
+        if (!_Equality.#plainish(expected) || typeof received !== "object" || received === null)
+          return _Equality.equals(received, expected);
+        if (Array.isArray(expected))
+          return Array.isArray(received) && received.length === expected.length && expected.every(
+            (item, index) => _Equality.matches(received[index], item)
+          );
+        return _Equality.#keys(expected, true).every(
+          (key) => key in received && _Equality.matches(
+            received[key],
+            expected[key]
+          )
+        );
+      }
+      /** Objects and arrays that `toMatchObject` compares by their properties. */
+      static #plainish(value) {
+        return typeof value === "object" && value !== null && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Error);
+      }
+      static #equals(a, b, strict, aSeen, bSeen) {
+        if (_Equality.asymmetric(a)) return a.asymmetricMatch(b);
+        if (_Equality.asymmetric(b)) return b.asymmetricMatch(a);
+        if (Object.is(a, b)) return true;
+        if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+          return false;
+        const tag = Object.prototype.toString.call(a);
+        if (tag !== Object.prototype.toString.call(b)) return false;
+        if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+          return false;
+        const bytes = _Equality.bytes(a);
+        if (bytes) return _Equality.#sameBytes(bytes, _Equality.bytes(b));
+        if (a instanceof URL) return a.href === b.href;
+        if (a instanceof Date)
+          return Object.is(a.getTime(), b.getTime());
+        if (a instanceof RegExp) return String(a) === String(b);
+        if (a instanceof Error && b instanceof Error)
+          return a.name === b.name && a.message === b.message;
+        if (a instanceof Number || a instanceof String || a instanceof Boolean)
+          return Object.is(
+            a.valueOf(),
+            b.valueOf()
+          );
+        const index = aSeen.indexOf(a);
+        if (index >= 0) return bSeen[index] === b;
+        aSeen.push(a);
+        bSeen.push(b);
+        try {
+          return _Equality.#structures(a, b, strict, aSeen, bSeen);
+        } finally {
+          aSeen.pop();
+          bSeen.pop();
+        }
+      }
+      /** The bytes of an ArrayBuffer, SharedArrayBuffer or DataView, undefined for other values. */
+      static bytes(value) {
+        if (value instanceof DataView)
+          return new Uint8Array(
+            value.buffer,
+            value.byteOffset,
+            value.byteLength
+          );
+        if (value instanceof ArrayBuffer || typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer)
+          return new Uint8Array(value);
+        return void 0;
+      }
+      static #sameBytes(a, b) {
+        return b !== void 0 && a.length === b.length && a.every((byte, index) => byte === b[index]);
+      }
+      static #structures(a, b, strict, aSeen, bSeen) {
+        const equal = /* @__PURE__ */ __name((x, y) => _Equality.#equals(x, y, strict, aSeen, bSeen), "equal");
+        if (a instanceof Map && b instanceof Map)
+          return a.size === b.size && [...a].every(
+            ([key, value]) => b.has(key) ? equal(value, b.get(key)) : [...b].some(
+              ([other, item]) => equal(key, other) && equal(value, item)
+            )
+          );
+        if (a instanceof Set && b instanceof Set)
+          return a.size === b.size && [...a].every(
+            (value) => b.has(value) || [...b].some((other) => equal(value, other))
+          );
+        if (Array.isArray(a) || ArrayBuffer.isView(a)) {
+          const left = a;
+          const right = b;
+          if (left.length !== right.length) return false;
+          for (let index = 0; index < left.length; index++) {
+            if (strict && index in left !== index in right) return false;
+            if (!equal(left[index], right[index])) return false;
+          }
+        }
+        const indexed = Array.isArray(a) || ArrayBuffer.isView(a);
+        const keysOf = /* @__PURE__ */ __name((object) => _Equality.#keys(object, strict).filter(
+          (key) => !(indexed && typeof key === "string" && /^\d+$/.test(key))
+        ), "keysOf");
+        const aKeys = keysOf(a);
+        const bKeys = keysOf(b);
+        if (aKeys.length !== bKeys.length) return false;
+        return aKeys.every(
+          (key) => Object.hasOwn(b, key) && equal(
+            a[key],
+            b[key]
+          )
+        );
+      }
+      /** Own enumerable keys, without the ones set to undefined unless strict. */
+      static #keys(object, strict) {
+        const record = object;
+        const keys = [
+          ...Object.keys(object),
+          ...Object.getOwnPropertySymbols(object).filter(
+            (symbol) => Object.getOwnPropertyDescriptor(object, symbol)?.enumerable
+          )
+        ];
+        return strict ? keys : keys.filter((key) => record[key] !== void 0);
+      }
+    };
+  }
+});
+
 // packages/testero/src/expect/format.ts
 var Format;
 var init_format = __esm({
   "packages/testero/src/expect/format.ts"() {
     "use strict";
+    init_equality();
     Format = class _Format {
       static {
         __name(this, "Format");
@@ -325,6 +581,7 @@ Received: ${_Format.inline(received)}`;
         if (value instanceof Date)
           return Number.isNaN(value.getTime()) ? "Date { NaN }" : value.toISOString();
         if (value instanceof RegExp) return String(value);
+        if (value instanceof URL) return `URL ${JSON.stringify(value.href)}`;
         if (value instanceof Error) return `[${value.name}: ${value.message}]`;
         if (seen.includes(value)) return "[Circular]";
         const inner = [...seen, value];
@@ -348,6 +605,15 @@ Received: ${_Format.inline(received)}`;
             indent,
             multiline
           );
+        const bytes = Equality.bytes(value);
+        if (bytes)
+          return _Format.#block(
+            `${name ?? "ArrayBuffer"} [`,
+            "]",
+            Array.from(bytes, String),
+            indent,
+            multiline
+          );
         if (Array.isArray(value) || ArrayBuffer.isView(value)) {
           const items = Array.from(value, print);
           const prefix2 = name && name !== "Array" ? `${name} [` : "[";
@@ -392,7 +658,11 @@ var init_each = __esm({
        */
       static rows(table, values) {
         if (_Each.#template(table)) {
-          const names = table.join("").trim().split(/\s*\|\s*/);
+          const names = (table[0] ?? "").trim().split(/\s*\|\s*/);
+          if (values.length % names.length !== 0)
+            throw new TypeError(
+              `each table has ${names.length} columns (${names.join(", ")}), but ${values.length} values do not fill whole rows`
+            );
           const rows = [];
           for (let index = 0; index < values.length; index += names.length)
             rows.push([
@@ -588,7 +858,8 @@ var init_collector = __esm({
           for (const [index, row] of Each.rows(table, values).entries())
             this.#test(
               Each.title(String(name), row, index),
-              () => body(...row),
+              // a parameter after the row's values is the done callback
+              body.length > row.length ? (done) => body(...row, done) : () => body(...row),
               mode,
               timeout
             );
@@ -714,9 +985,14 @@ var init_mock = __esm({
         this.state.instances.push(context);
         this.state.results.push(result);
         this.state.lastCall = args;
+        const index = this.state.instances.length - 1;
         const implementation = this.#once.shift() ?? this.#implementation;
         try {
           result.value = !implementation ? void 0 : target ? Reflect.construct(implementation, args, target) : implementation.apply(context, args);
+          if (target && typeof result.value === "object" && result.value) {
+            this.state.instances[index] = result.value;
+            this.state.contexts[index] = result.value;
+          }
           result.type = "return";
           return result.value;
         } catch (error) {
@@ -788,123 +1064,617 @@ var init_mock = __esm({
   }
 });
 
-// packages/testero/src/expect/equality.ts
-var Equality;
-var init_equality = __esm({
-  "packages/testero/src/expect/equality.ts"() {
+// packages/testero/src/globals.ts
+var Globals;
+var init_globals = __esm({
+  "packages/testero/src/globals.ts"() {
     "use strict";
-    Equality = class _Equality {
+    init_mock();
+    Globals = class _Globals {
       static {
-        __name(this, "Equality");
-      }
-      /** Whether a value matches by its own rule, like `expect.any(Number)`. */
-      static asymmetric(value) {
-        return typeof value === "object" && value !== null && typeof value.asymmetricMatch === "function";
-      }
-      /**
-       * Whether two values are deeply equal. Loosely, properties set to
-       * undefined count as missing; strictly, types and holes in arrays count.
-       */
-      static equals(a, b, strict = false) {
-        return _Equality.#equals(a, b, strict, [], []);
+        __name(this, "Globals");
       }
-      /** Whether received has every property expected has, recursively, like `toMatchObject`. */
-      static matches(received, expected) {
-        if (_Equality.asymmetric(expected))
-          return expected.asymmetricMatch(received);
-        if (!_Equality.#plainish(expected) || typeof received !== "object" || received === null)
-          return _Equality.equals(received, expected);
-        if (Array.isArray(expected))
-          return Array.isArray(received) && received.length === expected.length && expected.every(
-            (item, index) => _Equality.matches(received[index], item)
-          );
-        return _Equality.#keys(expected, true).every(
-          (key) => key in received && _Equality.matches(
-            received[key],
-            expected[key]
+      static key = /* @__PURE__ */ Symbol.for("testero");
+      static names = [
+        "describe",
+        "fdescribe",
+        "xdescribe",
+        "test",
+        "it",
+        "fit",
+        "xit",
+        "xtest",
+        "beforeAll",
+        "afterAll",
+        "beforeEach",
+        "afterEach",
+        "expect",
+        "testero",
+        "jest"
+      ];
+      /** The module the transformer injects, it reads the globals of the file being run. */
+      static source() {
+        return [
+          'const globals = globalThis[Symbol.for("testero")];',
+          ..._Globals.names.map(
+            (name) => `export const ${name} = globals.${name};`
           )
-        );
-      }
-      /** Objects and arrays that `toMatchObject` compares by their properties. */
-      static #plainish(value) {
-        return typeof value === "object" && value !== null && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Error);
+        ].join("\n");
       }
-      static #equals(a, b, strict, aSeen, bSeen) {
-        if (_Equality.asymmetric(a)) return a.asymmetricMatch(b);
-        if (_Equality.asymmetric(b)) return b.asymmetricMatch(a);
-        if (Object.is(a, b)) return true;
-        if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
-          return false;
-        const tag = Object.prototype.toString.call(a);
-        if (tag !== Object.prototype.toString.call(b)) return false;
-        if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
-          return false;
-        if (a instanceof Date)
-          return Object.is(a.getTime(), b.getTime());
-        if (a instanceof RegExp) return String(a) === String(b);
-        if (a instanceof Error && b instanceof Error)
-          return a.name === b.name && a.message === b.message;
-        if (a instanceof Number || a instanceof String || a instanceof Boolean)
-          return Object.is(
-            a.valueOf(),
-            b.valueOf()
-          );
-        const index = aSeen.indexOf(a);
-        if (index >= 0) return bSeen[index] === b;
-        aSeen.push(a);
-        bSeen.push(b);
-        try {
-          return _Equality.#structures(a, b, strict, aSeen, bSeen);
-        } finally {
-          aSeen.pop();
-          bSeen.pop();
-        }
+      /** Sets the globals for the next test file to import. */
+      static install(collector, expect, settings) {
+        const { describe, test } = collector;
+        const testero = {
+          fn: Mocks.fn,
+          spyOn: Mocks.spyOn,
+          isMockFunction: Mocks.isMockFunction,
+          clearAllMocks: /* @__PURE__ */ __name(() => {
+            Mocks.clearAll();
+            return testero;
+          }, "clearAllMocks"),
+          resetAllMocks: /* @__PURE__ */ __name(() => {
+            Mocks.resetAll();
+            return testero;
+          }, "resetAllMocks"),
+          restoreAllMocks: /* @__PURE__ */ __name(() => {
+            Mocks.restoreAll();
+            return testero;
+          }, "restoreAllMocks"),
+          /** Sets the timeout of the tests and hooks of this file. */
+          setTimeout: /* @__PURE__ */ __name((timeout) => {
+            settings.timeout = timeout;
+            return testero;
+          }, "setTimeout")
+        };
+        globalThis[_Globals.key] = {
+          describe,
+          fdescribe: describe.only,
+          xdescribe: describe.skip,
+          test,
+          it: test,
+          fit: test.only,
+          xit: test.skip,
+          xtest: test.skip,
+          beforeAll: collector.hook("beforeAll"),
+          afterAll: collector.hook("afterAll"),
+          beforeEach: collector.hook("beforeEach"),
+          afterEach: collector.hook("afterEach"),
+          expect: expect.create(),
+          testero,
+          jest: testero
+        };
       }
-      static #structures(a, b, strict, aSeen, bSeen) {
-        const equal = /* @__PURE__ */ __name((x, y) => _Equality.#equals(x, y, strict, aSeen, bSeen), "equal");
-        if (a instanceof Map && b instanceof Map)
-          return a.size === b.size && [...a].every(
-            ([key, value]) => b.has(key) ? equal(value, b.get(key)) : [...b].some(
-              ([other, item]) => equal(key, other) && equal(value, item)
+    };
+  }
+});
+
+// packages/testero/src/transformer.ts
+import { mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname, join as join2, resolve, sep } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { build } from "esbuild";
+var Transformer;
+var init_transformer = __esm({
+  "packages/testero/src/transformer.ts"() {
+    "use strict";
+    init_globals();
+    Transformer = class _Transformer {
+      static {
+        __name(this, "Transformer");
+      }
+      /** Packages test files import the globals from, like with Jest. */
+      static modules = ["@jest/globals", "@aljazmc/testero"];
+      static #loaders = {
+        ".js": "js",
+        ".cjs": "js",
+        ".mjs": "js",
+        ".jsx": "jsx",
+        ".ts": "ts",
+        ".cts": "ts",
+        ".mts": "ts",
+        ".tsx": "tsx"
+      };
+      /** The import.meta properties that describe the source file. */
+      static #meta = ["url", "filename", "dirname"];
+      /** CommonJS globals the ES module bundle lacks, mapped to the same descriptions. */
+      static #commonjs = {
+        __dirname: "dirname",
+        __filename: "filename"
+      };
+      /** Sources that refer to the location of their own file. */
+      static #located = /\bimport\.meta\b|\b__dirname\b|\b__filename\b/;
+      /** Marks the resolutions the plugin asks esbuild for itself. */
+      static #own = /* @__PURE__ */ Symbol("testero");
+      /** Where compiled test files go, stack frames there are testero's own. */
+      static prefix = join2(tmpdir(), "testero-build-");
+      #directory = mkdtempSync(_Transformer.prefix);
+      #globals = join2(this.#directory, "globals.mjs");
+      #count = 0;
+      /** The code of each compiled module by its path, with an inline source map, for coverage. */
+      bundles = /* @__PURE__ */ new Map();
+      #keep;
+      /** Keeps the code of the compiled modules in `bundles` when told. */
+      constructor(keep = false) {
+        this.#keep = keep;
+        writeFileSync2(this.#globals, Globals.source());
+      }
+      /** Bundles a test file, returns the URL of the module to import. */
+      async compile(file) {
+        const outfile = join2(this.#directory, `${++this.#count}.mjs`);
+        const { outputFiles } = await build({
+          ...this.#options(file),
+          outfile,
+          sourcemap: "inline",
+          sourcesContent: false,
+          // for coverage, code no test imports counts too
+          treeShaking: !this.#keep
+        });
+        const code = outputFiles[0]?.text ?? "";
+        writeFileSync2(outfile, code);
+        if (this.#keep) this.bundles.set(outfile, code);
+        return pathToFileURL2(outfile).href;
+      }
+      /** The absolute paths of the local files a test file is bundled from, itself included. */
+      async inputs(file) {
+        const { metafile } = await build({
+          ...this.#options(file),
+          metafile: true
+        });
+        return Object.keys(metafile.inputs).filter((input) => !/^[\w-]+:/.test(input)).map((input) => resolve(input)).filter((input) => input !== this.#globals);
+      }
+      /** What compiling and listing the inputs share. */
+      #options(file) {
+        return {
+          entryPoints: [file],
+          write: false,
+          bundle: true,
+          platform: "node",
+          format: "esm",
+          target: `node${process.versions.node.split(".")[0]}`,
+          inject: [this.#globals],
+          // defines replace only unbound names, so a file's own `__dirname` stays
+          define: Object.fromEntries([
+            ..._Transformer.#meta.map((name) => [
+              `import.meta.${name}`,
+              `__testero.${name}`
+            ]),
+            ...Object.entries(_Transformer.#commonjs).map(
+              ([name, property2]) => [name, `__testero.${property2}`]
             )
-          );
-        if (a instanceof Set && b instanceof Set)
-          return a.size === b.size && [...a].every(
-            (value) => b.has(value) || [...b].some((other) => equal(value, other))
-          );
-        if (Array.isArray(a) || ArrayBuffer.isView(a)) {
-          const left = a;
-          const right = b;
-          if (left.length !== right.length) return false;
-          for (let index = 0; index < left.length; index++) {
-            if (strict && index in left !== index in right) return false;
-            if (!equal(left[index], right[index])) return false;
+          ]),
+          // CommonJS code in the bundle may require installed packages
+          banner: {
+            js: 'import { createRequire as __testeroRequire } from "node:module";\nconst require = __testeroRequire(import.meta.url);'
+          },
+          logLevel: "silent",
+          plugins: [this.#plugin()]
+        };
+      }
+      /** The esbuild loader of a source file, undefined for files it does not compile. */
+      static loader(path) {
+        return _Transformer.#loaders[extname(path)];
+      }
+      /** Removes the compiled files. */
+      dispose() {
+        rmSync(this.#directory, { recursive: true, force: true });
+      }
+      #plugin() {
+        return {
+          name: "testero",
+          setup: /* @__PURE__ */ __name((build2) => {
+            build2.onResolve({ filter: /^testero-meta:/ }, (args) => ({
+              path: args.path.slice("testero-meta:".length),
+              namespace: "testero-meta"
+            }));
+            build2.onLoad(
+              { filter: /.*/, namespace: "testero-meta" },
+              (args) => ({
+                contents: `export default ${JSON.stringify({
+                  url: pathToFileURL2(args.path).href,
+                  filename: args.path,
+                  dirname: dirname(args.path)
+                })};`,
+                loader: "js"
+              })
+            );
+            build2.onResolve({ filter: /^[^./]/ }, async (args) => {
+              if (args.pluginData === _Transformer.#own) return void 0;
+              if (_Transformer.modules.includes(args.path))
+                return { path: this.#globals };
+              const resolved = await build2.resolve(args.path, {
+                kind: args.kind,
+                resolveDir: args.resolveDir,
+                pluginData: _Transformer.#own
+              });
+              if (resolved.errors.length > 0)
+                return { errors: resolved.errors };
+              if (resolved.external)
+                return { path: args.path, external: true };
+              if (!_Transformer.#installed(resolved.path))
+                return { path: resolved.path };
+              return {
+                path: args.kind === "require-call" ? resolved.path : pathToFileURL2(resolved.path).href,
+                external: true
+              };
+            });
+            build2.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+              if (_Transformer.#installed(args.path)) return void 0;
+              const source = readFileSync2(args.path, "utf8");
+              return {
+                contents: _Transformer.#locate(source, args.path),
+                loader: _Transformer.#loaders[extname(args.path)] ?? "js",
+                resolveDir: dirname(args.path)
+              };
+            });
+          }, "setup")
+        };
+      }
+      /**
+       * A source with `__testero` describing its file, when it refers to it.
+       * Modules import it after their last line, as imports are hoisted.
+       * CommonJS files, without import or export statements, require it at the
+       * start of their first line instead, as an import would make them modules
+       * and their `module.exports` would be lost.
+       */
+      static #locate(source, path) {
+        if (!_Transformer.#located.test(source)) return source;
+        const meta = JSON.stringify(`testero-meta:${path}`);
+        if (/\.m[jt]s$/.test(path) || /^\s*(?:import\s*[\w{*"']|export\b)/m.test(source))
+          return `${source}
+import __testero from ${meta};
+`;
+        const start = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+        if (source.startsWith("#!") && start === 0) return source;
+        return `${source.slice(0, start)}var __testero = require(${meta}).default;${source.slice(start)}`;
+      }
+      static #installed(path) {
+        return path.split(sep).includes("node_modules");
+      }
+    };
+  }
+});
+
+// packages/testero/src/coverage.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { Session } from "node:inspector/promises";
+import { dirname as dirname2, join as join3, relative, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { transform } from "esbuild";
+var Coverage;
+var init_coverage = __esm({
+  "packages/testero/src/coverage.ts"() {
+    "use strict";
+    init_transformer();
+    Coverage = class _Coverage {
+      static {
+        __name(this, "Coverage");
+      }
+      static #digits = (() => {
+        const digits = new Int8Array(128).fill(-1);
+        const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        for (let index = 0; index < alphabet.length; index++)
+          digits[alphabet.charCodeAt(index)] = index;
+        return digits;
+      })();
+      static #inline = /\/\/# sourceMappingURL=data:application\/json;base64,([\w+/=]+)\s*$/;
+      #root;
+      #tracks;
+      /** What runs within this one took, which reset the counts of this one. */
+      #taken = [];
+      #receive = /* @__PURE__ */ __name((result) => this.#taken.push(result), "#receive");
+      /** Reports the files, relative to the root, that `tracks` takes. */
+      constructor(root, tracks) {
+        this.#root = root;
+        this.#tracks = tracks;
+      }
+      /**
+       * The runs measuring coverage, a run within a run, like testero testing
+       * itself, among them, and their session. Starting coverage clears the
+       * counts of calls and taking it resets all counts, of the whole process,
+       * so the runs share one session, started once, and each gets what any
+       * of the others takes. Kept on globalThis, as nested runs may come from
+       * different copies of this module.
+       */
+      static #shared() {
+        const key = /* @__PURE__ */ Symbol.for("@aljazmc/testero.coverage");
+        const global = globalThis;
+        global[key] ??= { session: void 0, runs: /* @__PURE__ */ new Set() };
+        return global[key];
+      }
+      /** Starts counting, before the tests load. */
+      async start() {
+        const shared = _Coverage.#shared();
+        if (!shared.session) {
+          const session = new Session();
+          session.connect();
+          await session.post("Profiler.enable");
+          await session.post("Profiler.startPreciseCoverage", {
+            callCount: true,
+            detailed: true
+          });
+          shared.session = session;
+        }
+        shared.runs.add(this.#receive);
+      }
+      /**
+       * The coverage of the tracked sources of the bundles, by their paths,
+       * and of the files no test loaded, sorted by path.
+       */
+      async collect(bundles, unloaded = []) {
+        const shared = _Coverage.#shared();
+        const session = shared.session;
+        if (!session || !shared.runs.delete(this.#receive))
+          throw new Error("Coverage was not started.");
+        const { result } = await session.post(
+          "Profiler.takePreciseCoverage"
+        );
+        for (const receive of shared.runs) receive(result);
+        if (shared.runs.size === 0) {
+          session.disconnect();
+          shared.session = void 0;
+        }
+        const files = /* @__PURE__ */ new Map();
+        for (const taken of [...this.#taken, result])
+          for (const script of taken) {
+            const path = script.url.startsWith("file:") ? fileURLToPath(script.url) : script.url;
+            const code = bundles.get(path);
+            if (code !== void 0)
+              this.#bundle(code, dirname2(path), script.functions, files);
+          }
+        for (const file of unloaded)
+          if (!files.has(file)) files.set(file, await this.#unloaded(file));
+        return [...files.values()].sort(
+          (a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0
+        );
+      }
+      /** Adds the counts of the sources of one bundle. */
+      #bundle(code, directory, functions, files) {
+        const inline = _Coverage.#inline.exec(code)?.[1];
+        if (inline === void 0) return;
+        const map = JSON.parse(Buffer.from(inline, "base64").toString());
+        const sources = map.sources.map((source) => {
+          const file = relative(this.#root, resolve2(directory, source)).split("\\").join("/");
+          if (!this.#tracks(file)) return void 0;
+          let coverage = files.get(file);
+          if (!coverage) {
+            coverage = {
+              file,
+              lines: /* @__PURE__ */ new Map(),
+              functions: /* @__PURE__ */ new Map(),
+              loaded: true
+            };
+            files.set(file, coverage);
+          }
+          return coverage;
+        });
+        if (sources.every((source) => source === void 0)) return;
+        const counts = new Float64Array(code.length);
+        const ranges = functions.flatMap((fn) => fn.ranges).sort(
+          (a, b) => b.endOffset - b.startOffset - (a.endOffset - a.startOffset)
+        );
+        for (const range of ranges)
+          counts.fill(range.count, range.startOffset, range.endOffset);
+        const starts = [0];
+        for (let index = 0; index < code.length; index++)
+          if (code.charCodeAt(index) === 10) starts.push(index + 1);
+        const segments = _Coverage.decode(map.mappings);
+        const offsets = segments.map(
+          (segment) => (starts[segment.line] ?? code.length) + segment.column
+        );
+        const lines = /* @__PURE__ */ new Map();
+        segments.forEach((segment, index) => {
+          const coverage = sources[segment.source];
+          if (!coverage) return;
+          const next = segments[index + 1];
+          const end = next?.line === segment.line ? offsets[index + 1] : starts[segment.line + 1] ?? code.length;
+          let offset = offsets[index];
+          while (offset < end && /\s/.test(code[offset])) offset++;
+          if (offset >= end) return;
+          const counted = lines.get(coverage) ?? /* @__PURE__ */ new Map();
+          lines.set(coverage, counted);
+          const line = segment.sourceLine + 1;
+          const count = counts[offset] ?? 0;
+          counted.set(line, Math.max(counted.get(line) ?? 0, count));
+        });
+        for (const [coverage, counted] of lines)
+          for (const [line, count] of counted)
+            coverage.lines.set(
+              line,
+              (coverage.lines.get(line) ?? 0) + count
+            );
+        for (const { functionName, ranges: ranges2 } of functions) {
+          const range = ranges2[0];
+          if (!range || range.startOffset === 0 || functionName.startsWith("<"))
+            continue;
+          const index = _Coverage.#before(offsets, range.startOffset) ?? -1;
+          const segment = segments[index];
+          const line = starts[_Coverage.#before(starts, range.startOffset) ?? 0];
+          if (!segment || offsets[index] < (line ?? 0)) continue;
+          const coverage = sources[segment.source];
+          if (!coverage) continue;
+          const key = `${segment.sourceLine + 1}:${segment.sourceColumn + 1}`;
+          const known = coverage.functions.get(key);
+          if (known) known.count += range.count;
+          else
+            coverage.functions.set(key, {
+              name: functionName,
+              line: segment.sourceLine + 1,
+              count: range.count
+            });
+        }
+      }
+      /** A file no test loaded: its lines with code, none of them run. */
+      async #unloaded(file) {
+        const coverage = {
+          file,
+          lines: /* @__PURE__ */ new Map(),
+          functions: /* @__PURE__ */ new Map(),
+          loaded: false
+        };
+        const path = join3(this.#root, file);
+        const loader = Transformer.loader(path);
+        if (!loader) return coverage;
+        try {
+          const { map } = await transform(readFileSync3(path, "utf8"), {
+            loader,
+            sourcemap: "external",
+            sourcefile: file
+          });
+          const { mappings } = JSON.parse(map);
+          for (const segment of _Coverage.decode(mappings))
+            coverage.lines.set(segment.sourceLine + 1, 0);
+        } catch {
+        }
+        return coverage;
+      }
+      /** The index of the last of the sorted numbers at or before a number. */
+      static #before(sorted, value) {
+        let low = 0;
+        let high = sorted.length - 1;
+        let found;
+        while (low <= high) {
+          const middle = low + high >> 1;
+          if (sorted[middle] <= value) {
+            found = middle;
+            low = middle + 1;
+          } else high = middle - 1;
+        }
+        return found;
+      }
+      /** The mappings of a source map with a source, in order, its base64 VLQs decoded. */
+      static decode(mappings) {
+        const segments = [];
+        let line = 0;
+        let column = 0;
+        let source = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let fields = [];
+        let value = 0;
+        let shift = 0;
+        for (let index = 0; index <= mappings.length; index++) {
+          const code = mappings.charCodeAt(index);
+          if (Number.isNaN(code) || code === 44 || code === 59) {
+            if (fields.length > 0) {
+              column += fields[0];
+              if (fields.length >= 4) {
+                source += fields[1];
+                sourceLine += fields[2];
+                sourceColumn += fields[3];
+                segments.push({
+                  line,
+                  column,
+                  source,
+                  sourceLine,
+                  sourceColumn
+                });
+              }
+              fields = [];
+            }
+            if (code === 59) {
+              line++;
+              column = 0;
+            }
+            continue;
+          }
+          const digit = _Coverage.#digits[code] ?? -1;
+          if (digit < 0)
+            throw new Error(
+              `The source map has "${mappings[index]}" in its mappings.`
+            );
+          value += (digit & 31) * 2 ** shift;
+          if (digit & 32) shift += 5;
+          else {
+            const magnitude = Math.floor(value / 2);
+            fields.push(value % 2 === 1 ? -magnitude : magnitude);
+            value = 0;
+            shift = 0;
           }
         }
-        const indexed = Array.isArray(a) || ArrayBuffer.isView(a);
-        const keysOf = /* @__PURE__ */ __name((object) => _Equality.#keys(object, strict).filter(
-          (key) => !(indexed && typeof key === "string" && /^\d+$/.test(key))
-        ), "keysOf");
-        const aKeys = keysOf(a);
-        const bKeys = keysOf(b);
-        if (aKeys.length !== bKeys.length) return false;
-        return aKeys.every(
-          (key) => Object.hasOwn(b, key) && equal(
-            a[key],
-            b[key]
-          )
+        return segments;
+      }
+      /** How many of the lines with code ran. */
+      static lines(coverage) {
+        const counts = [...coverage.lines.values()];
+        return {
+          covered: counts.filter((count) => count > 0).length,
+          total: counts.length
+        };
+      }
+      /** How many of the functions ran. */
+      static functions(coverage) {
+        const counts = [...coverage.functions.values()];
+        return {
+          covered: counts.filter(({ count }) => count > 0).length,
+          total: counts.length
+        };
+      }
+      /** The sums of ratios. */
+      static sum(ratios) {
+        return ratios.reduce(
+          (sum, ratio) => ({
+            covered: sum.covered + ratio.covered,
+            total: sum.total + ratio.total
+          }),
+          { covered: 0, total: 0 }
         );
       }
-      /** Own enumerable keys, without the ones set to undefined unless strict. */
-      static #keys(object, strict) {
-        const record = object;
-        const keys = [
-          ...Object.keys(object),
-          ...Object.getOwnPropertySymbols(object).filter(
-            (symbol) => Object.getOwnPropertyDescriptor(object, symbol)?.enumerable
-          )
-        ];
-        return strict ? keys : keys.filter((key) => record[key] !== void 0);
+      /** A percentage like Jest's, 100 when there is nothing to run, unless nothing loaded it. */
+      static percent(ratio, loaded = true) {
+        if (ratio.total === 0) return loaded ? 100 : 0;
+        return Math.floor(ratio.covered / ratio.total * 1e4) / 100;
+      }
+      /** The lines that did not run, in ranges like `3-5,9`. */
+      static uncovered(coverage) {
+        const lines = [...coverage.lines].filter(([, count]) => count === 0).map(([line]) => line).sort((a, b) => a - b);
+        const ranges = [];
+        for (let index = 0; index < lines.length; ) {
+          const first = lines[index];
+          let last = first;
+          while (lines[index + 1] === last + 1)
+            last = lines[++index];
+          ranges.push(first === last ? `${first}` : `${first}-${last}`);
+          index++;
+        }
+        return ranges.join(",");
+      }
+      /** The coverage in the lcov format editors and services read. */
+      static lcov(root, files) {
+        return files.map((coverage) => {
+          const records = ["TN:", `SF:${join3(root, coverage.file)}`];
+          const functions = [...coverage.functions.values()].sort(
+            (a, b) => a.line - b.line
+          );
+          const names = /* @__PURE__ */ new Map();
+          const named = functions.map((fn) => {
+            const base = fn.name || "(anonymous)";
+            const seen = names.get(base) ?? 0;
+            names.set(base, seen + 1);
+            return {
+              ...fn,
+              name: seen === 0 ? base : `${base}_${seen}`
+            };
+          });
+          for (const fn of named)
+            records.push(`FN:${fn.line},${fn.name}`);
+          for (const fn of named)
+            records.push(`FNDA:${fn.count},${fn.name}`);
+          const ratio = _Coverage.functions(coverage);
+          records.push(`FNF:${ratio.total}`, `FNH:${ratio.covered}`);
+          for (const [line, count] of [...coverage.lines].sort(
+            ([a], [b]) => a - b
+          ))
+            records.push(`DA:${line},${count}`);
+          const lines = _Coverage.lines(coverage);
+          records.push(
+            `LF:${lines.total}`,
+            `LH:${lines.covered}`,
+            "end_of_record"
+          );
+          return `${records.join("\n")}
+`;
+        }).join("");
       }
     };
   }
@@ -1375,46 +2145,47 @@ var init_assertion = __esm({
       }
       /** The same assertion, expecting the opposite. */
       get not() {
-        return new _Assertion(this.#received, {
-          ...this.#context,
-          isNot: !this.#context.isNot
-        });
+        return this.#with({ isNot: !this.#context.isNot });
       }
       /** The assertion on what a promise resolves to, its matchers return promises. */
       get resolves() {
-        return new _Assertion(this.#received, {
-          ...this.#context,
-          promise: "resolves"
-        });
+        return this.#with({ promise: "resolves" });
       }
       /** The assertion on why a promise rejects, its matchers return promises. */
       get rejects() {
-        return new _Assertion(this.#received, {
+        return this.#with({ promise: "rejects" });
+      }
+      /** The same received value with another context, of the same class to keep its matchers. */
+      #with(change) {
+        const Same = this.constructor;
+        return new Same(this.#received, {
           ...this.#context,
-          promise: "rejects"
+          ...change
         });
       }
-      /** Adds a matcher to every assertion, like `expect.extend`. */
-      static define(name, matcher) {
-        matchers[name] = matcher;
-        Object.defineProperty(_Assertion.prototype, name, {
+      /**
+       * Adds a matcher to the assertions of a class: Assertion itself for the
+       * built in ones, the class of one test file for `expect.extend`.
+       */
+      static define(target, name, matcher) {
+        Object.defineProperty(target.prototype, name, {
           configurable: true,
           writable: true,
           value: /* @__PURE__ */ __name(function check(...args) {
-            return this.#run(name, args, check);
+            return this.#run(name, matcher, args, check);
           }, "check")
         });
       }
       /** Runs a matcher now, or once the promise settles for `.resolves` and `.rejects`. */
-      #run(name, args, caller) {
+      #run(name, matcher, args, caller) {
         _Assertion.count++;
         const origin = {};
         Error.captureStackTrace(origin, caller);
         const { promise } = this.#context;
-        if (!promise) return this.#check(name, this.#received, args, origin);
+        if (!promise) return this.#check(matcher, this.#received, args, origin);
         const settled = /* @__PURE__ */ __name((value, resolved) => {
           if (resolved === (promise === "resolves"))
-            return this.#check(name, value, args, origin);
+            return this.#check(matcher, value, args, origin);
           throw _Assertion.#error(
             `expect(received).${promise}.${name}()
 
@@ -1435,19 +2206,34 @@ Matcher error: received value must be a promise`,
           (reason) => settled(reason, false)
         );
       }
-      #check(name, received, args, origin) {
-        const matcher = matchers[name];
+      /** Calls a matcher, and fails when it does not pass, after awaiting an async one. */
+      #check(matcher, received, args, origin) {
+        const failed = /* @__PURE__ */ __name((error) => _Assertion.#error(
+          error instanceof Error ? error.message : String(error),
+          origin
+        ), "failed");
         let result;
         try {
           result = matcher.call(this.#context, received, ...args);
         } catch (error) {
+          throw failed(error);
+        }
+        if (typeof result?.then === "function")
+          return Promise.resolve(result).then(
+            (settled) => this.#verdict(settled, origin),
+            (error) => {
+              throw failed(error);
+            }
+          );
+        return this.#verdict(result, origin);
+      }
+      /** Throws when a matcher result is not what the assertion expects. */
+      #verdict(result, origin) {
+        if (Boolean(result?.pass) === this.#context.isNot)
           throw _Assertion.#error(
-            error instanceof Error ? error.message : String(error),
+            typeof result?.message === "function" ? String(result.message()) : "The matcher did not return a result with pass and message.",
             origin
           );
-        }
-        if (result.pass === this.#context.isNot)
-          throw _Assertion.#error(result.message(), origin);
       }
       static #error(message, origin) {
         const error = new AssertionError(message);
@@ -1458,7 +2244,7 @@ ${frames}` : ""}`;
       }
     };
     for (const [name, matcher] of Object.entries(matchers))
-      Assertion.define(name, matcher);
+      Assertion.define(Assertion, name, matcher);
   }
 });
 
@@ -1588,307 +2374,96 @@ var init_asymmetric = __esm({
         return Math.abs(this.sample - other) < 10 ** -this.#digits / 2;
       }
       toString() {
-        return `Number${this.prefix}CloseTo ${this.sample} (${this.#digits} digits)`;
-      }
-    };
-  }
-});
-
-// packages/testero/src/expect/expect.ts
-var negatable, Expect;
-var init_expect = __esm({
-  "packages/testero/src/expect/expect.ts"() {
-    "use strict";
-    init_assertion();
-    init_asymmetric();
-    negatable = /* @__PURE__ */ __name((inverse) => ({
-      objectContaining: /* @__PURE__ */ __name((object) => new ObjectContaining(object, inverse), "objectContaining"),
-      arrayContaining: /* @__PURE__ */ __name((array) => new ArrayContaining(array, inverse), "arrayContaining"),
-      stringContaining: /* @__PURE__ */ __name((text) => new StringContaining(text, inverse), "stringContaining"),
-      stringMatching: /* @__PURE__ */ __name((pattern) => new StringMatching(new RegExp(pattern), inverse), "stringMatching"),
-      closeTo: /* @__PURE__ */ __name((number, digits) => new CloseTo(number, digits, inverse), "closeTo")
-    }), "negatable");
-    Expect = class {
-      static {
-        __name(this, "Expect");
-      }
-      #expected;
-      #needed = false;
-      /** Starts the counts of a new test. */
-      reset() {
-        Assertion.count = 0;
-        this.#expected = void 0;
-        this.#needed = false;
-      }
-      /** Failures of `expect.assertions(n)` and `expect.hasAssertions()` after a test. */
-      verify() {
-        const count = Assertion.count;
-        if (this.#expected !== void 0 && count !== this.#expected)
-          return [
-            new AssertionError(
-              `expect.assertions(${this.#expected})
-
-Expected ${this.#expected} assertion${this.#expected === 1 ? "" : "s"} to be called but received ${count} assertion call${count === 1 ? "" : "s"}.`
-            )
-          ];
-        if (this.#needed && count === 0)
-          return [
-            new AssertionError(
-              "expect.hasAssertions()\n\nExpected at least one assertion to be called but received none."
-            )
-          ];
-        return [];
-      }
-      /** The function test files call as `expect`. */
-      create() {
-        const expect = /* @__PURE__ */ __name((received) => new Assertion(received), "expect");
-        return Object.assign(expect, {
-          ...negatable(false),
-          not: negatable(true),
-          any: /* @__PURE__ */ __name((type) => new Any(type), "any"),
-          anything: /* @__PURE__ */ __name(() => new Anything(void 0), "anything"),
-          assertions: /* @__PURE__ */ __name((count) => {
-            this.#expected = count;
-          }, "assertions"),
-          hasAssertions: /* @__PURE__ */ __name(() => {
-            this.#needed = true;
-          }, "hasAssertions"),
-          extend: /* @__PURE__ */ __name((added) => {
-            for (const [name, matcher] of Object.entries(added))
-              Assertion.define(name, matcher);
-          }, "extend")
-        });
-      }
-    };
-  }
-});
-
-// packages/testero/src/globals.ts
-var Globals;
-var init_globals = __esm({
-  "packages/testero/src/globals.ts"() {
-    "use strict";
-    init_mock();
-    Globals = class _Globals {
-      static {
-        __name(this, "Globals");
-      }
-      static key = /* @__PURE__ */ Symbol.for("testero");
-      static names = [
-        "describe",
-        "fdescribe",
-        "xdescribe",
-        "test",
-        "it",
-        "fit",
-        "xit",
-        "xtest",
-        "beforeAll",
-        "afterAll",
-        "beforeEach",
-        "afterEach",
-        "expect",
-        "testero",
-        "jest"
-      ];
-      /** The module the transformer injects, it reads the globals of the file being run. */
-      static source() {
-        return [
-          'const globals = globalThis[Symbol.for("testero")];',
-          ..._Globals.names.map(
-            (name) => `export const ${name} = globals.${name};`
-          )
-        ].join("\n");
-      }
-      /** Sets the globals for the next test file to import. */
-      static install(collector, expect, settings) {
-        const { describe, test } = collector;
-        const testero = {
-          fn: Mocks.fn,
-          spyOn: Mocks.spyOn,
-          isMockFunction: Mocks.isMockFunction,
-          clearAllMocks: /* @__PURE__ */ __name(() => {
-            Mocks.clearAll();
-            return testero;
-          }, "clearAllMocks"),
-          resetAllMocks: /* @__PURE__ */ __name(() => {
-            Mocks.resetAll();
-            return testero;
-          }, "resetAllMocks"),
-          restoreAllMocks: /* @__PURE__ */ __name(() => {
-            Mocks.restoreAll();
-            return testero;
-          }, "restoreAllMocks"),
-          /** Sets the timeout of the tests and hooks of this file. */
-          setTimeout: /* @__PURE__ */ __name((timeout) => {
-            settings.timeout = timeout;
-            return testero;
-          }, "setTimeout")
-        };
-        globalThis[_Globals.key] = {
-          describe,
-          fdescribe: describe.only,
-          xdescribe: describe.skip,
-          test,
-          it: test,
-          fit: test.only,
-          xit: test.skip,
-          xtest: test.skip,
-          beforeAll: collector.hook("beforeAll"),
-          afterAll: collector.hook("afterAll"),
-          beforeEach: collector.hook("beforeEach"),
-          afterEach: collector.hook("afterEach"),
-          expect: expect.create(),
-          testero,
-          jest: testero
-        };
-      }
-    };
-  }
-});
-
-// packages/testero/src/transformer.ts
-import { mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, extname, join as join2, sep } from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { build } from "esbuild";
-var Transformer;
-var init_transformer = __esm({
-  "packages/testero/src/transformer.ts"() {
+        return `Number${this.prefix}CloseTo ${this.sample} (${this.#digits} digits)`;
+      }
+    };
+  }
+});
+
+// packages/testero/src/expect/expect.ts
+var negatable, Expect;
+var init_expect = __esm({
+  "packages/testero/src/expect/expect.ts"() {
     "use strict";
-    init_globals();
-    Transformer = class _Transformer {
+    init_assertion();
+    init_asymmetric();
+    negatable = /* @__PURE__ */ __name((inverse) => ({
+      objectContaining: /* @__PURE__ */ __name((object) => new ObjectContaining(object, inverse), "objectContaining"),
+      arrayContaining: /* @__PURE__ */ __name((array) => new ArrayContaining(array, inverse), "arrayContaining"),
+      stringContaining: /* @__PURE__ */ __name((text) => new StringContaining(text, inverse), "stringContaining"),
+      stringMatching: /* @__PURE__ */ __name((pattern) => new StringMatching(new RegExp(pattern), inverse), "stringMatching"),
+      closeTo: /* @__PURE__ */ __name((number, digits) => new CloseTo(number, digits, inverse), "closeTo")
+    }), "negatable");
+    Expect = class {
       static {
-        __name(this, "Transformer");
+        __name(this, "Expect");
       }
-      /** Packages test files import the globals from, like with Jest. */
-      static modules = ["@jest/globals", "@aljazmc/testero"];
-      static #loaders = {
-        ".js": "js",
-        ".cjs": "js",
-        ".mjs": "js",
-        ".jsx": "jsx",
-        ".ts": "ts",
-        ".cts": "ts",
-        ".mts": "ts",
-        ".tsx": "tsx"
+      #expected;
+      #needed = false;
+      /** The assertions of this test file, `expect.extend` adds matchers to them only. */
+      #Assertion = class extends Assertion {
+        static {
+          __name(this, "#Assertion");
+        }
       };
-      /** The import.meta properties that describe the source file. */
-      static #meta = ["url", "filename", "dirname"];
-      /** Marks the resolutions the plugin asks esbuild for itself. */
-      static #own = /* @__PURE__ */ Symbol("testero");
-      /** Where compiled test files go, stack frames there are testero's own. */
-      static prefix = join2(tmpdir(), "testero-build-");
-      #directory = mkdtempSync(_Transformer.prefix);
-      #globals = join2(this.#directory, "globals.mjs");
-      #count = 0;
-      constructor() {
-        writeFileSync2(this.#globals, Globals.source());
-      }
-      /** Bundles a test file, returns the URL of the module to import. */
-      async compile(file) {
-        const outfile = join2(this.#directory, `${++this.#count}.mjs`);
-        const { outputFiles } = await build({
-          entryPoints: [file],
-          outfile,
-          write: false,
-          bundle: true,
-          platform: "node",
-          format: "esm",
-          target: `node${process.versions.node.split(".")[0]}`,
-          sourcemap: "inline",
-          sourcesContent: false,
-          inject: [this.#globals],
-          define: Object.fromEntries(
-            _Transformer.#meta.map((name) => [
-              `import.meta.${name}`,
-              `__testero.${name}`
-            ])
-          ),
-          // CommonJS code in the bundle may require installed packages
-          banner: {
-            js: 'import { createRequire as __testeroRequire } from "node:module";\nconst require = __testeroRequire(import.meta.url);'
-          },
-          logLevel: "silent",
-          plugins: [this.#plugin()]
-        });
-        writeFileSync2(outfile, outputFiles[0]?.text ?? "");
-        return pathToFileURL2(outfile).href;
-      }
-      /** Removes the compiled files. */
-      dispose() {
-        rmSync(this.#directory, { recursive: true, force: true });
+      /** Starts the counts of a new test. */
+      reset() {
+        Assertion.count = 0;
+        this.#expected = void 0;
+        this.#needed = false;
       }
-      #plugin() {
-        return {
-          name: "testero",
-          setup: /* @__PURE__ */ __name((build2) => {
-            build2.onResolve({ filter: /^testero-meta:/ }, (args) => ({
-              path: args.path.slice("testero-meta:".length),
-              namespace: "testero-meta"
-            }));
-            build2.onLoad(
-              { filter: /.*/, namespace: "testero-meta" },
-              (args) => ({
-                contents: `export default ${JSON.stringify({
-                  url: pathToFileURL2(args.path).href,
-                  filename: args.path,
-                  dirname: dirname(args.path)
-                })};`,
-                loader: "js"
-              })
-            );
-            build2.onResolve({ filter: /^[^./]/ }, async (args) => {
-              if (args.pluginData === _Transformer.#own) return void 0;
-              if (_Transformer.modules.includes(args.path))
-                return { path: this.#globals };
-              const resolved = await build2.resolve(args.path, {
-                kind: args.kind,
-                resolveDir: args.resolveDir,
-                pluginData: _Transformer.#own
-              });
-              if (resolved.errors.length > 0)
-                return { errors: resolved.errors };
-              if (resolved.external)
-                return { path: args.path, external: true };
-              if (!_Transformer.#installed(resolved.path))
-                return { path: resolved.path };
-              return {
-                path: args.kind === "require-call" ? resolved.path : pathToFileURL2(resolved.path).href,
-                external: true
-              };
-            });
-            build2.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
-              if (_Transformer.#installed(args.path)) return void 0;
-              const source = readFileSync2(args.path, "utf8");
-              const contents = /\bimport\.meta\b/.test(source) ? `${source}
-import __testero from ${JSON.stringify(`testero-meta:${args.path}`)};
-` : source;
-              return {
-                contents,
-                loader: _Transformer.#loaders[extname(args.path)] ?? "js",
-                resolveDir: dirname(args.path)
-              };
-            });
-          }, "setup")
-        };
+      /** Failures of `expect.assertions(n)` and `expect.hasAssertions()` after a test. */
+      verify() {
+        const count = Assertion.count;
+        if (this.#expected !== void 0 && count !== this.#expected)
+          return [
+            new AssertionError(
+              `expect.assertions(${this.#expected})
+
+Expected ${this.#expected} assertion${this.#expected === 1 ? "" : "s"} to be called but received ${count} assertion call${count === 1 ? "" : "s"}.`
+            )
+          ];
+        if (this.#needed && count === 0)
+          return [
+            new AssertionError(
+              "expect.hasAssertions()\n\nExpected at least one assertion to be called but received none."
+            )
+          ];
+        return [];
       }
-      static #installed(path) {
-        return path.split(sep).includes("node_modules");
+      /** The function test files call as `expect`. */
+      create() {
+        const expect = /* @__PURE__ */ __name((received) => new this.#Assertion(received), "expect");
+        return Object.assign(expect, {
+          ...negatable(false),
+          not: negatable(true),
+          any: /* @__PURE__ */ __name((type) => new Any(type), "any"),
+          anything: /* @__PURE__ */ __name(() => new Anything(void 0), "anything"),
+          assertions: /* @__PURE__ */ __name((count) => {
+            this.#expected = count;
+          }, "assertions"),
+          hasAssertions: /* @__PURE__ */ __name(() => {
+            this.#needed = true;
+          }, "hasAssertions"),
+          extend: /* @__PURE__ */ __name((added) => {
+            for (const [name, matcher] of Object.entries(added))
+              Assertion.define(this.#Assertion, name, matcher);
+          }, "extend")
+        });
       }
     };
   }
 });
 
 // packages/testero/src/reporter.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname2, isAbsolute, relative } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname3, isAbsolute, relative as relative2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var Reporter;
 var init_reporter = __esm({
   "packages/testero/src/reporter.ts"() {
     "use strict";
+    init_coverage();
     init_assertion();
     init_format();
     init_transformer();
@@ -1907,7 +2482,7 @@ var init_reporter = __esm({
         gray: 90
       };
       /** Stack frames from testero itself are left out of failures. */
-      static #own = dirname2(fileURLToPath(import.meta.url));
+      static #own = dirname3(fileURLToPath2(import.meta.url));
       #root;
       #verbose;
       #color;
@@ -1985,6 +2560,66 @@ ${failed ? "\n" : ""}`);
           ].join("\n")
         );
       }
+      /** The coverage of each file in a table like Jest's, under the totals. */
+      coverage(files) {
+        const row = /* @__PURE__ */ __name((name, functions, lines, uncovered) => [
+          name,
+          String(functions),
+          String(lines),
+          uncovered.length > 40 ? `${uncovered.slice(0, 37)}...` : uncovered
+        ], "row");
+        const header = ["File", "% Funcs", "% Lines", "Uncovered Line #s"];
+        const rows = [
+          row(
+            "All files",
+            Coverage.percent(Coverage.sum(files.map(Coverage.functions))),
+            Coverage.percent(Coverage.sum(files.map(Coverage.lines))),
+            ""
+          ),
+          ...files.map(
+            (coverage) => row(
+              ` ${coverage.file}`,
+              Coverage.percent(
+                Coverage.functions(coverage),
+                coverage.loaded
+              ),
+              Coverage.percent(Coverage.lines(coverage), coverage.loaded),
+              Coverage.uncovered(coverage)
+            )
+          )
+        ];
+        const widths = header.map(
+          (title, column) => Math.max(
+            title.length,
+            ...rows.map((cells) => cells[column]?.length ?? 0)
+          )
+        );
+        const line = /* @__PURE__ */ __name((cells, paint) => cells.map((cell, column) => {
+          const width = widths[column] ?? 0;
+          if (column === 1 || column === 2) {
+            const padded = cell.padStart(width);
+            if (!paint) return padded;
+            const percent = Number(cell);
+            return this.#paint(
+              padded,
+              percent >= 80 ? "green" : percent >= 50 ? "yellow" : "red"
+            );
+          }
+          return cell.padEnd(width);
+        }).join(" | "), "line");
+        const rule = widths.map((width) => "-".repeat(width)).join("-|-");
+        this.#write(
+          `${[
+            "",
+            rule,
+            line(header, false),
+            rule,
+            ...rows.map((cells) => line(cells, true)),
+            rule
+          ].join("\n")}
+`
+        );
+      }
       /** Explains that no test files were found. */
       none(patterns) {
         this.#write(
@@ -2053,7 +2688,7 @@ ${failed ? "\n" : ""}`);
           const match = /^\s+at (?:.*?\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
           if (!match) continue;
           let file = match[1];
-          if (file.startsWith("file://")) file = fileURLToPath(file);
+          if (file.startsWith("file://")) file = fileURLToPath2(file);
           if (!isAbsolute(file) || file.includes("node_modules") || file.startsWith(_Reporter.#own) || file.startsWith(Transformer.prefix))
             continue;
           frames.push({
@@ -2067,7 +2702,7 @@ ${failed ? "\n" : ""}`);
       /** The lines around a position, with a mark under it. */
       #code({ file, line, column }) {
         if (!existsSync2(file)) return "";
-        const lines = readFileSync3(file, "utf8").split(/\r?\n/);
+        const lines = readFileSync4(file, "utf8").split(/\r?\n/);
         const first = Math.max(1, line - 2);
         const last = Math.min(lines.length, line + 2);
         const width = String(last).length;
@@ -2087,7 +2722,7 @@ ${failed ? "\n" : ""}`);
         return out.join("\n");
       }
       #path(file) {
-        const path = relative(this.#root, file);
+        const path = relative2(this.#root, file);
         return path.startsWith("..") ? file : path;
       }
       #paint(text, ...styles) {
@@ -2114,6 +2749,8 @@ var init_runner = __esm({
       }
       #settings;
       #focused = false;
+      /** Fails the test or hook that is running, if any. */
+      #abort;
       constructor(settings) {
         this.#settings = settings;
       }
@@ -2125,6 +2762,15 @@ var init_runner = __esm({
         await this.#suite(root, [], results, errors);
         return { results, errors };
       }
+      /**
+       * Fails the running test or hook with an error thrown outside of it, like
+       * from a timer it started. Returns false when nothing is running.
+       */
+      fail(error) {
+        if (!this.#abort) return false;
+        this.#abort(error);
+        return true;
+      }
       /** Whether a test runs: not skipped, focused when others are, matching the name pattern. */
       runs(test) {
         return !test.skipped && (!this.#focused || test.focused) && (this.#settings.namePattern?.test(test.fullName) ?? true);
@@ -2202,6 +2848,7 @@ var init_runner = __esm({
       async #call(body, timeout = this.#settings.timeout) {
         let timer;
         const expired = new Promise((_, reject) => {
+          this.#abort = reject;
           timer = setTimeout(
             () => reject(
               new Error(
@@ -2217,17 +2864,18 @@ var init_runner = __esm({
         } catch (error) {
           return error ?? new Error(`${String(error)} was thrown`);
         } finally {
+          this.#abort = void 0;
           clearTimeout(timer);
         }
       }
       /** Runs a body as a promise, with a `done` callback when it takes one. */
       static #invoke(body) {
         if (body.length === 0)
-          return new Promise((resolve) => resolve(body(() => {
+          return new Promise((resolve3) => resolve3(body(() => {
           })));
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve3, reject) => {
           body(
-            (error) => error === void 0 ? resolve(void 0) : reject(error)
+            (error) => error === void 0 ? resolve3(void 0) : reject(error)
           );
         });
       }
@@ -2236,20 +2884,22 @@ var init_runner = __esm({
 });
 
 // packages/testero/src/testero.ts
-import { join as join3 } from "node:path";
+import { mkdirSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join4 } from "node:path";
 var Testero;
 var init_testero = __esm({
   "packages/testero/src/testero.ts"() {
     "use strict";
     init_src();
     init_collector();
+    init_coverage();
     init_expect();
     init_globals();
     init_mock();
     init_reporter();
     init_runner();
     init_transformer();
-    Testero = class {
+    Testero = class _Testero {
       static {
         __name(this, "Testero");
       }
@@ -2258,6 +2908,10 @@ var init_testero = __esm({
       #reporter;
       /** Errors thrown outside of tests, like from a forgotten timer. */
       #stray = [];
+      /** The runner of the file being run, which fails its running test with stray errors. */
+      #runner;
+      /** The test files and collectCoverageFrom, made when coverage first needs them. */
+      #coverageIncludes;
       constructor(config, options, reporter = new Reporter(config.root, { verbose: options.verbose })) {
         this.#config = config;
         this.#options = options;
@@ -2265,7 +2919,7 @@ var init_testero = __esm({
       }
       /** The test files to run, relative to the root. */
       files() {
-        const includes = new Includes(this.#options.testMatch);
+        const includes = new Includes(this.#options.testMatch, "testMatch");
         const patterns = this.#options.patterns.map(
           (pattern) => new RegExp(pattern)
         );
@@ -2281,11 +2935,18 @@ var init_testero = __esm({
           this.#reporter.none(this.#options.patterns);
           return this.#options.passWithNoTests;
         }
+        const coverage = this.#options.collectCoverage ? new Coverage(this.#config.root, (file) => this.#tracks(file)) : void 0;
+        await coverage?.start();
         process.setSourceMapsEnabled(true);
-        const stray = /* @__PURE__ */ __name((error) => this.#stray.push(error), "stray");
+        const runs = _Testero.#runs();
+        const stray = /* @__PURE__ */ __name((error) => {
+          if (runs.at(-1) !== stray) return;
+          if (!this.#runner?.fail(error)) this.#stray.push(error);
+        }, "stray");
+        runs.push(stray);
         process.on("uncaughtException", stray);
         process.on("unhandledRejection", stray);
-        const transformer = new Transformer();
+        const transformer = new Transformer(coverage !== void 0);
         const results = [];
         try {
           for (const file of files) {
@@ -2298,20 +2959,68 @@ var init_testero = __esm({
           transformer.dispose();
           process.off("uncaughtException", stray);
           process.off("unhandledRejection", stray);
+          runs.splice(runs.indexOf(stray), 1);
+        }
+        if (coverage) {
+          const covered = await coverage.collect(
+            transformer.bundles,
+            this.#options.collectCoverageFrom.length > 0 ? [...this.#config.files()].filter(
+              (file) => Transformer.loader(file) !== void 0 && this.#tracks(file)
+            ) : []
+          );
+          this.#reporter.coverage(covered);
+          const directory = join4(
+            this.#config.root,
+            this.#options.coverageDirectory
+          );
+          mkdirSync(directory, { recursive: true });
+          writeFileSync3(
+            join4(directory, "lcov.info"),
+            Coverage.lcov(this.#config.root, covered)
+          );
         }
         this.#reporter.summary(results, performance.now() - start);
         return !results.some(Reporter.failed);
       }
+      /**
+       * Whether coverage is reported for a file, relative to the root: one of
+       * the project, not a test file nor installed, and in collectCoverageFrom
+       * when it is set.
+       */
+      #tracks(file) {
+        if (file.startsWith("../") || isAbsolute2(file)) return false;
+        if (this.#config.ignore.matches(file)) return false;
+        if (file.split("/").includes("node_modules")) return false;
+        this.#coverageIncludes ??= {
+          tests: new Includes(this.#options.testMatch, "testMatch"),
+          from: this.#options.collectCoverageFrom.length > 0 ? new Includes(
+            this.#options.collectCoverageFrom,
+            "collectCoverageFrom"
+          ) : void 0
+        };
+        const { tests, from } = this.#coverageIncludes;
+        return !tests.matches(file) && (from?.matches(file) ?? true);
+      }
+      /**
+       * The stray error listeners of the runs in progress, innermost last.
+       * Kept on globalThis, as nested runs may come from different copies of this module.
+       */
+      static #runs() {
+        const key = /* @__PURE__ */ Symbol.for("@aljazmc/testero.runs");
+        const global = globalThis;
+        global[key] ??= [];
+        return global[key];
+      }
       async #file(file, transformer) {
         const start = performance.now();
-        const finish = /* @__PURE__ */ __name((results2, errors2) => {
-          errors2.push(...this.#stray.splice(0));
+        const finish = /* @__PURE__ */ __name((results, errors) => {
+          errors.push(...this.#stray.splice(0));
           Mocks.restoreAll();
           Mocks.forget();
           return {
             file,
-            results: results2,
-            errors: errors2,
+            results,
+            errors,
             duration: performance.now() - start
           };
         }, "finish");
@@ -2330,7 +3039,7 @@ var init_testero = __esm({
         };
         Globals.install(collector, expect, settings);
         try {
-          await import(await transformer.compile(join3(this.#config.root, file)));
+          await import(await transformer.compile(join4(this.#config.root, file)));
         } catch (error) {
           return finish([], [error]);
         } finally {
@@ -2341,10 +3050,13 @@ var init_testero = __esm({
             [],
             [new Error("Your test suite must contain at least one test.")]
           );
-        const { results, errors } = await new Runner(settings).run(
-          collector.root
-        );
-        return finish(results, errors);
+        this.#runner = new Runner(settings);
+        try {
+          const { results, errors } = await this.#runner.run(collector.root);
+          return finish(results, errors);
+        } finally {
+          this.#runner = void 0;
+        }
       }
     };
   }
@@ -2370,6 +3082,9 @@ Options:
   --listTests                    print the test files instead of running them
   --passWithNoTests              succeed when there are no test files
   --testTimeout <ms>             milliseconds a test or hook may take
+  --coverage                     report which lines and functions the tests run
+  --watch                        rerun the tests of changed files and what imports them
+  --watchAll                     rerun every test when a file changes
   --config [js]                  write the default testero.config.ts, or .js
   -h, --help                     show this help
 `;
@@ -2378,9 +3093,14 @@ Options:
       namePattern;
       listTests = false;
       help = false;
+      /** Reruns the tests of changed files, or all of them, when files change. */
+      watch;
+      /** The options, without the patterns and the watch ones, for the runs of watch mode. */
+      flags = [];
       constructor(argv) {
         for (let index = 0; index < argv.length; index++) {
           const argument = argv[index];
+          const start = index;
           const [name, inline] = argument.split(/=(.*)/s);
           const value = /* @__PURE__ */ __name(() => {
             const next = inline ?? argv[++index];
@@ -2393,14 +3113,32 @@ Options:
             case "--testNamePattern":
               this.namePattern = new RegExp(value());
               break;
-            case "--testTimeout":
-              this.rules.testTimeout = Number(value());
+            case "--testTimeout": {
+              const text = value();
+              const timeout = Number(text);
+              const valid = timeout > 0 && timeout < 2 ** 31;
+              if (text.trim() === "" || !valid)
+                throw new Error(
+                  `--testTimeout needs a positive number of milliseconds, not "${text}".`
+                );
+              this.rules.testTimeout = timeout;
               break;
+            }
             case "--bail":
             case "--verbose":
             case "--passWithNoTests":
               this.rules[name.slice(2)] = true;
               break;
+            case "--coverage":
+            case "--collectCoverage":
+              this.rules.collectCoverage = true;
+              break;
+            case "--watch":
+              this.watch ??= "related";
+              continue;
+            case "--watchAll":
+              this.watch = "all";
+              continue;
             case "--listTests":
               this.listTests = true;
               break;
@@ -2412,7 +3150,9 @@ Options:
               if (name.startsWith("-"))
                 throw new Error(`Unknown option ${name}.`);
               this.patterns.push(argument);
+              continue;
           }
+          this.flags.push(...argv.slice(start, index + 1));
         }
       }
       /** The configured rules, with the ones given on the command line instead. */
@@ -2445,7 +3185,10 @@ var init_config2 = __esm({
       passWithNoTests: false,
       clearMocks: false,
       resetMocks: false,
-      restoreMocks: false
+      restoreMocks: false,
+      collectCoverage: false,
+      collectCoverageFrom: [],
+      coverageDirectory: "coverage"
     };
     config_default = {
       ignore: [".git", "node_modules"],
@@ -2454,8 +3197,166 @@ var init_config2 = __esm({
   }
 });
 
+// packages/testero/src/watcher.ts
+var Watcher, Dependencies;
+var init_watcher = __esm({
+  "packages/testero/src/watcher.ts"() {
+    "use strict";
+    Watcher = class _Watcher {
+      static {
+        __name(this, "Watcher");
+      }
+      #options;
+      #write;
+      #current;
+      #queued;
+      #last = "all";
+      #changed = /* @__PURE__ */ new Set();
+      #timer;
+      #unsubscribe;
+      #closed = false;
+      #keys = /* @__PURE__ */ __name((data) => this.#key(String(data)), "#keys");
+      constructor(options) {
+        this.#options = options;
+        this.#write = options.write ?? ((text) => process.stdout.write(text));
+      }
+      /** Runs all tests, then watches. */
+      start() {
+        this.#unsubscribe = this.#options.subscribe(
+          (path) => this.#change(path)
+        );
+        const input = this.#options.input;
+        if (input) {
+          input.setRawMode?.(true);
+          input.on("data", this.#keys);
+          input.resume();
+        }
+        this.#queue("all");
+      }
+      /** Stops watching and the run in progress. */
+      close() {
+        this.#closed = true;
+        clearTimeout(this.#timer);
+        this.#unsubscribe?.();
+        this.#current?.run.stop();
+        const input = this.#options.input;
+        if (input) {
+          input.off("data", this.#keys);
+          input.setRawMode?.(false);
+          input.pause();
+        }
+      }
+      #key(key) {
+        if (key === "q" || key === "" || key === "") this.close();
+        else if (key === "a") this.#queue("all");
+        else if (key === "\r" || key === "\n") this.#queue(this.#last);
+      }
+      #change(path) {
+        if (this.#closed || this.#options.ignores?.(path)) return;
+        this.#changed.add(path);
+        clearTimeout(this.#timer);
+        this.#timer = setTimeout(
+          () => void this.#flush(),
+          this.#options.delay ?? 100
+        );
+      }
+      async #flush() {
+        const changed = this.#changed;
+        this.#changed = /* @__PURE__ */ new Set();
+        if (this.#options.mode === "all") return this.#queue("all");
+        try {
+          const files = await this.#options.related(changed);
+          if (files.length > 0) this.#queue(files);
+        } catch (error) {
+          this.#write(
+            `${error instanceof Error ? error.message : String(error)}
+`
+          );
+        }
+      }
+      /** Runs a selection, after stopping the run in progress, whose files run again too. */
+      #queue(selection) {
+        if (this.#closed) return;
+        this.#queued = _Watcher.merge(this.#queued, selection);
+        if (this.#current) {
+          this.#queued = _Watcher.merge(this.#queued, this.#current.selection);
+          this.#current.run.stop();
+        } else this.#next();
+      }
+      #next() {
+        const selection = this.#queued;
+        if (selection === void 0 || this.#closed) return;
+        this.#queued = void 0;
+        this.#last = selection;
+        if (this.#options.clear) this.#write("\x1B[2J\x1B[3J\x1B[H");
+        const run = this.#options.run(
+          selection === "all" ? void 0 : selection
+        );
+        this.#current = { selection, run };
+        void run.done.then(() => {
+          this.#current = void 0;
+          if (this.#queued !== void 0) this.#next();
+          else if (!this.#closed) this.#usage();
+        });
+      }
+      #usage() {
+        this.#write(
+          this.#options.input ? [
+            "",
+            "Watch Usage",
+            " \u203A Press a to run all tests.",
+            " \u203A Press Enter to run the last tests again.",
+            " \u203A Press q to quit watch mode.",
+            ""
+          ].join("\n") : "\nWatching for changes, Ctrl+C quits.\n"
+        );
+      }
+      /** Two selections in one, all when either is. */
+      static merge(a, b) {
+        if (a === void 0) return b;
+        if (a === "all" || b === "all") return "all";
+        return [.../* @__PURE__ */ new Set([...a, ...b])].sort();
+      }
+    };
+    Dependencies = class {
+      static {
+        __name(this, "Dependencies");
+      }
+      #list;
+      #inputs = /* @__PURE__ */ new Map();
+      /** `list` gives the files a test file is bundled from, all relative to the root. */
+      constructor(list) {
+        this.#list = list;
+      }
+      async related(tests, changed) {
+        const related = [];
+        for (const test of tests) {
+          const known = this.#inputs.get(test);
+          const touched = /* @__PURE__ */ __name((inputs2) => inputs2 !== void 0 && [...inputs2].some((input) => changed.has(input)), "touched");
+          let inputs = known;
+          if (!known || changed.has(test) || touched(known))
+            try {
+              inputs = new Set(await this.#list(test));
+              this.#inputs.set(test, inputs);
+            } catch {
+              this.#inputs.delete(test);
+              related.push(test);
+              continue;
+            }
+          if (changed.has(test) || touched(known) || touched(inputs))
+            related.push(test);
+        }
+        return related;
+      }
+    };
+  }
+});
+
 // packages/testero/src/index.ts
 var index_exports = {};
+import { spawn } from "node:child_process";
+import { watch } from "node:fs";
+import { join as join5, relative as relative3, sep as sep2 } from "node:path";
 var init_index = __esm({
   async "packages/testero/src/index.ts"() {
     "use strict";
@@ -2463,16 +3364,70 @@ var init_index = __esm({
     init_arguments();
     init_config2();
     init_testero();
+    init_transformer();
+    init_watcher();
     try {
       if (Config.init("testero", config_default)) process.exit();
       const args = new Arguments(process.argv.slice(2));
       if (args.help) process.stdout.write(Arguments.usage);
       else {
         const config = await Config.load("testero", config_default);
-        const testero = new Testero(config, args.options(config.rules));
+        const options = args.options(config.rules);
+        const testero = new Testero(config, options);
         if (args.listTests)
           for (const file of testero.files()) console.log(file);
-        else if (!await testero.run()) process.exitCode = 1;
+        else if (args.watch) {
+          const entry = process.argv[1];
+          const exactly = /* @__PURE__ */ __name((file) => `^${file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "exactly");
+          const transformer = new Transformer();
+          const dependencies = new Dependencies(
+            async (file) => (await transformer.inputs(join5(config.root, file))).map(
+              (input) => relative3(config.root, input).split(sep2).join("/")
+            )
+          );
+          const coverage = new Pattern(`/${options.coverageDirectory}`);
+          const watcher = new Watcher({
+            mode: args.watch,
+            run: /* @__PURE__ */ __name((files) => {
+              const child = spawn(
+                process.execPath,
+                [
+                  ...process.execArgv,
+                  entry,
+                  ...args.flags,
+                  ...files?.map(exactly) ?? args.patterns
+                ],
+                { stdio: ["ignore", "inherit", "inherit"] }
+              );
+              return {
+                done: new Promise(
+                  (resolve3) => child.on("close", resolve3).on("error", resolve3)
+                ),
+                stop: /* @__PURE__ */ __name(() => child.kill(), "stop")
+              };
+            }, "run"),
+            related: /* @__PURE__ */ __name((changed) => dependencies.related(testero.files(), changed), "related"),
+            subscribe: /* @__PURE__ */ __name((listener) => {
+              const watching = watch(
+                config.root,
+                { recursive: true },
+                (_, name) => {
+                  if (name) listener(name.split(sep2).join("/"));
+                }
+              );
+              return () => watching.close();
+            }, "subscribe"),
+            // sources and JSON, like Jest's moduleFileExtensions, not
+            // the coverage a run writes
+            ignores: /* @__PURE__ */ __name((path) => config.ignore.matches(path) || coverage.matches(path) || Transformer.loader(path) === void 0 && !path.endsWith(".json"), "ignores"),
+            input: process.stdin.isTTY ? process.stdin : void 0,
+            clear: process.stdout.isTTY
+          });
+          process.on("exit", () => transformer.dispose());
+          for (const signal of ["SIGINT", "SIGTERM"])
+            process.once(signal, () => watcher.close());
+          watcher.start();
+        } else if (!await testero.run()) process.exitCode = 1;
       }
     } catch (error) {
       console.error(error instanceof Error ? error.message : error);