From 0930df6b71dcceca03b3a0eca6a2124d6bca4756 Mon Sep 17 00:00:00 2001
From: Michael B Reiser <mreiser@gmail.com>
Date: Sun, 18 Oct 2026 13:17:54 -0400
Subject: [PATCH] =?UTF-8?q?runner:=20throttle-proof=20host-timed=20waits?=
 =?UTF-8?q?=20=E2=80=94=20Worker=20timer=20with=20a=20setTimeout=20backsto?=
 =?UTF-8?q?p=20(LAB-303)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ArenaRunner._sleep was a plain setTimeout. Chrome aligns page timers to 1 s ticks
once the tab is hidden or the window is occluded, so on the Bergamo 2P rig
(2026-10-16) every host-timed 3 s step ran 4.00 s while the operator worked in
ScanImage over the Studio window.

The wait now runs on createSleepTimer(): a dedicated Worker built from an inline
blob URL (the runner stays a classic <script src> module) arms the timeout and
posts back; a page setTimeout is armed beside it as a backstop and whichever
fires first wins, so the Worker path is never worse than before. Without Worker /
Blob / URL (Node tests) or after a Worker error the setTimeout alone runs.
_resolveSleep() clears the handle through the same timer, so stop() / _clear()
still wake the wait at once. A wait that overshoots by > 250 ms emits a 'warn'
event naming timer throttling, so a starved page shows in the run log.

Tests: fallback completes, stop()/_clear() wake a 5 s wait, fake-Worker path
(set/clear/backstop/onerror → fallback), the inline Worker source's protocol,
late-wait warn, and runSequence with the real sleep (completes; aborts mid-wait).
arena_studio.html bumps the runner's ?v= cache-buster.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 arena_studio.html             |   2 +-
 js/arena-runner-g6.js         | 185 ++++++++++++++++++++-
 tests/test-arena-runner-g6.js | 291 ++++++++++++++++++++++++++++++++++
 3 files changed, 472 insertions(+), 6 deletions(-)

diff --git a/arena_studio.html b/arena_studio.html
index 0cd898fb..f6443b73 100644
--- a/arena_studio.html
+++ b/arena_studio.html
@@ -3363,7 +3363,7 @@ <h2 id="modalTitle">Import error</h2>
 <script src="js/studio-analog-in.js"></script>
 <script src="js/studio-panel-inventory.js"></script>
 <script src="js/arena-link.js"></script>
-<script src="js/arena-runner-g6.js?v=20260926-cl-start"></script> <!-- ?v= forces a fresh load: a cached runner/client silently runs the old closed-loop start -->
+<script src="js/arena-runner-g6.js?v=20261018-worker-timer"></script> <!-- ?v= forces a fresh load: a cached runner silently keeps the old throttled setTimeout wait (hidden-window 4 s steps) -->
 <script src="js/run-log.js"></script>
 <script src="js/fictrac-bridge-client.js?v=20260926-cl-start"></script>
 <script src="js/arena-session.js"></script>
