@unrift/core 0.3.0 → 0.4.0

package/dist/esm/mock/timers.js

@@ -0,0 +1,581 @@
+/**
+ * Fake clock - controllable replacements for `setTimeout`, `setInterval`,
+ * `setImmediate`, `process.nextTick`, `queueMicrotask`, `Date`, `Date.now`,
+ * and `performance.now`.
+ *
+ * Tests opt in via `mock.useFakeTimers()` and drain queued tasks deterministically
+ * with `advanceTimersByTime(ms)` / `runAllTimers()` / `runOnlyPendingTimers()`.
+ *
+ * Restoration:
+ *   - `mock.useRealTimers()` reverts every patched global to its original
+ *   - `mock.restoreAll()` does the same as part of bulk cleanup
+ */
+import { activeRestorers } from "./spy.js";
+const PRIORITY = {
+    microtask: 0,
+    immediate: 1,
+    timeout: 2,
+    interval: 2,
+};
+// State
+//
+// NOTE: this is process-global singleton state. It is correct today because
+// unrift runs every spec file sequentially in one process, and the
+// afterEach(restoreAll) contract resets between tests. If parallel per-file
+// execution lands (see ISSUES.md, parallel test file execution), the fake
+// clock would need per-worker isolation instead of module-level state.
+let installed = false;
+let now = 0;
+let nextId = 1;
+let nextSeq = 0;
+const queue = [];
+let originals;
+const realDate = globalThis.Date;
+const realDateNow = realDate.now.bind(realDate);
+// Queue operations
+function compareTasks(a, b) {
+    if (a.fireAt !== b.fireAt)
+        return a.fireAt - b.fireAt;
+    const pa = PRIORITY[a.kind];
+    const pb = PRIORITY[b.kind];
+    if (pa !== pb)
+        return pa - pb;
+    return a.seq - b.seq;
+}
+function enqueue(task) {
+    /**
+     * Linear insertion keeps the queue sorted. Test workloads rarely have
+     * enough pending tasks for a heap to matter.
+     */
+    let i = 0;
+    while (i < queue.length && compareTasks(queue[i], task) <= 0)
+        i++;
+    queue.splice(i, 0, task);
+}
+function findIndexById(id) {
+    for (let i = 0; i < queue.length; i++) {
+        if (queue[i].id === id)
+            return i;
+    }
+    return -1;
+}
+// Patched timer functions
+function fakeSetTimeout(callback, ms, ...args) {
+    const task = {
+        id: nextId++,
+        kind: "timeout",
+        fireAt: now + Math.max(0, ms ?? 0),
+        seq: nextSeq++,
+        callback,
+        args,
+        cancelled: false,
+    };
+    enqueue(task);
+    return task.id;
+}
+function fakeClearTimeout(id) {
+    if (id == null)
+        return;
+    const numericId = typeof id === "number" ? id : id.id;
+    if (numericId == null)
+        return;
+    const index = findIndexById(numericId);
+    if (index !== -1)
+        queue[index].cancelled = true;
+}
+function fakeSetInterval(callback, ms, ...args) {
+    const period = Math.max(1, ms ?? 0);
+    const task = {
+        id: nextId++,
+        kind: "interval",
+        fireAt: now + period,
+        seq: nextSeq++,
+        callback,
+        args,
+        periodMs: period,
+        cancelled: false,
+    };
+    enqueue(task);
+    return task.id;
+}
+function fakeSetImmediate(callback, ...args) {
+    const task = {
+        id: nextId++,
+        kind: "immediate",
+        fireAt: now,
+        seq: nextSeq++,
+        callback,
+        args,
+        cancelled: false,
+    };
+    enqueue(task);
+    return task.id;
+}
+function fakeQueueMicrotask(callback) {
+    const task = {
+        id: nextId++,
+        kind: "microtask",
+        fireAt: now,
+        seq: nextSeq++,
+        callback,
+        args: [],
+        cancelled: false,
+    };
+    enqueue(task);
+}
+// Date replacement
+function makeFakeDate() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const FakeDate = function (...args) {
+        if (!new.target) {
+            /**
+             * Date(...) without `new` returns a string of the *current* time -
+             * which when faked should reflect the fake clock.
+             */
+            return new realDate(now).toString();
+        }
+        if (args.length === 0) {
+            return Reflect.construct(realDate, [now], new.target);
+        }
+        return Reflect.construct(realDate, args, new.target);
+    };
+    /**
+     * Inherit static surface and instance prototype from the real Date.
+     * The cast is needed because `prototype` is typed as readonly on `typeof Date`
+     * even though it's actually writable on a function value.
+     */
+    Object.setPrototypeOf(FakeDate, realDate);
+    FakeDate.prototype =
+        realDate.prototype;
+    FakeDate.now = () => now;
+    FakeDate.parse = realDate.parse.bind(realDate);
+    FakeDate.UTC = realDate.UTC.bind(realDate);
+    return FakeDate;
+}
+// Drain
+const MAX_DRAIN_ITERATIONS = 10_000;
+// Pull and run the head task. Re-queues intervals. Skips cancelled tasks.
+function pumpOne() {
+    while (queue.length > 0 && queue[0].cancelled)
+        queue.shift();
+    if (queue.length === 0)
+        return false;
+    const task = queue.shift();
+    now = Math.max(now, task.fireAt);
+    if (task.kind === "interval") {
+        /**
+         * Re-schedule before firing so a callback that calls clearInterval()
+         * can find the task in the queue.
+         */
+        const next = {
+            ...task,
+            seq: nextSeq++,
+            fireAt: now + (task.periodMs ?? 1),
+        };
+        enqueue(next);
+    }
+    task.callback(...task.args);
+    return true;
+}
+function advanceTo(target) {
+    let iterations = 0;
+    while (queue.length > 0) {
+        while (queue.length > 0 && queue[0].cancelled)
+            queue.shift();
+        if (queue.length === 0)
+            break;
+        if (queue[0].fireAt > target)
+            break;
+        pumpOne();
+        if (++iterations > MAX_DRAIN_ITERATIONS) {
+            throw new Error("advanceTimersByTime exceeded the maximum drain iterations - " +
+                "is a timer scheduling itself in a loop?");
+        }
+    }
+    if (target > now)
+        now = target;
+}
+const ALL_FAKEABLE = [
+    "setTimeout",
+    "setInterval",
+    "setImmediate",
+    "queueMicrotask",
+    "process.nextTick",
+    "Date",
+    "performance",
+];
+function resolveFakedSet(options) {
+    if (options.toFake !== undefined && options.doNotFake !== undefined) {
+        throw new Error("mock.useFakeTimers(): `toFake` and `doNotFake` are mutually exclusive");
+    }
+    if (options.toFake !== undefined) {
+        return new Set(options.toFake);
+    }
+    if (options.doNotFake !== undefined) {
+        const excluded = new Set(options.doNotFake);
+        return new Set(ALL_FAKEABLE.filter((api) => !excluded.has(api)));
+    }
+    return new Set(ALL_FAKEABLE);
+}
+// Tracks what was actually patched on the most recent useFakeTimers call,
+// so useRealTimers knows which originals to restore.
+let fakedApis = new Set();
+// The own descriptor `performance` had for `now` before we shadowed it
+// (undefined if `now` was inherited from the prototype).
+let originalPerfNowDescriptor;
+/**
+ * Patch `performance.now` to read the fake clock. Uses `defineProperty`
+ * rather than assignment because on Node 18 `performance.now` is a
+ * non-writable prototype method - plain assignment throws. Defining an own
+ * property on the instance shadows it safely.
+ *
+ * Returns false (without throwing) if the platform won't allow it, so a
+ * failure here never aborts the rest of the timer install.
+ */
+function patchPerformanceNow() {
+    const perf = globalThis.performance;
+    if (!perf || typeof perf.now !== "function")
+        return false;
+    try {
+        originalPerfNowDescriptor = Object.getOwnPropertyDescriptor(perf, "now");
+        Object.defineProperty(perf, "now", {
+            configurable: true,
+            writable: true,
+            value: () => now,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Reverse `patchPerformanceNow`. Best-effort - never throws. */
+function restorePerformanceNow() {
+    const perf = globalThis.performance;
+    if (!perf)
+        return;
+    try {
+        if (originalPerfNowDescriptor) {
+            Object.defineProperty(perf, "now", originalPerfNowDescriptor);
+        }
+        else {
+            // We added a shadow own property; deleting it reveals the real
+            // prototype method again.
+            delete perf.now;
+        }
+    }
+    catch {
+        // ignore - leaving the fake in place is better than throwing on cleanup
+    }
+    originalPerfNowDescriptor = undefined;
+}
+function ensureInstalled(method) {
+    if (!installed) {
+        throw new Error(`mock.${method}() requires fake timers - call mock.useFakeTimers() first`);
+    }
+}
+function toMillis(value) {
+    let ms;
+    if (value instanceof realDate)
+        ms = value.getTime();
+    else if (typeof value === "number")
+        ms = value;
+    else
+        ms = new realDate(value).getTime();
+    // Reject NaN (invalid Date / unparseable string) and ±Infinity up front.
+    // Letting a non-finite value become the fake clock would silently break
+    // every scheduling and drain comparison (now + ms, fireAt > target, …).
+    if (!Number.isFinite(ms)) {
+        const shown = typeof value === "string" ? JSON.stringify(value) : String(value);
+        throw new TypeError(`mock fake-timers: invalid time value ${shown} - expected a valid Date, ` +
+            `a parseable date string, or finite epoch milliseconds`);
+    }
+    return ms;
+}
+export function useFakeTimers(options = {}) {
+    if (installed)
+        return;
+    // Resolve options that can throw BEFORE flipping `installed` or touching
+    // any global - so an invalid `toFake`/`doNotFake` combo or a bad `now`
+    // leaves useFakeTimers a clean no-op rather than a half-installed state.
+    const toFake = resolveFakedSet(options);
+    const initialNow = options.now !== undefined ? toMillis(options.now) : 0;
+    installed = true;
+    fakedApis = toFake;
+    originals = {
+        setTimeout: globalThis.setTimeout,
+        clearTimeout: globalThis.clearTimeout,
+        setInterval: globalThis.setInterval,
+        clearInterval: globalThis.clearInterval,
+        setImmediate: typeof globalThis.setImmediate !== "undefined"
+            ? globalThis.setImmediate
+            : undefined,
+        clearImmediate: typeof globalThis.clearImmediate !== "undefined"
+            ? globalThis.clearImmediate
+            : undefined,
+        queueMicrotask: globalThis.queueMicrotask,
+        processNextTick: typeof process !== "undefined" && process.nextTick
+            ? process.nextTick
+            : undefined,
+        Date: globalThis.Date,
+        performanceNow: typeof globalThis.performance !== "undefined" &&
+            typeof globalThis.performance.now === "function"
+            ? globalThis.performance.now.bind(globalThis.performance)
+            : undefined,
+    };
+    now = initialNow;
+    queue.length = 0;
+    // Register the restorer BEFORE patching anything, so even a mid-install
+    // failure leaves a globally-installed fake that restoreAll can undo.
+    // Without this, a throw between here and the end would strand the real
+    // timers permanently - see the Node 18 performance.now issue.
+    activeRestorers.add(useRealTimers);
+    // Patch globals - each pair gated on the resolved fake set.
+    if (toFake.has("setTimeout")) {
+        globalThis.setTimeout =
+            fakeSetTimeout;
+        globalThis.clearTimeout =
+            fakeClearTimeout;
+    }
+    if (toFake.has("setInterval")) {
+        globalThis.setInterval =
+            fakeSetInterval;
+        globalThis.clearInterval =
+            fakeClearTimeout;
+    }
+    if (toFake.has("setImmediate") && originals.setImmediate) {
+        globalThis.setImmediate =
+            fakeSetImmediate;
+        globalThis.clearImmediate =
+            fakeClearTimeout;
+    }
+    if (toFake.has("queueMicrotask")) {
+        globalThis.queueMicrotask = fakeQueueMicrotask;
+    }
+    if (toFake.has("process.nextTick") &&
+        originals.processNextTick &&
+        typeof process !== "undefined") {
+        /**
+         * process.nextTick has the highest priority in Node. schedule with
+         * microtask priority so it fires before macrotasks at the same time.
+         */
+        process.nextTick = ((callback, ...args) => {
+            const task = {
+                id: nextId++,
+                kind: "microtask",
+                fireAt: now,
+                seq: nextSeq++,
+                callback,
+                args,
+                cancelled: false,
+            };
+            enqueue(task);
+        });
+    }
+    if (toFake.has("Date")) {
+        globalThis.Date = makeFakeDate();
+    }
+    if (toFake.has("performance")) {
+        // If the platform won't let us patch performance.now (e.g. it's a
+        // non-configurable accessor), drop it from the faked set so restore
+        // doesn't try to undo something we never did.
+        if (!patchPerformanceNow()) {
+            fakedApis.delete("performance");
+        }
+    }
+}
+export function useRealTimers() {
+    if (!installed || !originals)
+        return;
+    // Only restore the APIs that were actually patched. Touching globals
+    // we didn't touch would clobber user-set values or other mocks.
+    if (fakedApis.has("setTimeout")) {
+        globalThis.setTimeout = originals.setTimeout;
+        globalThis.clearTimeout = originals.clearTimeout;
+    }
+    if (fakedApis.has("setInterval")) {
+        globalThis.setInterval = originals.setInterval;
+        globalThis.clearInterval = originals.clearInterval;
+    }
+    if (fakedApis.has("setImmediate")) {
+        if (originals.setImmediate)
+            globalThis.setImmediate = originals.setImmediate;
+        if (originals.clearImmediate)
+            globalThis.clearImmediate = originals.clearImmediate;
+    }
+    if (fakedApis.has("queueMicrotask")) {
+        globalThis.queueMicrotask = originals.queueMicrotask;
+    }
+    if (fakedApis.has("process.nextTick") &&
+        originals.processNextTick &&
+        typeof process !== "undefined") {
+        process.nextTick =
+            originals.processNextTick;
+    }
+    if (fakedApis.has("Date")) {
+        globalThis.Date = originals.Date;
+    }
+    if (fakedApis.has("performance")) {
+        restorePerformanceNow();
+    }
+    installed = false;
+    originals = undefined;
+    fakedApis = new Set();
+    queue.length = 0;
+    now = 0;
+    activeRestorers.delete(useRealTimers);
+}
+export function advanceTimersByTime(ms) {
+    ensureInstalled("advanceTimersByTime");
+    advanceTo(now + Math.max(0, ms));
+}
+export function runAllTimers() {
+    ensureInstalled("runAllTimers");
+    let iterations = 0;
+    while (queue.length > 0) {
+        while (queue.length > 0 && queue[0].cancelled)
+            queue.shift();
+        if (queue.length === 0)
+            break;
+        pumpOne();
+        if (++iterations > MAX_DRAIN_ITERATIONS) {
+            throw new Error("runAllTimers exceeded the maximum drain iterations - " +
+                "is a timer scheduling itself in a loop?");
+        }
+    }
+}
+export function runOnlyPendingTimers() {
+    ensureInstalled("runOnlyPendingTimers");
+    // Snapshot by `seq`, not `id`: a re-fired interval re-enqueues itself with
+    // the SAME id but a fresh seq (see pumpOne). Snapshotting ids would keep the
+    // interval "in scope" forever and drain it every tick until the guard trips.
+    // seq is unique per enqueue, so the re-scheduled tick counts as newly
+    // scheduled and is left pending.
+    const targetSeqs = new Set(queue.map((t) => t.seq));
+    let iterations = 0;
+    while (queue.length > 0) {
+        while (queue.length > 0 && queue[0].cancelled)
+            queue.shift();
+        if (queue.length === 0)
+            break;
+        if (!targetSeqs.has(queue[0].seq))
+            break;
+        pumpOne();
+        if (++iterations > MAX_DRAIN_ITERATIONS) {
+            throw new Error("runOnlyPendingTimers exceeded the maximum drain iterations");
+        }
+    }
+}
+/**
+ * Like `pumpOne`, but if the callback returns a thenable, awaits it before
+ * resolving, and yields to the real microtask queue afterward so any
+ * microtasks the callback queued can settle before the next pump.
+ *
+ * The `await Promise.resolve()` at the end is the key. It lets pending
+ * microtasks (resolved Promises, queued `.then` handlers) flush. Real
+ * `Promise.resolve()` is unaffected by `mock.useFakeTimers()` - the engine
+ * uses its internal microtask queue, not our fake `queueMicrotask`.
+ */
+async function pumpOneAsync() {
+    while (queue.length > 0 && queue[0].cancelled)
+        queue.shift();
+    if (queue.length === 0)
+        return false;
+    const task = queue.shift();
+    now = Math.max(now, task.fireAt);
+    if (task.kind === "interval") {
+        const next = {
+            ...task,
+            seq: nextSeq++,
+            fireAt: now + (task.periodMs ?? 1),
+        };
+        enqueue(next);
+    }
+    const result = task.callback(...task.args);
+    if (result !== undefined &&
+        result !== null &&
+        typeof result.then === "function") {
+        await result;
+    }
+    // Yield once more so microtasks scheduled by the callback (after any
+    // awaited promise resolved) can run before we move on.
+    await Promise.resolve();
+    return true;
+}
+/**
+ * Like `advanceTimersByTime`, but awaits Promise return values from
+ * timer callbacks and yields to microtasks between pumps. Use this when
+ * the code under test does `await` work inside a `setTimeout` callback.
+ */
+export async function advanceTimersByTimeAsync(ms) {
+    ensureInstalled("advanceTimersByTimeAsync");
+    const target = now + Math.max(0, ms);
+    let iterations = 0;
+    while (queue.length > 0) {
+        while (queue.length > 0 && queue[0].cancelled)
+            queue.shift();
+        if (queue.length === 0)
+            break;
+        if (queue[0].fireAt > target)
+            break;
+        await pumpOneAsync();
+        if (++iterations > MAX_DRAIN_ITERATIONS) {
+            throw new Error("advanceTimersByTimeAsync exceeded the maximum drain iterations - " +
+                "is a timer scheduling itself in a loop?");
+        }
+    }
+    if (target > now)
+        now = target;
+}
+/** Async sibling of `runAllTimers`. */
+export async function runAllTimersAsync() {
+    ensureInstalled("runAllTimersAsync");
+    let iterations = 0;
+    while (queue.length > 0) {
+        while (queue.length > 0 && queue[0].cancelled)
+            queue.shift();
+        if (queue.length === 0)
+            break;
+        await pumpOneAsync();
+        if (++iterations > MAX_DRAIN_ITERATIONS) {
+            throw new Error("runAllTimersAsync exceeded the maximum drain iterations - " +
+                "is a timer scheduling itself in a loop?");
+        }
+    }
+}
+/** Async sibling of `runOnlyPendingTimers`. */
+export async function runOnlyPendingTimersAsync() {
+    ensureInstalled("runOnlyPendingTimersAsync");
+    // Snapshot by `seq` for the same reason as the sync variant: a re-fired
+    // interval re-enqueues with the same id but a fresh seq, so id-based
+    // snapshotting would drain it every tick until the guard trips.
+    const targetSeqs = new Set(queue.map((t) => t.seq));
+    let iterations = 0;
+    while (queue.length > 0) {
+        while (queue.length > 0 && queue[0].cancelled)
+            queue.shift();
+        if (queue.length === 0)
+            break;
+        if (!targetSeqs.has(queue[0].seq))
+            break;
+        await pumpOneAsync();
+        if (++iterations > MAX_DRAIN_ITERATIONS) {
+            throw new Error("runOnlyPendingTimersAsync exceeded the maximum drain iterations");
+        }
+    }
+}
+export function getTimerCount() {
+    ensureInstalled("getTimerCount");
+    let count = 0;
+    for (const task of queue)
+        if (!task.cancelled)
+            count++;
+    return count;
+}
+export function setSystemTime(value) {
+    ensureInstalled("setSystemTime");
+    now = toMillis(value);
+}
+export function getRealSystemTime() {
+    return realDateNow();
+}

package/dist/esm/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/runner.ts"],"names":[],"mappings":"AAkBA,UAAU,aAAa;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AA0ND,wBAAsB,WAAW,CAAC,OAAO,GAAE,aAAkB,iBA8T5D;AA+DD,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,iBAyD9D"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/runner.ts"],"names":[],"mappings":"AAwBA,UAAU,aAAa;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AA0ND,wBAAsB,WAAW,CAAC,OAAO,GAAE,aAAkB,iBA8T5D;AA+DD,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,iBAyD9D"}

package/dist/esm/runner.js

@@ -8,6 +8,11 @@ import { runEngine } from "./run.js";
 import { normalizePath } from "./utils/normalizePath.js";
 import { safeRegExp, isGlobPattern, globToRegex } from "./utils/helpers.js";
 import { TaskStatus } from "./types.js";
+/**
+ * Captured at module load so the runner's own timing measurements
+ * aren't affected by user mocks (e.g. mock.useFakeTimers patches performance.now).
+ */
+const realPerformanceNow = performance.now.bind(performance);
 function debugLog(enabled, json, ...args) {
     // Keep stdout clean for --json mode; use stderr for debug.
     if (!enabled)
@@ -144,7 +149,7 @@ function extractTestName(description) {
 }
 export async function runTestsCLI(options = {}) {
     regExpCache.clear();
-    const runStart = performance.now();
+    const runStart = realPerformanceNow();
     // Cache clean mode
     if (options.cacheClean) {
         const projectRoot = process.cwd();
@@ -159,7 +164,7 @@ export async function runTestsCLI(options = {}) {
             if (result.tempCacheDeleted)
                 lines.push("✔ deleted temp cache");
             if (lines.length === 0)
-                lines.push("— nothing to clean");
+                lines.push("- nothing to clean");
             console.log(lines.join("\n"));
         }
         return;
@@ -215,7 +220,7 @@ export async function runTestsCLI(options = {}) {
                 testDir: dir,
                 configPath: resolvedConfigPath,
                 files: [],
-                durationMs: performance.now() - runStart,
+                durationMs: realPerformanceNow() - runStart,
                 results: [],
             };
             console.log(JSON.stringify(report, null, 2));
@@ -265,7 +270,7 @@ export async function runTestsCLI(options = {}) {
         });
     }
     const ok = failed === 0;
-    const durationMs = performance.now() - runStart;
+    const durationMs = realPerformanceNow() - runStart;
     // JSON mode: stdout must be JSON only
     if (options.json) {
         const report = {
@@ -288,7 +293,7 @@ export async function runTestsCLI(options = {}) {
             process.exitCode = 1;
         return;
     }
-    // ── Pretty reporting ──────────────────────────────────────────────
+    // Pretty reporting
     const groups = groupResultsByFile(results);
     // File-by-file results
     for (const group of groups) {
@@ -343,7 +348,7 @@ export async function runTestsCLI(options = {}) {
             }
         }
     }
-    // ── Failure details ────────────────────────────────────────────────
+    // Failure details
     if (failures.length > 0) {
         console.log(`\n${horizontalRule(colors.boldRed(" FAILURES "))}\n`);
         failures.forEach((r, i) => {
@@ -373,7 +378,7 @@ export async function runTestsCLI(options = {}) {
         });
         console.log(`\n${horizontalRule()}`);
     }
-    // ── Summary ────────────────────────────────────────────────────────
+    // Summary
     console.log("");
     const summaryParts = [];
     if (passed > 0)
@@ -461,7 +466,7 @@ export async function watchTestsCLI(options = {}) {
         running = true;
         const shortFile = shortenPath(filename);
         console.log(`\n${colors.dim("─".repeat(Math.min(process.stdout.columns || 80, 80)))}`);
-        console.log(` ${colors.dim("↺")} ${colors.dim(`${shortFile} changed — re-running…`)}\n`);
+        console.log(` ${colors.dim("↺")} ${colors.dim(`${shortFile} changed - re-running…`)}\n`);
         // Reset exit code so each run is evaluated independently
         process.exitCode = 0;
         try {

package/dist/esm/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAGlE,qBAAa,IAAI;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,EAAE,QAAQ,CAAC;IAEf,MAAM,EAAE,UAAU,CAAsB;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAGjB,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,EACtB,IAAI,GAAE,QAA2B,EACjC,SAAS,CAAC,EAAE,MAAM;IAQd,GAAG,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAuDnD"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AASlE,qBAAa,IAAI;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,EAAE,QAAQ,CAAC;IAEf,MAAM,EAAE,UAAU,CAAsB;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAGjB,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,EACtB,IAAI,GAAE,QAA2B,EACjC,SAAS,CAAC,EAAE,MAAM;IAQd,GAAG,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAyDnD"}