hermes-test 1.0.1 → 1.0.3

package/bin/hermes-test.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
-"use strict";
+'use strict';
 
-const { execFileSync } = require("child_process");
-const path = require("path");
-const os = require("os");
-const fs = require("fs");
+const { execFileSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
 
 const platform = os.platform();
 const arch = os.arch();
 
 // Check for local development build first (target/release/hermes-test next to the package)
-const localBin = path.join(__dirname, "..", "..", "..", "target", "release", "hermes-test");
+const localBin = path.join(__dirname, '..', '..', '..', 'target', 'release', 'hermes-test');
 if (fs.existsSync(localBin)) {
   try {
-    execFileSync(localBin, process.argv.slice(2), { stdio: "inherit" });
+    execFileSync(localBin, process.argv.slice(2), { stdio: 'inherit' });
   } catch (e) {
     process.exit(e.status ?? 1);
   }
@@ -21,9 +21,9 @@ if (fs.existsSync(localBin)) {
 }
 
 const pkgMap = {
-  "darwin-arm64": "@hermes-test/darwin-arm64",
-  "darwin-x64": "@hermes-test/darwin-x64",
-  "linux-x64": "@hermes-test/linux-x64",
+  'darwin-arm64': '@hermes-test/darwin-arm64',
+  'darwin-x64': '@hermes-test/darwin-x64',
+  'linux-x64': '@hermes-test/linux-x64',
 };
 
 const key = `${platform}-${arch}`;
@@ -31,7 +31,7 @@ const pkg = pkgMap[key];
 
 if (!pkg) {
   console.error(`hermes-test: unsupported platform ${key}`);
-  console.error(`Supported: ${Object.keys(pkgMap).join(", ")}`);
+  console.error(`Supported: ${Object.keys(pkgMap).join(', ')}`);
   process.exit(1);
 }
 
@@ -40,9 +40,9 @@ try {
   // Search from cwd and script dir so the platform package is found
   // even when hoisted to a different node_modules in monorepos (bun/pnpm/yarn workspaces)
   const resolved = require.resolve(`${pkg}/package.json`, {
-    paths: [process.cwd(), path.join(__dirname, "..")]
+    paths: [process.cwd(), path.join(__dirname, '..')],
   });
-  binPath = path.join(path.dirname(resolved), "bin", "hermes-test");
+  binPath = path.join(path.dirname(resolved), 'bin', 'hermes-test');
 } catch {
   console.error(`hermes-test: platform package ${pkg} not installed.`);
   console.error(`Run: npm install --save-dev ${pkg}`);
@@ -50,7 +50,7 @@ try {
 }
 
 try {
-  execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+  execFileSync(binPath, process.argv.slice(2), { stdio: 'inherit' });
 } catch (e) {
   process.exit(e.status ?? 1);
 }

package/dist/harness.bundle.js

@@ -17,14 +17,14 @@ if (typeof globalThis.process === 'undefined') {
 
 // process.nextTick — many Node.js-style tests use this
 if (typeof globalThis.process.nextTick === 'undefined') {
-  globalThis.process.nextTick = function(fn) {
+  globalThis.process.nextTick = function (fn) {
     Promise.resolve().then(fn);
   };
 }
 
 // Object.fromEntries — ES2019, may not exist in older Hermes builds
 if (typeof Object.fromEntries === 'undefined') {
-  Object.fromEntries = function(iterable) {
+  Object.fromEntries = function (iterable) {
     var obj = {};
     if (iterable && typeof iterable[Symbol.iterator] === 'function') {
       var iter = iterable[Symbol.iterator]();
@@ -33,7 +33,9 @@ if (typeof Object.fromEntries === 'undefined') {
         obj[next.value[0]] = next.value[1];
       }
     } else if (iterable && typeof iterable.forEach === 'function') {
-      iterable.forEach(function(pair) { obj[pair[0]] = pair[1]; });
+      iterable.forEach(function (pair) {
+        obj[pair[0]] = pair[1];
+      });
     }
     return obj;
   };
@@ -44,7 +46,7 @@ if (typeof globalThis.crypto === 'undefined') {
   globalThis.crypto = {};
 }
 if (typeof globalThis.crypto.getRandomValues === 'undefined') {
-  globalThis.crypto.getRandomValues = function(arr) {
+  globalThis.crypto.getRandomValues = function (arr) {
     for (var i = 0; i < arr.length; i++) {
       arr[i] = Math.floor(Math.random() * 256);
     }
@@ -54,54 +56,69 @@ if (typeof globalThis.crypto.getRandomValues === 'undefined') {
 
 // MessageChannel polyfill — React 19's scheduler uses it for async work
 if (typeof globalThis.MessageChannel === 'undefined') {
-  globalThis.MessageChannel = function() {
+  globalThis.MessageChannel = function () {
     var cb = null;
     this.port1 = { onmessage: null };
     this.port2 = {
-      postMessage: function() {
-        if (cb) { var fn = cb; cb = null; fn({ data: undefined }); }
-      }
+      postMessage: function () {
+        if (cb) {
+          var fn = cb;
+          cb = null;
+          fn({ data: undefined });
+        }
+      },
     };
     var self = this;
     Object.defineProperty(this.port1, 'onmessage', {
-      set: function(fn) { cb = fn; },
-      get: function() { return cb; }
+      set: function (fn) {
+        cb = fn;
+      },
+      get: function () {
+        return cb;
+      },
     });
   };
 }
 
 // Timer polyfills — React scheduler needs these
-(function() {
+(function () {
   var queue = [];
   var timerIdCounter = 1;
   var timers = {};
 
   if (typeof globalThis.setImmediate === 'undefined') {
-    globalThis.setImmediate = function(fn) { queue.push(fn); };
+    globalThis.setImmediate = function (fn) {
+      queue.push(fn);
+    };
   }
 
   // Flush all async work: Hermes microtask queue (promises) + our polyfill queues (timers).
   // The C++ bridge installs a native __HT_drain that calls Hermes's drainMicrotasks().
   // We wrap it to also flush our setImmediate/setTimeout polyfill queues.
-  var nativeDrain = globalThis.__HT_drain || function() {};
-  globalThis.__HT_drain = function() {
+  var nativeDrain = globalThis.__HT_drain || function () {};
+  globalThis.__HT_drain = function () {
     // 1. Drain Hermes's internal promise/microtask queue
     nativeDrain();
     // 2. Flush our setImmediate queue
     var limit = 1000;
-    while (queue.length > 0 && limit-- > 0) { queue.shift()(); }
+    while (queue.length > 0 && limit-- > 0) {
+      queue.shift()();
+    }
     // 3. Flush pending timers
     var ids = Object.keys(timers);
     for (var i = 0; i < ids.length; i++) {
       var t = timers[ids[i]];
-      if (t) { delete timers[ids[i]]; t(); }
+      if (t) {
+        delete timers[ids[i]];
+        t();
+      }
     }
     // 4. Drain again (timer callbacks may have queued more microtasks)
     nativeDrain();
   };
 
   if (typeof globalThis.setTimeout === 'undefined') {
-    globalThis.setTimeout = function(fn, delay) {
+    globalThis.setTimeout = function (fn, delay) {
       var id = timerIdCounter++;
       if (!delay || delay <= 0) {
         queue.push(fn);
@@ -113,35 +130,48 @@ if (typeof globalThis.MessageChannel === 'undefined') {
   }
 
   if (typeof globalThis.clearTimeout === 'undefined') {
-    globalThis.clearTimeout = function(id) { delete timers[id]; };
+    globalThis.clearTimeout = function (id) {
+      delete timers[id];
+    };
   }
 
   if (typeof globalThis.console === 'undefined') {
     globalThis.console = {
-      log: function() {},
-      warn: function() {},
-      error: function() {},
-      info: function() {},
-      debug: function() {},
+      log: function () {},
+      warn: function () {},
+      error: function () {},
+      info: function () {},
+      debug: function () {},
     };
   }
 })();
 
 // Web API polyfills — needed for RTK Query's fetchBaseQuery
-(function() {
+(function () {
   // AbortController / AbortSignal
   if (typeof globalThis.AbortController === 'undefined') {
-    function AbortSignal() { this.aborted = false; this._listeners = []; }
-    AbortSignal.prototype.addEventListener = function(type, fn) { this._listeners.push(fn); };
-    AbortSignal.prototype.removeEventListener = function(type, fn) {
-      this._listeners = this._listeners.filter(function(f) { return f !== fn; });
+    function AbortSignal() {
+      this.aborted = false;
+      this._listeners = [];
+    }
+    AbortSignal.prototype.addEventListener = function (type, fn) {
+      this._listeners.push(fn);
+    };
+    AbortSignal.prototype.removeEventListener = function (type, fn) {
+      this._listeners = this._listeners.filter(function (f) {
+        return f !== fn;
+      });
     };
 
-    function AbortController() { this.signal = new AbortSignal(); }
-    AbortController.prototype.abort = function() {
+    function AbortController() {
+      this.signal = new AbortSignal();
+    }
+    AbortController.prototype.abort = function () {
       this.signal.aborted = true;
       for (var i = 0; i < this.signal._listeners.length; i++) {
-        try { this.signal._listeners[i](); } catch(e) {}
+        try {
+          this.signal._listeners[i]();
+        } catch (e) {}
       }
     };
 
@@ -155,7 +185,11 @@ if (typeof globalThis.MessageChannel === 'undefined') {
       this._map = {};
       if (init) {
         if (typeof init.forEach === 'function') {
-          init.forEach(function(v, k) { this._map[k.toLowerCase()] = v; }.bind(this));
+          init.forEach(
+            function (v, k) {
+              this._map[k.toLowerCase()] = v;
+            }.bind(this),
+          );
         } else {
           var keys = Object.keys(init);
           for (var i = 0; i < keys.length; i++) {
@@ -164,19 +198,29 @@ if (typeof globalThis.MessageChannel === 'undefined') {
         }
       }
     }
-    Headers.prototype.get = function(k) { return this._map[k.toLowerCase()] || null; };
-    Headers.prototype.has = function(k) { return k.toLowerCase() in this._map; };
-    Headers.prototype.set = function(k, v) { this._map[k.toLowerCase()] = v; };
-    Headers.prototype.append = function(k, v) {
+    Headers.prototype.get = function (k) {
+      return this._map[k.toLowerCase()] || null;
+    };
+    Headers.prototype.has = function (k) {
+      return k.toLowerCase() in this._map;
+    };
+    Headers.prototype.set = function (k, v) {
+      this._map[k.toLowerCase()] = v;
+    };
+    Headers.prototype.append = function (k, v) {
       k = k.toLowerCase();
       this._map[k] = this._map[k] ? this._map[k] + ', ' + v : v;
     };
-    Headers.prototype.delete = function(k) { delete this._map[k.toLowerCase()]; };
-    Headers.prototype.forEach = function(fn) {
+    Headers.prototype.delete = function (k) {
+      delete this._map[k.toLowerCase()];
+    };
+    Headers.prototype.forEach = function (fn) {
       var keys = Object.keys(this._map);
       for (var i = 0; i < keys.length; i++) fn(this._map[keys[i]], keys[i], this);
     };
-    Headers.prototype.entries = function() { return Object.entries(this._map); };
+    Headers.prototype.entries = function () {
+      return Object.entries(this._map);
+    };
     globalThis.Headers = Headers;
   }
 
@@ -207,7 +251,11 @@ if (typeof globalThis.MessageChannel === 'undefined') {
           }
         } else if (typeof init.forEach === 'function') {
           // URLSearchParams-like with forEach(value, key)
-          init.forEach(function(v, k) { this._params.push([String(k), String(v)]); }.bind(this));
+          init.forEach(
+            function (v, k) {
+              this._params.push([String(k), String(v)]);
+            }.bind(this),
+          );
         } else {
           // Plain object: { key: value }
           var keys = Object.keys(init);
@@ -217,59 +265,76 @@ if (typeof globalThis.MessageChannel === 'undefined') {
         }
       }
     }
-    URLSearchParams.prototype.get = function(k) {
+    URLSearchParams.prototype.get = function (k) {
       for (var i = 0; i < this._params.length; i++) {
         if (this._params[i][0] === k) return this._params[i][1];
       }
       return null;
     };
-    URLSearchParams.prototype.has = function(k) {
+    URLSearchParams.prototype.has = function (k) {
       for (var i = 0; i < this._params.length; i++) {
         if (this._params[i][0] === k) return true;
       }
       return false;
     };
-    URLSearchParams.prototype.set = function(k, v) {
+    URLSearchParams.prototype.set = function (k, v) {
       for (var i = 0; i < this._params.length; i++) {
-        if (this._params[i][0] === k) { this._params[i][1] = String(v); return; }
+        if (this._params[i][0] === k) {
+          this._params[i][1] = String(v);
+          return;
+        }
       }
       this._params.push([k, String(v)]);
     };
-    URLSearchParams.prototype.append = function(k, v) { this._params.push([k, String(v)]); };
-    URLSearchParams.prototype['delete'] = function(k) {
-      this._params = this._params.filter(function(p) { return p[0] !== k; });
+    URLSearchParams.prototype.append = function (k, v) {
+      this._params.push([k, String(v)]);
+    };
+    URLSearchParams.prototype['delete'] = function (k) {
+      this._params = this._params.filter(function (p) {
+        return p[0] !== k;
+      });
     };
-    URLSearchParams.prototype.entries = function() {
+    URLSearchParams.prototype.entries = function () {
       var params = this._params;
       var i = 0;
-      return { next: function() {
-        if (i < params.length) return { value: [params[i][0], params[i++][1]], done: false };
-        return { value: undefined, done: true };
-      }};
+      return {
+        next: function () {
+          if (i < params.length) return { value: [params[i][0], params[i++][1]], done: false };
+          return { value: undefined, done: true };
+        },
+      };
     };
-    URLSearchParams.prototype.keys = function() {
+    URLSearchParams.prototype.keys = function () {
       var params = this._params;
       var i = 0;
-      return { next: function() {
-        if (i < params.length) return { value: params[i++][0], done: false };
-        return { value: undefined, done: true };
-      }};
+      return {
+        next: function () {
+          if (i < params.length) return { value: params[i++][0], done: false };
+          return { value: undefined, done: true };
+        },
+      };
     };
-    URLSearchParams.prototype.values = function() {
+    URLSearchParams.prototype.values = function () {
       var params = this._params;
       var i = 0;
-      return { next: function() {
-        if (i < params.length) return { value: params[i++][1], done: false };
-        return { value: undefined, done: true };
-      }};
+      return {
+        next: function () {
+          if (i < params.length) return { value: params[i++][1], done: false };
+          return { value: undefined, done: true };
+        },
+      };
     };
-    URLSearchParams.prototype.forEach = function(fn, thisArg) {
+    URLSearchParams.prototype.forEach = function (fn, thisArg) {
       for (var i = 0; i < this._params.length; i++) {
         fn.call(thisArg, this._params[i][1], this._params[i][0], this);
       }
     };
-    URLSearchParams.prototype.toString = function() {
-      return this._params.map(function(p) { return encodeURIComponent(p[0]) + '=' + encodeURIComponent(p[1]); }).join('&');
+    URLSearchParams.prototype.toString = function () {
+      return this._params
+        .map(function (p) {
+          return encodeURIComponent(p[0]) + '=' + encodeURIComponent(p[1]);
+        })
+        .join('&');
     };
     URLSearchParams.prototype[Symbol.iterator] = URLSearchParams.prototype.entries;
     globalThis.URLSearchParams = URLSearchParams;
@@ -293,13 +358,20 @@ if (typeof globalThis.MessageChannel === 'undefined') {
         this.host = this.hostname + (this.port ? ':' + this.port : '');
         this.origin = this.protocol + '//' + this.host;
       } else {
-        this.protocol = ''; this.hostname = ''; this.port = '';
-        this.pathname = url; this.search = ''; this.hash = '';
-        this.host = ''; this.origin = '';
+        this.protocol = '';
+        this.hostname = '';
+        this.port = '';
+        this.pathname = url;
+        this.search = '';
+        this.hash = '';
+        this.host = '';
+        this.origin = '';
       }
       this.searchParams = new globalThis.URLSearchParams(this.search);
     }
-    URL.prototype.toString = function() { return this.href; };
+    URL.prototype.toString = function () {
+      return this.href;
+    };
     globalThis.URL = URL;
   }
 
@@ -315,8 +387,10 @@ if (typeof globalThis.MessageChannel === 'undefined') {
 
   // Stub fetch (mockFetch will override with handler-based implementation)
   if (typeof globalThis.fetch === 'undefined') {
-    globalThis.fetch = function() {
-      return Promise.reject(new Error('fetch not configured — use mockFetch() to register handlers'));
+    globalThis.fetch = function () {
+      return Promise.reject(
+        new Error('fetch not configured — use mockFetch() to register handlers'),
+      );
     };
   }
 
@@ -328,8 +402,12 @@ if (typeof globalThis.MessageChannel === 'undefined') {
       this.ok = this.status >= 200 && this.status < 300;
       this.headers = new globalThis.Headers(init && init.headers);
     };
-    globalThis.Response.prototype.json = function() { return Promise.resolve(JSON.parse(this.body)); };
-    globalThis.Response.prototype.text = function() { return Promise.resolve(String(this.body)); };
+    globalThis.Response.prototype.json = function () {
+      return Promise.resolve(JSON.parse(this.body));
+    };
+    globalThis.Response.prototype.text = function () {
+      return Promise.resolve(String(this.body));
+    };
   }
 })();
 
@@ -402,10 +480,14 @@ var __metroTestHarness = (() => {
     _updateSnapshots = update;
   }
   function _serializeSnapshot(value) {
-    return JSON.stringify(value, (_key, val) => {
-      if (typeof val === "function") return "[Function]";
-      return val;
-    }, 2);
+    return JSON.stringify(
+      value,
+      (_key, val) => {
+        if (typeof val === "function") return "[Function]";
+        return val;
+      },
+      2
+    );
   }
   function _loadSnapshots(path) {
     if (_snapshotCache[path]) return _snapshotCache[path];
@@ -458,8 +540,10 @@ Run with --update-snapshots to update.`
     }
   }
   function deepEqual(a, b) {
-    if (b != null && typeof b === "object" && b.__htMatcher && typeof b.matches === "function") return b.matches(a);
-    if (a != null && typeof a === "object" && a.__htMatcher && typeof a.matches === "function") return a.matches(b);
+    if (b != null && typeof b === "object" && b.__htMatcher && typeof b.matches === "function")
+      return b.matches(a);
+    if (a != null && typeof a === "object" && a.__htMatcher && typeof a.matches === "function")
+      return a.matches(b);
     if (a === b) return true;
     if (a == null || b == null) return a === b;
     if (typeof a !== typeof b) return false;
@@ -512,10 +596,14 @@ Run with --update-snapshots to update.`
           actual === expected,
           negated ? `expect(received).not.toBe(expected)
 
-    Expected: not ${formatValue(expected)}
+    Expected: not ${formatValue(
+            expected
+          )}
     Received: ${formatValue(actual)}` : `expect(received).toBe(expected)
 
-    Expected: ${formatValue(expected)}
+    Expected: ${formatValue(
+            expected
+          )}
     Received: ${formatValue(actual)}`
         );
       },
@@ -524,16 +612,21 @@ Run with --update-snapshots to update.`
           deepEqual(actual, expected),
           negated ? `expect(received).not.toEqual(expected)
 
-    Expected: not ${formatValue(expected)}
+    Expected: not ${formatValue(
+            expected
+          )}
     Received: ${formatValue(actual)}` : `expect(received).toEqual(expected)
 
-    Expected: ${formatValue(expected)}
+    Expected: ${formatValue(
+            expected
+          )}
     Received: ${formatValue(actual)}`
         );
       },
       toMatchObject(expected) {
         function matchesObject(a, b) {
-          if (b != null && typeof b === "object" && b.__htMatcher && typeof b.matches === "function") return b.matches(a);
+          if (b != null && typeof b === "object" && b.__htMatcher && typeof b.matches === "function")
+            return b.matches(a);
           if (typeof b !== "object" || b === null) return a === b;
           if (Array.isArray(b)) {
             if (!Array.isArray(a) || a.length < b.length) return false;
@@ -548,10 +641,14 @@ Run with --update-snapshots to update.`
           matchesObject(actual, expected),
           negated ? `expect(received).not.toMatchObject(expected)
 
-    Expected: not ${formatValue(expected)}
+    Expected: not ${formatValue(
+            expected
+          )}
     Received: ${formatValue(actual)}` : `expect(received).toMatchObject(expected)
 
-    Expected: ${formatValue(expected)}
+    Expected: ${formatValue(
+            expected
+          )}
     Received: ${formatValue(actual)}`
         );
       },
@@ -716,7 +813,9 @@ Run with --update-snapshots to update.`
         const match = s.calls.some((call) => deepEqual(call, args));
         assert(
           match,
-          negated ? `Expected spy not to have been called with ${formatValue(args)}` : `Expected spy to have been called with ${formatValue(args)}, calls: ${formatValue(s.calls)}`
+          negated ? `Expected spy not to have been called with ${formatValue(args)}` : `Expected spy to have been called with ${formatValue(args)}, calls: ${formatValue(
+            s.calls
+          )}`
         );
       },
       wasLastCalledWith(...args) {
@@ -867,11 +966,13 @@ Run with --update-snapshots to update.`
       },
       toBe: async (expected) => {
         const r = await actual;
-        if (r !== expected) throw new Error(`Expected ${formatValue(expected)}, got ${formatValue(r)}`);
+        if (r !== expected)
+          throw new Error(`Expected ${formatValue(expected)}, got ${formatValue(r)}`);
       },
       toEqual: async (expected) => {
         const r = await actual;
-        if (!deepEqual(r, expected)) throw new Error(`Expected deep equal to ${formatValue(expected)}, got ${formatValue(r)}`);
+        if (!deepEqual(r, expected))
+          throw new Error(`Expected deep equal to ${formatValue(expected)}, got ${formatValue(r)}`);
       },
       toBeDefined: async () => {
         const r = await actual;
@@ -1040,7 +1141,10 @@ Run with --update-snapshots to update.`
   }
   function getReconcilerModule() {
     const R = globalThis.__HT_Reconciler;
-    if (!R) throw new Error("react-reconciler not available. Make sure it is installed (it ships with hermes-test).");
+    if (!R)
+      throw new Error(
+        "react-reconciler not available. Make sure it is installed (it ships with hermes-test)."
+      );
     return R;
   }
   function getReconcilerConstants() {
@@ -1387,13 +1491,16 @@ Run with --update-snapshots to update.`
     return {
       getAll(root, arg) {
         const result = queryAll(root, arg);
-        if (result.length === 0) throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
+        if (result.length === 0)
+          throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
         return result;
       },
       get(root, arg) {
         const result = queryAll(root, arg);
-        if (result.length === 0) throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
-        if (result.length > 1) throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
+        if (result.length === 0)
+          throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
+        if (result.length > 1)
+          throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
         return result[0];
       },
       queryAll(root, arg) {
@@ -1401,7 +1508,8 @@ Run with --update-snapshots to update.`
       },
       query(root, arg) {
         const result = queryAll(root, arg);
-        if (result.length > 1) throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
+        if (result.length > 1)
+          throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
         return result[0] || null;
       }
     };
@@ -1761,7 +1869,9 @@ ${pad}</${type}>`;
         has: (k) => k.toLowerCase() in responseHeaders
       },
       json: () => Promise.resolve(responseBody),
-      text: () => Promise.resolve(typeof responseBody === "string" ? responseBody : JSON.stringify(responseBody)),
+      text: () => Promise.resolve(
+        typeof responseBody === "string" ? responseBody : JSON.stringify(responseBody)
+      ),
       clone: function() {
         return this;
       }
@@ -2059,10 +2169,14 @@ ${pad}</${type}>`;
       if (globalThis.__HT_coverage) {
         _print(`\r\x1B[K`);
       }
-      _print(` \x1B[31mFAIL\x1B[0m  ${file} \x1B[2m(${passed} passed, ${failed} failed)\x1B[0m${time}
-`);
+      _print(
+        ` \x1B[31mFAIL\x1B[0m  ${file} \x1B[2m(${passed} passed, ${failed} failed)\x1B[0m${time}
+`
+      );
     } else if (globalThis.__HT_coverage) {
-      _print(`\r\x1B[K \x1B[2mRunning...\x1B[0m ${_filesCompleted}/${_totalFiles} files (${_testsCompleted} tests)`);
+      _print(
+        `\r\x1B[K \x1B[2mRunning...\x1B[0m ${_filesCompleted}/${_totalFiles} files (${_testsCompleted} tests)`
+      );
     } else {
       _print(` \x1B[32mPASS\x1B[0m  ${file} \x1B[2m(${total} tests)\x1B[0m${time}
 `);