diff --git a/js/arena-runner-g6.js b/js/arena-runner-g6.js
index 94fa7f61..823c694e 100644
--- a/js/arena-runner-g6.js
+++ b/js/arena-runner-g6.js
@@ -1065,6 +1065,154 @@ var ArenaRunnerG6 = (function () {
         await sleep((Number(remainderSec) || 0) * 1000);
     }
 
+    // ---- throttle-proof host-side wait timer ------------------------------
+    //
+    // A page setTimeout is throttled once the tab is hidden or the window is
+    // occluded: Chrome aligns it to 1 s ticks (1 min after 5 min hidden). On the
+    // Bergamo 2P rig (2026-10-16) every host-timed 3 s step ran 4.00 s while the
+    // operator worked in ScanImage over the Studio window. Dedicated Workers are
+    // not throttled, so the wait is armed in a Worker built from an inline blob
+    // URL (no extra file — this module must stay a classic <script src>). A page
+    // setTimeout is armed beside it as a backstop and whichever fires first wins,
+    // so the Worker path is never worse than the old behavior. Where Worker /
+    // Blob / URL are missing (Node tests, old engines) or the Worker fails, the
+    // setTimeout alone runs, exactly as before.
+    const SLEEP_WORKER_SRC =
+        'var t={};' +
+        'self.onmessage=function(e){var d=e.data;' +
+        "if(d.op==='set'){t[d.id]=setTimeout(function(){delete t[d.id];self.postMessage(d.id)},d.ms)}" +
+        "else if(d.op==='clear'){clearTimeout(t[d.id]);delete t[d.id]}};";
+
+    /** A wait that overshoots its request by more than this is reported as a 'warn' event. */
+    const SLEEP_LATE_WARN_MS = 250;
+
+    /**
+     * Build a wait timer: set(ms, cb) → handle, clear(handle). `kind` says which
+     * mechanism is live ('worker' | 'timeout'); `lastError` why the Worker was
+     * dropped, if it was. `deps` lets tests inject a fake Worker / Blob / URL /
+     * setTimeout; by default the globals are used.
+     * @param {{Worker?:function, Blob?:function, URL?:object, setTimeout?:function, clearTimeout?:function}} [deps]
+     */
+    function createSleepTimer(deps) {
+        deps = deps || {};
+        const g = typeof globalThis !== 'undefined' ? globalThis : {};
+        const WorkerCtor = deps.Worker !== undefined ? deps.Worker : g.Worker;
+        const BlobCtor = deps.Blob !== undefined ? deps.Blob : g.Blob;
+        const URLObj = deps.URL !== undefined ? deps.URL : g.URL;
+        const setT = deps.setTimeout || setTimeout;
+        const clearT = deps.clearTimeout || clearTimeout;
+        let worker = null;
+        let workerState = 'unset'; // 'unset' | 'ready' | 'unavailable'
+        let lastError = null;
+        let nextId = 1;
+        const pending = new Map(); // id → { cb, backstop, inWorker }
+
+        function dropWorker(reason) {
+            // The backstop timeouts already cover every pending wait — nothing is lost.
+            if (worker) {
+                try {
+                    worker.terminate();
+                } catch (_) {
+                    /* ignore */
+                }
+            }
+            worker = null;
+            workerState = 'unavailable';
+            lastError = reason ? String(reason.message || reason) : 'worker failed';
+        }
+        function fire(id) {
+            const p = pending.get(id);
+            if (!p) return; // the other arm fired first, or clear() won
+            pending.delete(id);
+            if (p.backstop !== null) clearT(p.backstop);
+            if (p.inWorker && worker) {
+                try {
+                    worker.postMessage({ op: 'clear', id });
+                } catch (_) {
+                    /* ignore */
+                }
+            }
+            p.cb();
+        }
+        function ensureWorker() {
+            if (workerState !== 'unset') return;
+            const ok =
+                typeof WorkerCtor === 'function' &&
+                typeof BlobCtor === 'function' &&
+                URLObj &&
+                typeof URLObj.createObjectURL === 'function';
+            if (!ok) {
+                workerState = 'unavailable';
+                lastError = 'Worker/Blob/URL unavailable';
+                return;
+            }
+            try {
+                const url = URLObj.createObjectURL(
+                    new BlobCtor([SLEEP_WORKER_SRC], { type: 'text/javascript' })
+                );
+                const w = new WorkerCtor(url);
+                w.onmessage = (e) => fire(e && e.data);
+                w.onerror = (e) => dropWorker(e || 'worker error');
+                worker = w;
+                workerState = 'ready';
+            } catch (e) {
+                dropWorker(e);
+            }
+        }
+        return {
+            set(ms, cb) {
+                ensureWorker();
+                const id = nextId++;
+                const p = { cb, backstop: null, inWorker: false };
+                pending.set(id, p);
+                p.backstop = setT(() => fire(id), ms);
+                if (worker) {
+                    try {
+                        worker.postMessage({ op: 'set', id, ms });
+                        p.inWorker = true;
+                    } catch (e) {
+                        dropWorker(e);
+                    }
+                }
+                return id;
+            },
+            clear(id) {
+                const p = pending.get(id);
+                if (!p) return;
+                pending.delete(id);
+                if (p.backstop !== null) clearT(p.backstop);
+                if (p.inWorker && worker) {
+                    try {
+                        worker.postMessage({ op: 'clear', id });
+                    } catch (_) {
+                        /* ignore */
+                    }
+                }
+            },
+            get kind() {
+                ensureWorker();
+                return worker ? 'worker' : 'timeout';
+            },
+            get lastError() {
+                return lastError;
+            },
+            get pendingCount() {
+                return pending.size;
+            },
+            /** Tests only: tear the Worker down (pending waits keep their backstop). */
+            dispose() {
+                if (worker) dropWorker('disposed');
+            }
+        };
+    }
+
+    let _sharedSleepTimer = null;
+    /** The page-wide wait timer (one Worker per page, created on first use). */
+    function sleepTimer() {
+        if (!_sharedSleepTimer) _sharedSleepTimer = createSleepTimer();
+        return _sharedSleepTimer;
+    }
+
     // ---- run-state machine ----------------------------------------------
 
     /**
@@ -1097,8 +1245,9 @@ var ArenaRunnerG6 = (function () {
             this._conditionName = null;
             this._lastResponse = null;
             this._abort = false; // sequence abort flag (set by stop()/_clear())
-            this._sleepTimer = null; // in-progress host-side wait timer
+            this._sleepTimer = null; // in-progress host-side wait (a sleepTimer() handle)
             this._sleepResolve = null; // resolver for the in-progress wait
+            this._timerImpl = null; // tests: a createSleepTimer() to use instead of the shared one
             this._ledActivator = null; // active conditional-LED evaluator (Mode 3)
             this._ledUnsub = null; // bridge 'applied' unsubscribe for the above
             this._emit = null; // current run's status emit (for async LED events)
@@ -1471,7 +1620,7 @@ var ArenaRunnerG6 = (function () {
         /** Resolve + clear any in-progress host-side wait (makes STOP prompt). */
         _resolveSleep() {
             if (this._sleepTimer) {
-                clearTimeout(this._sleepTimer);
+                (this._timerImpl || sleepTimer()).clear(this._sleepTimer);
                 this._sleepTimer = null;
             }
             if (this._sleepResolve) {
@@ -1484,7 +1633,11 @@ var ArenaRunnerG6 = (function () {
         /**
          * Abort-aware sleep: resolves after `ms`, OR immediately if already aborted
          * or stop() fires mid-wait. Only one wait is outstanding at a time (the
-         * sequence loop awaits each in turn).
+         * sequence loop awaits each in turn). The wait runs on the throttle-proof
+         * sleepTimer() (Worker + backstop setTimeout); a wait that still overshoots
+         * by more than SLEEP_LATE_WARN_MS is reported as a 'warn' event, so a
+         * throttled or starved page shows up in the run log instead of only in the
+         * data.
          */
         _sleep(ms) {
             return new Promise((resolve) => {
@@ -1492,12 +1645,31 @@ var ArenaRunnerG6 = (function () {
                     resolve();
                     return;
                 }
+                const t0 = Date.now();
                 this._sleepResolve = resolve;
-                this._sleepTimer = setTimeout(() => {
+                this._sleepTimer = (this._timerImpl || sleepTimer()).set(ms, () => {
                     this._sleepTimer = null;
                     this._sleepResolve = null;
+                    const late = Date.now() - t0 - ms;
+                    if (late > SLEEP_LATE_WARN_MS && typeof this._emit === 'function') {
+                        try {
+                            this._emit({
+                                phase: 'warn',
+                                reason:
+                                    'host-timed wait ran ' +
+                                    ((ms + late) / 1000).toFixed(2) +
+                                    ' s instead of ' +
+                                    (ms / 1000).toFixed(2) +
+                                    ' s (browser timer throttling? keep the Studio window visible)',
+                                requested_ms: ms,
+                                actual_ms: ms + late
+                            });
+                        } catch (_) {
+                            /* a logging failure must not break the run */
+                        }
+                    }
                     resolve();
-                }, ms);
+                });
             });
         }
 
@@ -2145,6 +2317,9 @@ var ArenaRunnerG6 = (function () {
         LED_MIN_STEP_MV, // smallest AO change the activator bothers to send (mV)
         normalizeBias, // validate/normalize startClosedLoop bias params → {bias, warning} (throws on bad)
         makeLedActivator, // pure stateful index→{level, mv, changed} evaluator over the zone vector
+        createSleepTimer, // throttle-proof wait timer factory (Worker + backstop setTimeout)
+        sleepTimer, // the page-wide instance the runner's host-side waits use
+        SLEEP_LATE_WARN_MS, // overshoot (ms) above which a host-timed wait logs a 'warn'
         ArenaRunner
     };
 })();
diff --git a/tests/test-arena-runner-g6.js b/tests/test-arena-runner-g6.js
index aff5b345..7fd8320b 100644
--- a/tests/test-arena-runner-g6.js
+++ b/tests/test-arena-runner-g6.js
@@ -2938,6 +2938,297 @@ async function main() {
         check('clean run → stopAcked true', s4.stopAcked, true);
     }
 
+    console.log('\n=== _sleep: throttle-proof timer (Worker + backstop setTimeout) ===');
+    {
+        // Node has no Worker: the shared timer falls back to setTimeout, and a wait
+        // completes after (about) the requested time.
+        const t = Runner.sleepTimer();
+        check('Node: no Worker → kind timeout', t.kind, 'timeout');
+        check('Node: lastError names the missing API', t.lastError, 'Worker/Blob/URL unavailable');
+        const runner = new Runner.ArenaRunner(makeFakeLink(), Wire);
+        const t0 = Date.now();
+        await runner._sleep(60);
+        const dt = Date.now() - t0;
+        check('fallback sleep(60) completes (≥ 50 ms)', dt >= 50, true);
+        check('fallback sleep leaves no pending wait', t.pendingCount, 0);
+        check('fallback sleep clears the handle', runner._sleepTimer, null);
+        // Non-positive / already-aborted waits resolve at once.
+        const t1 = Date.now();
+        await runner._sleep(0);
+        await runner._sleep(-5);
+        check('sleep(0) / sleep(-5) resolve immediately', Date.now() - t1 < 40, true);
+    }
+
+    console.log('\n=== _sleep: resolves on abort (stop() / _clear() wake the wait) ===');
+    {
+        const race = (p, ms) =>
+            Promise.race([
+                p.then(() => 'woke'),
+                new Promise((r) => setTimeout(() => r('stuck'), ms))
+            ]);
+        const t = Runner.sleepTimer();
+        const runner = new Runner.ArenaRunner(makeFakeLink(), Wire);
+        const p1 = runner._sleep(5000);
+        check('long wait is pending', t.pendingCount, 1);
+        await runner.stop();
+        check('stop() wakes a 5 s wait', await race(p1, 300), 'woke');
+        check('stop() cleared the pending wait (no leak)', t.pendingCount, 0);
+        check('stop() cleared the handle', runner._sleepTimer, null);
+
+        const runner2 = new Runner.ArenaRunner(makeFakeLink(), Wire);
+        const p2 = runner2._sleep(5000);
+        runner2._clear();
+        check('_clear() wakes a 5 s wait', await race(p2, 300), 'woke');
+        check('_clear() cleared the pending wait', t.pendingCount, 0);
+
+        // A wait requested AFTER the abort flag is up resolves at once.
+        const p3 = runner2._sleep(5000);
+        check('sleep after abort resolves immediately', await race(p3, 300), 'woke');
+        check('…and arms nothing', t.pendingCount, 0);
+    }
+
+    console.log('\n=== createSleepTimer: Worker path (fake Worker) ===');
+    {
+        // A fake Worker records what the page posts; the test plays the Worker's
+        // reply by hand. The backstop setTimeout is captured, never auto-fired.
+        const posted = [];
+        const timeouts = new Map();
+        let nextT = 100;
+        const cleared = [];
+        let instances = 0;
+        let lastWorker = null;
+        class FakeWorker {
+            constructor(url) {
+                instances++;
+                this.url = url;
+                this.onmessage = null;
+                this.onerror = null;
+                this.terminated = false;
+                lastWorker = this;
+            }
+            postMessage(m) {
+                posted.push(m);
+            }
+            terminate() {
+                this.terminated = true;
+            }
+        }
+        class FakeBlob {
+            constructor(parts, opts) {
+                this.src = parts.join('');
+                this.type = opts && opts.type;
+            }
+        }
+        let lastBlob = null;
+        const FakeURL = {
+            createObjectURL: (b) => {
+                lastBlob = b;
+                return 'blob:fake/' + b.src.length;
+            }
+        };
+        const deps = {
+            Worker: FakeWorker,
+            Blob: FakeBlob,
+            URL: FakeURL,
+            setTimeout: (cb, ms) => {
+                const id = nextT++;
+                timeouts.set(id, { cb, ms });
+                return id;
+            },
+            clearTimeout: (id) => {
+                cleared.push(id);
+                timeouts.delete(id);
+            }
+        };
+        const t = Runner.createSleepTimer(deps);
+        check('Worker available → kind worker', t.kind, 'worker');
+        check('one Worker per timer', instances, 1);
+        check('Worker built from a blob URL', String(lastWorker.url).startsWith('blob:'), true);
+        // The inline Worker source is self-contained: run it against a fake `self`
+        // to pin the message protocol the page side speaks ({op:set,id,ms} →
+        // postMessage(id) after ms; {op:clear,id} cancels).
+        {
+            const wTimeouts = new Map();
+            let wNext = 1;
+            const wPosted = [];
+            const fakeSelf = { onmessage: null, postMessage: (m) => wPosted.push(m) };
+            new Function('self', 'setTimeout', 'clearTimeout', lastBlob.src)(
+                fakeSelf,
+                (cb, ms) => {
+                    const id = wNext++;
+                    wTimeouts.set(id, { cb, ms });
+                    return id;
+                },
+                (id) => wTimeouts.delete(id)
+            );
+            check('Worker source installs onmessage', typeof fakeSelf.onmessage, 'function');
+            fakeSelf.onmessage({ data: { op: 'set', id: 7, ms: 1234 } });
+            check('Worker: set arms one timeout with the ms', [...wTimeouts.values()][0].ms, 1234);
+            {
+                const [tid, entry] = [...wTimeouts.entries()][0];
+                wTimeouts.delete(tid); // a real timeout is gone once it fires
+                entry.cb();
+            }
+            check('Worker: timeout posts the id back', JSON.stringify(wPosted), '[7]');
+            fakeSelf.onmessage({ data: { op: 'set', id: 8, ms: 50 } });
+            fakeSelf.onmessage({ data: { op: 'clear', id: 8 } });
+            check('Worker: clear cancels the timeout', wTimeouts.size, 0);
+        }
+
+        let fired = 0;
+        const h = t.set(3000, () => fired++);
+        check(
+            'set() posts {op:set, id, ms} to the Worker',
+            JSON.stringify(posted[0]),
+            JSON.stringify({ op: 'set', id: h, ms: 3000 })
+        );
+        check('set() arms the backstop setTimeout too', timeouts.size, 1);
+        check('backstop uses the same ms', [...timeouts.values()][0].ms, 3000);
+        // The Worker answers first (the page timer is throttled): callback once,
+        // backstop cleared.
+        lastWorker.onmessage({ data: h });
+        check('Worker reply fires the callback', fired, 1);
+        check('…and clears the backstop', timeouts.size, 0);
+        check('…exactly one clearTimeout', cleared.length, 1);
+        check('…nothing left pending', t.pendingCount, 0);
+        // A late duplicate (backstop or Worker) is ignored.
+        lastWorker.onmessage({ data: h });
+        check('duplicate Worker reply is ignored', fired, 1);
+
+        // clear() before either arm fires: Worker told to clear, backstop dropped,
+        // callback never runs.
+        let fired2 = 0;
+        const h2 = t.set(1000, () => fired2++);
+        t.clear(h2);
+        check(
+            'clear() posts {op:clear} to the Worker',
+            JSON.stringify(posted[posted.length - 1]),
+            JSON.stringify({ op: 'clear', id: h2 })
+        );
+        check('clear() drops the backstop', timeouts.size, 0);
+        lastWorker.onmessage({ data: h2 });
+        check('cleared wait never fires', fired2, 0);
+
+        // The backstop wins when the Worker is silent (e.g. the browser killed it):
+        // the callback still runs once.
+        let fired3 = 0;
+        const h3 = t.set(500, () => fired3++);
+        const bs = [...timeouts.values()][0];
+        bs.cb();
+        check('backstop fires the callback when the Worker is silent', fired3, 1);
+        check(
+            '…and the Worker is told to clear its copy',
+            JSON.stringify(posted[posted.length - 1]),
+            JSON.stringify({ op: 'clear', id: h3 })
+        );
+        lastWorker.onmessage({ data: h3 });
+        check('late Worker reply after the backstop is ignored', fired3, 1);
+
+        // Worker error mid-wait: the timer drops to the setTimeout path; the pending
+        // wait keeps its backstop and still completes.
+        let fired4 = 0;
+        t.set(700, () => fired4++);
+        lastWorker.onerror(new Error('boom'));
+        check('onerror → kind timeout', t.kind, 'timeout');
+        check('onerror → lastError recorded', t.lastError, 'boom');
+        check('onerror → Worker terminated', lastWorker.terminated, true);
+        check('pending wait keeps its backstop', timeouts.size, 1);
+        [...timeouts.values()][0].cb();
+        check('…which still fires the callback', fired4, 1);
+        // Subsequent waits are setTimeout-only (no new Worker is built).
+        t.set(10, () => {});
+        check('after the error: no new Worker', instances, 1);
+        check('after the error: no Worker message', posted.filter((m) => m.op === 'set').length, 4);
+    }
+
+    console.log('\n=== createSleepTimer: a Worker constructor that throws → fallback ===');
+    {
+        const t = Runner.createSleepTimer({
+            Worker: function () {
+                throw new Error('CSP blocks blob workers');
+            },
+            Blob: function () {},
+            URL: { createObjectURL: () => 'blob:x' }
+        });
+        check('throwing Worker → kind timeout', t.kind, 'timeout');
+        check('throwing Worker → reason kept', t.lastError, 'CSP blocks blob workers');
+        let fired = 0;
+        const t0 = Date.now();
+        await new Promise((resolve) =>
+            t.set(30, () => {
+                fired++;
+                resolve();
+            })
+        );
+        check('fallback wait fires once', fired, 1);
+        check('fallback wait honors ms (≥ 25)', Date.now() - t0 >= 25, true);
+    }
+
+    console.log('\n=== _sleep: a late wait is reported as a warn event ===');
+    {
+        const runner = new Runner.ArenaRunner(makeFakeLink(), Wire);
+        const events = [];
+        runner._emit = (ev) => events.push(ev);
+        // A timer that overshoots every request by 400 ms (a throttled page).
+        runner._timerImpl = {
+            set: (ms, cb) => setTimeout(cb, ms + 400),
+            clear: (h) => clearTimeout(h)
+        };
+        await runner._sleep(20);
+        const warn = events.find((e) => e.phase === 'warn');
+        check('late wait → one warn event', events.length, 1);
+        check('warn names timer throttling', /throttling/.test((warn || {}).reason || ''), true);
+        check('warn carries requested_ms', (warn || {}).requested_ms, 20);
+        check('warn actual_ms ≥ requested + 400', ((warn || {}).actual_ms || 0) >= 420, true);
+        // An on-time wait emits nothing.
+        runner._timerImpl = { set: (ms, cb) => setTimeout(cb, ms), clear: (h) => clearTimeout(h) };
+        events.length = 0;
+        await runner._sleep(20);
+        check('on-time wait → no event', events.length, 0);
+    }
+
+    console.log('\n=== runSequence: default (real) sleep completes and aborts mid-wait ===');
+    {
+        const mk = (waitSec) =>
+            new Map([
+                [
+                    'w',
+                    {
+                        name: 'w',
+                        commands: [
+                            { type: 'controller', command_name: 'allOn' },
+                            { type: 'wait', duration: waitSec }
+                        ]
+                    }
+                ]
+            ]);
+        const steps = [{ kind: 'ref', conditionName: 'w', label: 'w', seqIdx: 0, dur: 1 }];
+        const link = makeFakeLink();
+        const runner = new Runner.ArenaRunner(link, Wire);
+        const t0 = Date.now();
+        const summary = await runner.runSequence({
+            steps,
+            conditionsByName: mk(0.05),
+            resolvePatternId: () => 1
+        });
+        check('real sleep: sequence completes', summary.completed, true);
+        check('real sleep: waited ≥ 40 ms', Date.now() - t0 >= 40, true);
+
+        const link2 = makeFakeLink();
+        const runner2 = new Runner.ArenaRunner(link2, Wire);
+        const t1 = Date.now();
+        const pending = runner2.runSequence({
+            steps,
+            conditionsByName: mk(30),
+            resolvePatternId: () => 1
+        });
+        setTimeout(() => runner2.stop(), 50);
+        const s2 = await pending;
+        check('stop() mid-wait aborts the sequence', s2.aborted, true);
+        check('…promptly (< 2 s, not after the 30 s wait)', Date.now() - t1 < 2000, true);
+        check('…and nothing stays pending', Runner.sleepTimer().pendingCount, 0);
+    }
+
     console.log('\n=== Summary ===');
     console.log(`${totalChecks - failures} / ${totalChecks} checks passed`);
     process.exit(failures === 0 ? 0 : 1);