hbengine 0.2.3

package/engine-conformance/testdata/clock-probe/bundle/game.css

@@ -0,0 +1,17 @@
+body { margin: 0; background: #08141a; color: #F9F9FB; font: 500 14px/1.4 'Figtree', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; }
+.dice { width: 100%; max-width: 560px; box-sizing: border-box; padding: 20px; display: grid; gap: 20px; }
+.facts { display: flex; flex-wrap: wrap; gap: 16px; justify-content: space-between; font-size: 13px; color: #8F96A8; font-variant-numeric: tabular-nums; }
+.facts b { color: #F9F9FB; font-weight: 700; font-size: 15px; }
+.track { position: relative; height: 48px; background: #0b1f28; border: 1px solid #0D2A38; border-radius: 24px; }
+.win { position: absolute; top: 0; bottom: 0; background: rgba(40, 243, 243, 0.22); border-left: 1px solid #28F3F3; border-right: 1px solid #28F3F3; border-radius: inherit; }
+.scale { position: absolute; inset: 100% 12px auto 12px; padding-top: 6px; display: flex; justify-content: space-between; color: #8F96A8; font-size: 11px; font-variant-numeric: tabular-nums; }
+.marker { position: absolute; top: 50%; left: 22px; transform: translate(-50%, -50%); min-width: 44px; height: 36px; padding: 0 10px; display: grid; place-items: center; border-radius: 18px; background: #28F3F3; color: #041015; font-weight: 700; font-size: 15px; font-variant-numeric: tabular-nums; box-shadow: 0 6px 20px rgba(0,0,0,.4); transition: left 620ms cubic-bezier(.2,.8,.2,1); }
+.marker.win { background: #58e879; }
+.marker.lose { background: #FA2E5D; color: #F9F9FB; }
+.pick { display: grid; gap: 12px; }
+.side { display: inline-flex; padding: 3px; gap: 3px; background: rgba(9,102,125,0.15); border-radius: 8px; justify-self: start; }
+.side button { height: 32px; padding: 0 14px; border: 0; border-radius: 6px; background: transparent; color: #8F96A8; font: inherit; font-weight: 600; cursor: pointer; }
+.side button[aria-pressed="true"] { background: #0D2A38; color: #F9F9FB; }
+.target { display: grid; grid-template-columns: 1fr auto; gap: 12px; align-items: center; }
+.target input[type="range"] { width: 100%; accent-color: #28F3F3; }
+.target output { color: #F9F9FB; font-weight: 700; font-variant-numeric: tabular-nums; min-width: 28px; text-align: right; }

package/engine-conformance/testdata/clock-probe/bundle/game.js

@@ -0,0 +1,65 @@
+// Dice: roll under or over N on 0–99. The zone picks the bet by setting
+// game.bet; /engine-sdk/ui.js draws the panel around it.
+import { mount } from '/engine-sdk/ui.js';
+
+const el = document.getElementById('game');
+const marker = document.getElementById('marker');
+const winBand = document.getElementById('win');
+const mult = document.getElementById('mult');
+const chance = document.getElementById('chance');
+const maxwin = document.getElementById('maxwin');
+const target = document.getElementById('target');
+const val = document.getElementById('val');
+const sides = el.querySelectorAll('[data-side]');
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+const pct = (x) => (x / 99 * 100) + '%';
+
+let side = 'under';
+let n = 50;
+
+const game = await mount(el, {
+    async reveal(round) {
+        // The probe (probe.js) reads the clocks again at every round.
+        document.dispatchEvent(new CustomEvent('probe-round'));
+        const roll = round.data[0].roll;
+        marker.classList.remove('win', 'lose');
+        marker.textContent = '?';
+        marker.style.transition = 'none';
+        marker.style.left = '22px';
+        void marker.offsetWidth;
+        marker.style.transition = '';
+        await wait(40);
+        marker.style.left = `clamp(22px, ${pct(roll)}, calc(100% - 22px))`; // the marker stays on the track at 0 and 99
+        await wait(620);
+        marker.textContent = String(roll);
+        marker.classList.add(round.payout > 0 ? 'win' : 'lose');
+    },
+});
+const { engine, field } = game;
+const money = engine.money;
+// The pairing this frame plays under: its width and the money the game was given (travel.browser.test.mjs holds a variant's to one the frame-size run plays).
+console.error('clock-probe display ' + JSON.stringify({ w: innerWidth, isFiat: money.isFiat, unit: money.unit }));
+const bets = new Map(engine.config.modes[0].bets.map((b) => [b.id, b]));
+const range = () => (side === 'under' ? [0, n - 1] : [n + 1, 99]);
+
+function paint() {
+    val.textContent = String(n);
+    const [lo, hi] = range();
+    winBand.style.left = pct(lo);
+    winBand.style.width = pct(hi - lo);
+    chance.textContent = String(hi - lo + 1);
+    const bet = bets.get(`${side}-${n}`);
+    const m = bet.maxMultBp / 10000;
+    mult.textContent = m.toFixed(2) + '×';
+    maxwin.textContent = money.sign + money.format(money.payout(field.amount, m)) + (money.sign ? '' : ' ' + money.unit);
+    game.bet = bet.id;
+}
+
+for (const s of sides) s.addEventListener('click', () => {
+    side = s.dataset.side;
+    for (const o of sides) o.setAttribute('aria-pressed', String(o === s));
+    paint();
+});
+target.addEventListener('input', () => { n = +target.value; paint(); });
+field.addEventListener('change', paint);
+paint();

package/engine-conformance/testdata/clock-probe/bundle/hbtest.json

@@ -0,0 +1,4 @@
+{
+  "stake": { "page": "index.html", "selector": "hb-game hb-bet-amount input", "value": "1.00" },
+  "bet": { "page": "index.html", "selector": "hb-game [data-main]" }
+}

package/engine-conformance/testdata/clock-probe/bundle/index.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Clock probe</title>
+<link rel="stylesheet" href="./game.css">
+<script type="module" src="/engine-sdk/bet-field.js"></script>
+<script type="module" src="./game.js"></script>
+<script src="./probe.js"></script>
+</head>
+<body>
+<hb-game id="game">
+  <div slot="zone" class="dice" aria-live="polite">
+    <div class="facts">
+      <span>Payout <b id="mult">2.00×</b></span>
+      <span>Chance <b id="chance">50</b>%</span>
+      <span>Max win <b id="maxwin">—</b></span>
+    </div>
+    <div class="track" id="track">
+      <div class="win" id="win"></div>
+      <div class="scale"><span>0</span><span>25</span><span>50</span><span>75</span><span>99</span></div>
+      <div class="marker" id="marker">?</div>
+    </div>
+    <div class="pick">
+      <div class="side" role="tablist">
+        <button type="button" data-side="under" aria-pressed="true">Under</button>
+        <button type="button" data-side="over">Over</button>
+      </div>
+      <label class="target"><input id="target" type="range" min="2" max="98" step="1" value="50" aria-label="target"><output id="val">50</output></label>
+    </div>
+  </div>
+</hb-game>
+</body>
+</html>

package/engine-conformance/testdata/clock-probe/bundle/probe-worker.js

@@ -0,0 +1,46 @@
+// A test bundle's worker (probe.js): asked once, it reads every clock a worker
+// has, what its Date, timers, performance and File look like, where it runs
+// from, and what a worker of its own reads, and answers with all of it. The
+// same text runs as a same-origin script and as a blob. Every delta is a
+// number (ms), never a verdict: the page writes it fixed-width and the test
+// holds it to a threshold.
+const str = (f) => { try { return Function.prototype.toString.call(f); } catch { return 'not a function'; } };
+const suspicious = (names) => names.filter((k) => /^(__|\$cdc|_pw|cdc_)|pw|playwright|puppeteer|selenium|webdriver|clock|travel|driver|automation|headless/i.test(k)).sort();
+const depth = (s) => String(s || '').split('\n').filter((l) => /^\s+at /.test(l)).length;
+// What the worker's clocks read when it started: a browser keeps a worker's
+// timeOrigin, and so Date.now() - performance.now(), for the worker's life.
+const origin0 = performance.timeOrigin, delta0 = Date.now() - performance.now();
+// Real work (probe.js burn/SPIN): a busy loop calibrated here, outside any
+// timer, by doubling its count until it takes six milliseconds or more as it
+// then runs, spun inside a timer callback when asked.
+const burn = (n) => { let x = 0; for (let i = 0; i < n; i++) x += i & 1; return x; };
+const SPIN = (() => { let n = 1e5; for (let i = 0; i < 16; i++) { const p = performance.now(); burn(n); if (performance.now() - p >= 6) break; n *= 2; } return n; })();
+self.onmessage = async () => {
+    const nested = new Worker(URL.createObjectURL(new Blob(['postMessage(Date.now())'], { type: 'text/javascript' })));
+    const nestedNow = await new Promise((r) => { nested.onmessage = (e) => r(e.data); });
+    nested.terminate();
+    const dtf = new Intl.DateTimeFormat('en-US', { timeZone: 'UTC', year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric', hourCycle: 'h23' });
+    const stack = await new Promise((r) => setTimeout(() => r(depth(new Error('x').stack)), 0));
+    // A scheduler task's 300 ms delay fires when a 300 ms setTimeout armed with it does.
+    const fired = await Promise.all([new Promise((r) => setTimeout(() => r([Date.now(), performance.now()]), 300)), scheduler.postTask(() => [Date.now(), performance.now()], { delay: 300 })]);
+    const post = Math.max(Math.abs(fired[1][0] - fired[0][0]), Math.abs(fired[1][1] - fired[0][1]));
+    // Real work inside a timer callback: performance.now() moves across it (the smallest of three callbacks).
+    const spins = [];
+    for (let i = 0; i < 3; i++) spins.push(await new Promise((r) => setTimeout(() => { const p = performance.now(); burn(SPIN); r(performance.now() - p); }, 0)));
+    postMessage({
+        now: Date.now(), perfTime: performance.timeOrigin + performance.now(), loc: location.protocol, nestedNow,
+        originMoved: performance.timeOrigin - origin0, deltaMoved: (Date.now() - performance.now()) - delta0, post, spin: Math.min(...spins),
+        other: { postName: scheduler.postTask.name, postStr: str(scheduler.postTask), abortName: AbortSignal.timeout.name, abortStr: str(AbortSignal.timeout), waitName: Atomics.waitAsync.name, waitStr: str(Atomics.waitAsync), ric: typeof requestIdleCallback, raf: typeof requestAnimationFrame, perfOwn: Object.getOwnPropertyDescriptor(self, 'performance') === undefined },
+        date: { name: Date.name, len: Date.length, own: Object.getOwnPropertyNames(Date), isFake: 'isFake' in Date, str: str(Date), nowStr: str(Date.now), ctor: new Date().constructor === Date, inst: new Date() instanceof Date },
+        timers: { name: setTimeout.name, len: setTimeout.length, str: str(setTimeout), small: (() => { const t = setTimeout(() => {}, 0); clearTimeout(t); return t < 1e6; })() },
+        perf: { own: Object.getOwnPropertyNames(performance), inst: performance instanceof Performance, originStr: str(Object.getOwnPropertyDescriptor(Performance.prototype, 'timeOrigin').get), toJSON: performance.toJSON().timeOrigin === performance.timeOrigin, markStr: str(performance.mark) },
+        file: { name: File.name, str: str(File), protoCtor: new File([''], 'x').constructor === File, dated: new File([''], 'x', { lastModified: 5 }).lastModified === 5 },
+        globals: suspicious(Object.getOwnPropertyNames(self)),
+        intl: Date.parse(dtf.format()) - Date.parse(dtf.format(new Date())),
+        temporal: typeof Temporal === 'object' ? Temporal.Now.instant().epochMilliseconds - Date.now() : 0,
+        eventTs: new Event('x').timeStamp - performance.now(),
+        fileLM: new File([''], 'x').lastModified - Date.now(),
+        mark: performance.mark('probe').startTime - performance.now(),
+        stack,
+    });
+};

package/engine-conformance/testdata/clock-probe/bundle/probe.js

@@ -0,0 +1,210 @@
+// A test bundle's probe (travel.browser.test.mjs): everything a game could read
+// of its clocks and its surroundings to tell a time-travel run from a plain
+// run, written to the console as error lines the run records (consoleErrors).
+// Every number in a report is written as its size alone, eight digits wide, so a
+// report that differs from another run's only in a measurement is the same
+// text to the run's eye (travel.mjs shape: digits are #) and breaks into the
+// same chunks; only a difference of shape (a name, a descriptor, a property, a
+// global) is a new console error that fails the variant. Four kinds of line:
+//   clock-probe shape NNN/NNN <chunk>  what the clocks and the scope look like
+//   clock-probe boot NNN/NNN <chunk>   the deltas between clocks at boot, in
+//                                      the page and in its workers (a
+//                                      same-origin script, a blob, a worker's
+//                                      own worker)
+//   clock-probe walk NNN/NNN <chunk>   the same oracles read by a timer due
+//                                      twenty minutes in: inside the walk
+//   clock-probe round <n> k=v …        the oracles read at every round, two-letter
+//                                      keys so the line fits the run's 160 characters
+//   clock-probe roundb <n> k=v …       the rest of them (one line holds ten)
+//   clock-probe display {…}            the frame's width and the money the game
+//                                      was given (the pairing a variant plays under)
+// The oracles are the readings a fake clock does not reach by itself: a File's
+// lastModified against Date.now(), document.lastModified against the page's
+// Last-Modified header, a performance mark's startTime against
+// performance.now(), a fetched resource's responseEnd against the
+// performance.now() read before and after the fetch, a running animation's
+// startTime and currentTime against document.timeline.currentTime, 300 ms of
+// performance.now() against the animation's own progress, a scheduler task's
+// 300 ms delay and a 300 ms AbortSignal.timeout against a 300 ms setTimeout
+// armed with them, an animation frame's timestamp against the timeline
+// inside the callback, the last instant this origin's storage saw against
+// Date.now() (a clock that ran backwards between visits), the stack depth
+// inside a setTimeout and a requestAnimationFrame callback, how far
+// performance.now() and Date.now() move across six milliseconds or more of
+// real work inside a setTimeout callback and inside an animation frame's (a
+// clock that stands still inside the callbacks a jump fires reads zero there;
+// a browser's never does), and the same-origin worker's Date.now() against the
+// page's, its performance.timeOrigin and Date.now() - performance.now()
+// against their first readings, its own postTask delay and its own spin.
+(async () => {
+    const str = (f) => { try { return Function.prototype.toString.call(f); } catch { return 'not a function'; } };
+    const desc = (o, k) => { try { const d = Object.getOwnPropertyDescriptor(o, k); return d ? [typeof d.value, typeof d.get, typeof d.set, d.writable, d.enumerable, d.configurable].join('/') : 'none'; } catch { return 'error'; } };
+    const owner = (o, k) => { for (let p = o; p; p = Object.getPrototypeOf(p)) if (Object.getOwnPropertyDescriptor(p, k)) return p; return null; };
+    const suspicious = (names) => names.filter((k) => /^(__|\$cdc|_pw|cdc_)|pw|playwright|puppeteer|selenium|webdriver|clock|travel|driver|automation|headless/i.test(k)).sort();
+    // Storage is the game's own (carried from one variant to the next by design): only a key a harness would plant counts.
+    const planted = (names) => names.filter((k) => /^(__|\$cdc|_pw|cdc_|pw_)|playwright|puppeteer|selenium|webdriver/i.test(k)).sort();
+    const own = (o) => Object.getOwnPropertyNames(o);
+    const abs = (v) => Math.abs(Math.round(v));
+    // A number as the report writes it: its size, eight digits, zero-padded (a delta past 99,999,999 ms is clamped: still plainly not a second); anything that is not a finite number says so.
+    const fixed = (v) => (typeof v === 'number' ? (Number.isFinite(v) ? String(Math.min(abs(v), 99999999)).padStart(8, '0') : 'nan') : v);
+    const say = (tag, o) => {
+        const text = JSON.stringify(o, (k, v) => fixed(v));
+        const size = 120, chunks = Math.ceil(text.length / size); // the run keeps a console line to 160 characters
+        for (let i = 0; i < chunks; i++) console.error(`clock-probe ${tag} ${String(i + 1).padStart(3, '0')}/${String(chunks).padStart(3, '0')} ${text.slice(i * size, (i + 1) * size)}`);
+    };
+    // The stack depth inside a callback: frames below the Error line (production: the callback alone, one). The Error is made in the callback itself, so no helper's frame counts.
+    const depth = (s) => String(s || '').split('\n').filter((l) => /^\s+at /.test(l)).length;
+    const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+    // Real work: a busy loop of `n` iterations, never bounded by a clock (a
+    // clock that stood still would never end it). Calibrated once here, outside
+    // any timer, where performance.now() flows at real pace in every run: the
+    // count is doubled until the loop itself takes six milliseconds or more,
+    // measured on the loop as it then runs (warmed by the doubling, so a loop
+    // the engine later optimises does not come out a fraction of the time
+    // measured cold); the same function spins in the callbacks, so a reading
+    // under a millisecond there is the clock's doing, never the loop's.
+    const burn = (n) => { let x = 0; for (let i = 0; i < n; i++) x += i & 1; return x; };
+    const SPIN = (() => { let n = 1e5; for (let i = 0; i < 16; i++) { const p = performance.now(); burn(n); if (performance.now() - p >= 6) break; n *= 2; } return n; })();
+    const header = (await fetch(location.href)).headers.get('last-modified');
+
+    // ---- the shape: deterministic, the same in every run of the same browser.
+    const fp = {};
+    fp.globals = suspicious(own(window));
+    fp.symbols = Object.getOwnPropertySymbols(window).length === 0;
+    fp.navigator = { webdriver: navigator.webdriver, plugins: navigator.plugins.length > 0, ua: navigator.userAgent, uaData: !!navigator.userAgentData, headless: /headless/i.test(navigator.userAgent) };
+    fp.location = { search: location.search, hash: location.hash, name: window.name, referrer: document.referrer, cookie: document.cookie, ls: planted(Object.keys(localStorage)), ss: planted(Object.keys(sessionStorage)), lastModifiedHeader: typeof header === 'string' && header.length > 20 };
+    const D = Date;
+    fp.date = { name: D.name, len: D.length, own: own(D), isFake: 'isFake' in D, str: str(D), nowName: D.now.name, nowStr: str(D.now), desc: desc(window, 'Date'), protoCtor: new D().constructor === D, protoCtorDesc: desc(D.prototype, 'constructor'), inst: new D() instanceof D, tag: Object.prototype.toString.call(new D()), callStr: typeof D() === 'string', utc: D.UTC(2027, 0, 1) === 1798761600000,
+        sub: (() => { try { class X extends D { x() { return 1; } } const x = new X(); return x.x() === 1 && x instanceof X && x instanceof D && typeof x.getTime() === 'number'; } catch { return false; } })() };
+    fp.timers = {};
+    for (const k of ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'requestAnimationFrame', 'cancelAnimationFrame', 'requestIdleCallback', 'cancelIdleCallback']) { const f = window[k]; fp.timers[k] = typeof f === 'function' ? { name: f.name, len: f.length, str: str(f), desc: desc(window, k) } : typeof f; }
+    const t1 = setTimeout(() => {}, 0), t2 = setTimeout(() => {}, 0); clearTimeout(t1); clearTimeout(t2);
+    const i1 = setInterval(() => {}, 1000); clearInterval(i1);
+    const r1 = requestAnimationFrame(() => {}); cancelAnimationFrame(r1);
+    fp.timerIds = { small: t2 < 1e6 && r1 < 1e6 && i1 < 1e6, seq: t2 === t1 + 1 && i1 === t2 + 1, frameFromOne: r1 === 1, unknownClears: clearTimeout(123456) === undefined };
+    fp.perf = { inst: performance instanceof Performance, proto: Object.getPrototypeOf(performance) === Performance.prototype, own: own(performance), desc: desc(window, 'performance'), nowName: performance.now.name, nowStr: str(performance.now), nowDesc: desc(Performance.prototype, 'now'), originDesc: desc(Performance.prototype, 'timeOrigin'), originStr: str(Object.getOwnPropertyDescriptor(Performance.prototype, 'timeOrigin').get), markName: performance.mark.name, markStr: str(performance.mark), measureStr: str(performance.measure), entryStartDesc: desc(PerformanceEntry.prototype, 'startTime'), entryStartStr: str(Object.getOwnPropertyDescriptor(PerformanceEntry.prototype, 'startTime').get), resourceEndDesc: desc(PerformanceResourceTiming.prototype, 'responseEnd'), timing: Math.abs(performance.timing.navigationStart - performance.timeOrigin) < 60000 };
+    const dtf = new Intl.DateTimeFormat('en-US', { timeZone: 'UTC', year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric', hourCycle: 'h23' });
+    fp.intl = { own: own(Intl).sort(), dtfName: Intl.DateTimeFormat.name, dtfStr: str(Intl.DateTimeFormat), inst: dtf instanceof Intl.DateTimeFormat, instOwn: own(dtf), formatSame: dtf.format === dtf.format, formatDesc: desc(Intl.DateTimeFormat.prototype, 'format'), formatStr: str(dtf.format), partsStr: str(dtf.formatToParts), static: typeof Intl.DateTimeFormat.supportedLocalesOf, resolved: typeof dtf.resolvedOptions().timeZone };
+    fp.event = { tsDesc: desc(Event.prototype, 'timeStamp'), tsStr: str(Object.getOwnPropertyDescriptor(Event.prototype, 'timeStamp').get) };
+    const tlOwner = owner(document.timeline, 'currentTime');
+    fp.timeline = { owner: tlOwner && tlOwner.constructor && tlOwner.constructor.name, str: tlOwner ? str(Object.getOwnPropertyDescriptor(tlOwner, 'currentTime').get) : 'none' };
+    fp.animation = { startDesc: desc(Animation.prototype, 'startTime'), startStr: str(Object.getOwnPropertyDescriptor(Animation.prototype, 'startTime').get), currentDesc: desc(Animation.prototype, 'currentTime'), currentStr: str(Object.getOwnPropertyDescriptor(Animation.prototype, 'currentTime').get) };
+    fp.file = { name: File.name, len: File.length, str: str(File), desc: desc(window, 'File'), protoCtor: new File([''], 'x').constructor === File, inst: new File([''], 'x') instanceof File, blobCtor: new Blob(['']).constructor === Blob, dated: new File([''], 'x', { lastModified: 5 }).lastModified === 5 };
+    fp.temporal = typeof Temporal === 'object' ? { instantStr: str(Temporal.Now.instant), instantName: Temporal.Now.instant.name, zonedStr: str(Temporal.Now.zonedDateTimeISO), own: own(Temporal.Now).sort() } : typeof Temporal;
+    fp.other = { postName: scheduler.postTask.name, postLen: scheduler.postTask.length, postStr: str(scheduler.postTask), postDesc: desc(Object.getPrototypeOf(scheduler), 'postTask'), schedOwn: own(scheduler), yieldStr: str(scheduler.yield), abortName: AbortSignal.timeout.name, abortStr: str(AbortSignal.timeout), abortDesc: desc(AbortSignal, 'timeout'), abortSignal: AbortSignal.timeout(1000) instanceof AbortSignal, waitStr: str(Atomics.waitAsync), waitName: Atomics.waitAsync.name, waitLen: Atomics.waitAsync.length };
+    say('shape', fp);
+
+    // ---- the oracles, read at boot, in the walk and at every round.
+    const parse = (parts) => { const g = (t) => Number(parts.find((p) => p.type === t).value); return Date.UTC(g('year'), g('month') - 1, g('day'), g('hour') % 24, g('minute'), g('second')); };
+    const read = async (tag) => {
+        const d = {};
+        d.fileLM = new File([''], 'x').lastModified - Date.now();
+        d.docLM = Date.parse(document.lastModified) - Date.parse(header);
+        d.mark = performance.mark('probe-' + tag).startTime - performance.now();
+        // A running animation: where it is against the timeline, and its pace against performance.now() over 300 ms of this clock.
+        // Longer than any jump the walk makes (a day and a half an hour), so
+        // the animation never finishes and its progress tracks the clock across
+        // an hourly leap; a short animation would cap at its end mid-jump (as it
+        // would in real time) and read as a difference the clock did not cause.
+        const a = document.documentElement.animate([{ opacity: 1 }, { opacity: 1 }], 100 * 365 * 24 * 3600 * 1000);
+        await a.ready;
+        d.anim = document.timeline.currentTime - a.startTime - a.currentTime;
+        // A fetched resource's responseEnd lies between the clock read before
+        // the fetch and the clock read after it (an entry on another clock than
+        // the page's falls outside by their difference). Read as a window, not
+        // against one later reading: the response ends in one task and is read
+        // in a later one, and a jump of the clock between the two (the walk's
+        // leaps are posted from outside) would otherwise read as the jump.
+        const url = new URL('./hbtest.json?probe=' + tag + '-' + Math.random().toString(36).slice(2), location.href).href;
+        const p1 = performance.now();
+        await (await fetch(url)).text();
+        const p2 = performance.now();
+        const e = performance.getEntriesByName(url).at(-1);
+        d.res = e ? Math.max(0, p1 - e.responseEnd, e.responseEnd - p2) : NaN;
+        const c0 = a.currentTime, p0 = performance.now();
+        await wait(300);
+        d.pace = (performance.now() - p0) - (a.currentTime - c0);
+        a.cancel();
+        d.stack = await new Promise((r) => setTimeout(() => r(depth(new Error('x').stack)), 0));
+        d.rafStack = await new Promise((r) => requestAnimationFrame(() => r(depth(new Error('x').stack))));
+        // The other timers: a scheduler task's delay and a signal's timeout fire
+        // when a setTimeout of the same delay armed at the same instant does
+        // (a machine that sleeps delays all three alike; a clock that drives
+        // one and not the others pulls them apart).
+        const fired = await Promise.all([
+            new Promise((r) => setTimeout(() => r([Date.now(), performance.now()]), 300)),
+            scheduler.postTask(() => [Date.now(), performance.now()], { delay: 300 }),
+            new Promise((r) => AbortSignal.timeout(300).addEventListener('abort', () => r([Date.now(), performance.now()]), { once: true })),
+        ]);
+        d.post = Math.max(Math.abs(fired[1][0] - fired[0][0]), Math.abs(fired[1][1] - fired[0][1]));
+        d.abort = Math.max(Math.abs(fired[2][0] - fired[0][0]), Math.abs(fired[2][1] - fired[0][1]));
+        // Inside an animation frame its timestamp is the timeline's reading.
+        d.rafTs = await new Promise((r) => requestAnimationFrame((ts) => r(ts - document.timeline.currentTime)));
+        // The last instant this origin's storage saw is never ahead of the clock (a visit is remembered each time).
+        d.back = (() => { try { const seen = Number(localStorage.getItem('probe-seen') || 0), now = Date.now(); localStorage.setItem('probe-seen', String(Math.max(seen, now))); return Math.max(0, seen - now); } catch { return NaN; } })();
+        // Real work inside a timer callback and inside an animation frame's:
+        // performance.now() and Date.now() move across it in any browser. The
+        // smallest of three timer callbacks, so the reading is the clock's
+        // behaviour and not one lucky callback's.
+        const spins = [];
+        for (let i = 0; i < 3; i++) spins.push(await new Promise((r) => setTimeout(() => { const p = performance.now(), t = Date.now(); burn(SPIN); r([performance.now() - p, Date.now() - t]); }, 0)));
+        d.spinT = Math.min(...spins.map((s) => s[0]));
+        d.spinD = Math.min(...spins.map((s) => s[1]));
+        d.spinF = await new Promise((r) => requestAnimationFrame(() => { const p = performance.now(); burn(SPIN); r(performance.now() - p); }));
+        return d;
+    };
+    const boot = await read('boot');
+    boot.perfVsDate = Date.now() - (performance.timeOrigin + performance.now());
+    boot.intlFormat = Date.parse(dtf.format()) - Date.parse(dtf.format(new Date()));
+    boot.intlParts = parse(dtf.formatToParts()) - parse(dtf.formatToParts(new Date()));
+    boot.eventTs = new Event('x').timeStamp - performance.now();
+    boot.toJSON = performance.toJSON().timeOrigin - performance.timeOrigin;
+    boot.temporal = typeof Temporal === 'object' ? Temporal.Now.instant().epochMilliseconds - Date.now() : 0;
+    boot.temporalZoned = typeof Temporal === 'object' ? Temporal.Now.zonedDateTimeISO('UTC').epochMilliseconds - Date.now() : 0;
+    boot.temporalPlain = typeof Temporal === 'object' ? Date.parse(Temporal.Now.plainDateTimeISO('UTC').toString() + 'Z') - Date.now() : 0;
+    boot.frame = await new Promise((r) => requestAnimationFrame((ts) => r(Math.max(Math.abs(document.timeline.currentTime - performance.now()), Math.abs(ts - performance.now())))));
+    const d0 = Date.now(), p0 = performance.now();
+    await wait(300);
+    boot.pacingWait = Date.now() - d0;
+    boot.pacing = (Date.now() - d0) - (performance.now() - p0);
+    // A mark made now, read back after the clock has moved (the walk, the rounds), must keep its time; and a mark made then must read as the clock then reads (keptNow).
+    const kept = performance.mark('probe-kept');
+    const keptAt = kept.startTime, keptNow = performance.now();
+    // The workers: the same text as a same-origin script and as a blob, each
+    // asked what it reads; a worker's own worker too.
+    const text = await (await fetch('./probe-worker.js')).text();
+    const sw = new Worker('./probe-worker.js');
+    const bw = new Worker(URL.createObjectURL(new Blob([text], { type: 'text/javascript' })));
+    const ask = (w) => new Promise((r) => { const h = (e) => { w.removeEventListener('message', h); r(e.data); }; w.addEventListener('message', h); w.postMessage('probe'); });
+    fp.workers = {};
+    boot.workers = {};
+    for (const [kind, w] of [['scriptWorker', sw], ['blobWorker', bw]]) {
+        const a = await ask(w);
+        fp.workers[kind] = { loc: a.loc, date: a.date, timers: a.timers, perf: a.perf, file: a.file, globals: a.globals, other: a.other };
+        boot.workers[kind] = { now: a.now - Date.now(), perf: a.perfTime - a.now, nested: a.nestedNow - Date.now(), eventTs: a.eventTs, intl: a.intl, temporal: a.temporal, fileLM: a.fileLM, mark: a.mark, stack: a.stack, post: a.post, om: a.originMoved, dm: a.deltaMoved, spin: a.spin };
+    }
+    say('shape-workers', fp.workers);
+    say('boot', boot);
+    // The same oracles inside the walk's first leap (a timer due twenty minutes in) …
+    setTimeout(async () => { const d = await read('walk'); d.kept = performance.getEntriesByName('probe-kept')[0].startTime - keptAt; d.keptNow = (performance.mark('probe-kept-walk').startTime - keptAt) - (performance.now() - keptNow); say('walk', d); }, 20 * 60 * 1000);
+    // … and at every round, with the page's clock against the same-origin worker's: one short line each.
+    let n = 0, busy = false;
+    document.addEventListener('probe-round', async () => {
+        n++;
+        if (busy) return;
+        busy = true;
+        const round = n;
+        try {
+            const d = await read('round' + round);
+            const a = await ask(sw);
+            d.worker = a.now - Date.now();
+            d.kept = performance.getEntriesByName('probe-kept')[0].startTime - keptAt;
+            // The same-origin worker's timeOrigin and Date.now() - performance.now() against its first readings, its own postTask delay and its own spin.
+            d.om = a.originMoved; d.dm = a.deltaMoved; d.wp = a.post; d.ws = a.spin;
+            const short = { fl: 'fileLM', dl: 'docLM', mk: 'mark', rs: 'res', an: 'anim', pc: 'pace', st: 'stack', rf: 'rafStack', wk: 'worker', kp: 'kept' };
+            const more = { rt: 'rafTs', po: 'post', ab: 'abort', bk: 'back', om: 'om', dm: 'dm', wp: 'wp', sp: 'spinT', sd: 'spinD', sf: 'spinF', ws: 'ws' };
+            console.error(`clock-probe round ${String(round).padStart(5, '0')} ${Object.keys(short).map((k) => `${k}=${fixed(d[short[k]])}`).join(' ')}`);
+            console.error(`clock-probe roundb ${String(round).padStart(5, '0')} ${Object.keys(more).map((k) => `${k}=${fixed(d[more[k]])}`).join(' ')}`);
+        } finally { busy = false; }
+    });
+})();

package/engine-conformance/testdata/clock-probe/math/dice.tsv

@@ -0,0 +1,100 @@
+1	{"roll":0}
+1	{"roll":1}
+1	{"roll":2}
+1	{"roll":3}
+1	{"roll":4}
+1	{"roll":5}
+1	{"roll":6}
+1	{"roll":7}
+1	{"roll":8}
+1	{"roll":9}
+1	{"roll":10}
+1	{"roll":11}
+1	{"roll":12}
+1	{"roll":13}
+1	{"roll":14}
+1	{"roll":15}
+1	{"roll":16}
+1	{"roll":17}
+1	{"roll":18}
+1	{"roll":19}
+1	{"roll":20}
+1	{"roll":21}
+1	{"roll":22}
+1	{"roll":23}
+1	{"roll":24}
+1	{"roll":25}
+1	{"roll":26}
+1	{"roll":27}
+1	{"roll":28}
+1	{"roll":29}
+1	{"roll":30}
+1	{"roll":31}
+1	{"roll":32}
+1	{"roll":33}
+1	{"roll":34}
+1	{"roll":35}
+1	{"roll":36}
+1	{"roll":37}
+1	{"roll":38}
+1	{"roll":39}
+1	{"roll":40}
+1	{"roll":41}
+1	{"roll":42}
+1	{"roll":43}
+1	{"roll":44}
+1	{"roll":45}
+1	{"roll":46}
+1	{"roll":47}
+1	{"roll":48}
+1	{"roll":49}
+1	{"roll":50}
+1	{"roll":51}
+1	{"roll":52}
+1	{"roll":53}
+1	{"roll":54}
+1	{"roll":55}
+1	{"roll":56}
+1	{"roll":57}
+1	{"roll":58}
+1	{"roll":59}
+1	{"roll":60}
+1	{"roll":61}
+1	{"roll":62}
+1	{"roll":63}
+1	{"roll":64}
+1	{"roll":65}
+1	{"roll":66}
+1	{"roll":67}
+1	{"roll":68}
+1	{"roll":69}
+1	{"roll":70}
+1	{"roll":71}
+1	{"roll":72}
+1	{"roll":73}
+1	{"roll":74}
+1	{"roll":75}
+1	{"roll":76}
+1	{"roll":77}
+1	{"roll":78}
+1	{"roll":79}
+1	{"roll":80}
+1	{"roll":81}
+1	{"roll":82}
+1	{"roll":83}
+1	{"roll":84}
+1	{"roll":85}
+1	{"roll":86}
+1	{"roll":87}
+1	{"roll":88}
+1	{"roll":89}
+1	{"roll":90}
+1	{"roll":91}
+1	{"roll":92}
+1	{"roll":93}
+1	{"roll":94}
+1	{"roll":95}
+1	{"roll":96}
+1	{"roll":97}
+1	{"roll":98}
+1	{"roll":99}