@specific.dev/spectest 0.32.0 → 0.32.1

package/dist/browser.js

@@ -32,7 +32,7 @@ import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { generateId } from "./ids.js";
-import { recordBrowser, reserveEvent, truncateUtf8 } from "./recorder.js";
+import { recordBrowser, reserveBackdated, reserveEvent, truncateUtf8 } from "./recorder.js";
 import { wrap } from "./inspect.js";
 import { describeUrlPattern, matchesUrl } from "./url-match.js";
 import { attachBrowserProbe, DEFAULT_ACTION_TIMEOUT_MS, desktopStrategy, makeLocator, mobileStrategy, } from "./locator.js";
@@ -1407,7 +1407,9 @@ function buildBackend(holder, recorder, buildOpts) {
             // No page work — the matcher already read the value via silentRead. We
             // only mint the timeline anchor: the seq the assertion nests under, plus
             // `sessionTimestamp` (post-settle wall clock) so the dashboard seeks the
-            // replay to the frame the assertion observed.
+            // replay to the frame the assertion observed. The offset is backdated to
+            // where the matcher started polling, since that's what `tOffsetMs` means
+            // everywhere else (the ops that reserve up front stamp their start).
             const endT = Date.now();
             const seq = recordBrowser({
                 action,
@@ -1417,7 +1419,7 @@ function buildBackend(holder, recorder, buildOpts) {
                     : {}),
                 durationMs: waitedMs,
                 ...(error ? { error } : {}),
-            });
+            }, reserveBackdated(waitedMs));
             // Drain the rrweb the page buffered while the matcher waited into this
             // step's chunk, so `settledTarget` has bounds to seek into.
             await drain(action);

package/dist/recorder.d.ts

@@ -5,8 +5,11 @@ interface BaseEvent {
      *  before it does still sorts ahead of them. Ops that don't reserve get
      *  their seq at record (= finish) time. */
     seq: number;
-    /** Milliseconds since the recorder started, captured when the op began
-     *  (reserved) or, absent a reservation, when it was recorded. */
+    /** Milliseconds since the recorder started, captured when the op *began* —
+     *  either reserved up front, or backdated at record time by an op that could
+     *  only reserve at finish (`reserveBackdated`). Consumers read the step's
+     *  completion time as `tOffsetMs + durationMs`, so an op that stamps a bare
+     *  finish offset while also reporting a duration will render late. */
     tOffsetMs: number;
     /**
      * Optional grouping pointer. When set, this event was emitted inside
@@ -475,6 +478,14 @@ export declare function isRecording(): boolean;
  *  when nothing is recording, in which case `record*` falls back to allocating
  *  the seq at record time. */
 export declare function reserveEvent(): EventReservation | undefined;
+/** Reserve at op *finish* but backdate the offset by `elapsedMs` — for ops that
+ *  can't reserve up front because they only know they were an op once they're
+ *  done (the locator matchers: they poll silently and emit one settled step at
+ *  the end). Keeps `tOffsetMs` meaning "when the op started" for every kind,
+ *  which is what lets the dashboard render `tOffsetMs + durationMs` as the
+ *  step's completion time. Ordering is unaffected — the caller records
+ *  immediately, so the seq is the one it would have got anyway. */
+export declare function reserveBackdated(elapsedMs: number): EventReservation | undefined;
 export declare function recordExec(ev: Omit<ExecEvent, "seq" | "tOffsetMs" | "kind">, reservation?: EventReservation): number | undefined;
 export declare function recordAssertion(ev: Omit<AssertionEvent, "seq" | "tOffsetMs" | "kind">): number | undefined;
 export declare function recordHttp(ev: Omit<HttpEvent, "seq" | "tOffsetMs" | "kind">, reservation?: EventReservation): number | undefined;

package/dist/recorder.js

@@ -132,6 +132,19 @@ export function isRecording() {
 export function reserveEvent() {
     return active() ? current.reserve() : undefined;
 }
+/** Reserve at op *finish* but backdate the offset by `elapsedMs` — for ops that
+ *  can't reserve up front because they only know they were an op once they're
+ *  done (the locator matchers: they poll silently and emit one settled step at
+ *  the end). Keeps `tOffsetMs` meaning "when the op started" for every kind,
+ *  which is what lets the dashboard render `tOffsetMs + durationMs` as the
+ *  step's completion time. Ordering is unaffected — the caller records
+ *  immediately, so the seq is the one it would have got anyway. */
+export function reserveBackdated(elapsedMs) {
+    const resv = reserveEvent();
+    if (!resv)
+        return undefined;
+    return { seq: resv.seq, tOffsetMs: Math.max(0, resv.tOffsetMs - Math.max(0, elapsedMs)) };
+}
 export function recordExec(ev, reservation) {
     return active() ? current.push({ kind: "exec", ...ev }, reservation) : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",