@specific.dev/spectest 0.54.0 → 0.54.1

package/dist/daemon.js

@@ -3928,6 +3928,7 @@ async function runOne(testCase) {
             rows: term.rows,
             outputPreview: preview.value,
             outputTruncated: preview.truncated,
+            interactive: true,
         });
         return term;
     };

package/dist/recorder.d.ts

@@ -481,6 +481,14 @@ export interface TerminalEvent extends BaseEvent {
     outputTruncated: boolean;
     /** Set if spawning the PTY itself failed. */
     error?: string;
+    /**
+     * Set on the open marker of an interactive session (`ctx.terminal.open`).
+     * A one-shot `ctx.terminal(...)` event covers a whole command run, so the
+     * UI seeks its replay to the end; the open marker is the state at open,
+     * so the UI seeks to 0 instead. Older recordings lack this flag — the UI
+     * falls back to the marker's sentinel shape (exitCode -1, durationMs 0).
+     */
+    interactive?: boolean;
 }
 /** Action taken on an open interactive terminal session. */
 export type TerminalStepAction = "send" | "sendLine" | "press" | "waitFor" | "exit" | "close";

package/dist/terminal.js

@@ -128,8 +128,23 @@ export async function openTerminal(args) {
     // sendLine / press so the recorded `castTimeSec` lands on the echo's
     // frame instead of microseconds before it.
     const frameWaiters = [];
+    // Time of the most recently ingested frame. Two jobs: (1) frame
+    // timestamps are forced strictly increasing (Date.now() has ms
+    // resolution, so a fast PTY can land two frames — or two *ops* —
+    // in the same millisecond), and (2) it is what `recordOpEvent`
+    // stamps as the step's `castTimeSec`. Together they make the
+    // player's `seek(castTimeSec)` (which applies frames `<= target`)
+    // land on exactly the frames this op had seen: the step's own last
+    // frame is included, and the next op's first frame can never share
+    // the stamp. Before this, a `waitFor` that matched in the same
+    // millisecond as the following `sendLine`'s echo showed that echo
+    // — the replay ran one step ahead of the step list.
+    let lastFrameT = 0;
     const ingest = (chunk) => {
-        const t = (Date.now() - start) / 1000;
+        let t = (Date.now() - start) / 1000;
+        if (t <= lastFrameT)
+            t = lastFrameT + 0.001;
+        lastFrameT = t;
         sink.pushFrame(t, chunk);
         emu.write(chunk);
         if (output.length < OUTPUT_CAP_BYTES) {
@@ -223,8 +238,8 @@ export async function openTerminal(args) {
         }
         // Record cast time AFTER drain, so the `exit` step we record below
         // points the player at the very last frame (the program's final
-        // output before EOF).
-        exitCastTimeSec = (Date.now() - start) / 1000;
+        // output before EOF). Same between-frames stamp as `recordOpEvent`.
+        exitCastTimeSec = lastFrameT + 0.0005;
         sink.markClosed();
         resolveExit(code);
     })();
@@ -265,10 +280,17 @@ export async function openTerminal(args) {
         if (!args.recordEvents)
             return undefined;
         const preview = truncateUtf8(renderScreen());
-        // Use the SAME clock the asciicast frames use (offset from `start`,
-        // which is captured at Bun.spawn). That way the UI seeks the player
-        // directly to this value with no frame arithmetic.
-        const castTimeSec = (Date.now() - start) / 1000;
+        // Stamp the step half a millisecond past its last ingested frame:
+        // frame times are strictly increasing in 1ms steps (see `ingest`),
+        // so the stamp sits strictly BETWEEN the op's own last frame and
+        // any later op's first frame. That makes the boundary unambiguous
+        // in both directions — an inclusive seek (`<= stamp`) shows the
+        // op's own frame and can never pull in the next op's, and the
+        // viewer's exclusive `waitFor` seek (stamp − 0.0004, which
+        // disambiguates legacy wall-clock stamps that tied with the next
+        // op's echo) still lands past the op's own frame. Same clock as
+        // the frames (offset from `start`), so the UI seeks directly.
+        const castTimeSec = lastFrameT + 0.0005;
         // Return the event seq so callers can `wrap()` their result value
         // against it — e.g. `expect(await term.waitFor(...))` then links its
         // assertion to this step (sourceSeq) and the UI nests it here.

package/package.json

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

package/src/daemon.ts

@@ -4815,6 +4815,7 @@ async function runOne(testCase: TestCase<unknown>): Promise<RunResult> {
       rows: term.rows,
       outputPreview: preview.value,
       outputTruncated: preview.truncated,
+      interactive: true,
     });
     return term;
   };

package/src/recorder.ts

@@ -537,6 +537,14 @@ export interface TerminalEvent extends BaseEvent {
   outputTruncated: boolean;
   /** Set if spawning the PTY itself failed. */
   error?: string;
+  /**
+   * Set on the open marker of an interactive session (`ctx.terminal.open`).
+   * A one-shot `ctx.terminal(...)` event covers a whole command run, so the
+   * UI seeks its replay to the end; the open marker is the state at open,
+   * so the UI seeks to 0 instead. Older recordings lack this flag — the UI
+   * falls back to the marker's sentinel shape (exitCode -1, durationMs 0).
+   */
+  interactive?: boolean;
 }
 
 /** Action taken on an open interactive terminal session. */

package/src/terminal.ts

@@ -305,8 +305,22 @@ export async function openTerminal(args: OpenTerminalArgs): Promise<InternalTerm
   // sendLine / press so the recorded `castTimeSec` lands on the echo's
   // frame instead of microseconds before it.
   const frameWaiters: Array<() => void> = [];
+  // Time of the most recently ingested frame. Two jobs: (1) frame
+  // timestamps are forced strictly increasing (Date.now() has ms
+  // resolution, so a fast PTY can land two frames — or two *ops* —
+  // in the same millisecond), and (2) it is what `recordOpEvent`
+  // stamps as the step's `castTimeSec`. Together they make the
+  // player's `seek(castTimeSec)` (which applies frames `<= target`)
+  // land on exactly the frames this op had seen: the step's own last
+  // frame is included, and the next op's first frame can never share
+  // the stamp. Before this, a `waitFor` that matched in the same
+  // millisecond as the following `sendLine`'s echo showed that echo
+  // — the replay ran one step ahead of the step list.
+  let lastFrameT = 0;
   const ingest = (chunk: string): void => {
-    const t = (Date.now() - start) / 1000;
+    let t = (Date.now() - start) / 1000;
+    if (t <= lastFrameT) t = lastFrameT + 0.001;
+    lastFrameT = t;
     sink.pushFrame(t, chunk);
     emu.write(chunk);
     if (output.length < OUTPUT_CAP_BYTES) {
@@ -397,8 +411,8 @@ export async function openTerminal(args: OpenTerminalArgs): Promise<InternalTerm
     }
     // Record cast time AFTER drain, so the `exit` step we record below
     // points the player at the very last frame (the program's final
-    // output before EOF).
-    exitCastTimeSec = (Date.now() - start) / 1000;
+    // output before EOF). Same between-frames stamp as `recordOpEvent`.
+    exitCastTimeSec = lastFrameT + 0.0005;
     sink.markClosed();
     resolveExit(code);
   })();
@@ -444,10 +458,17 @@ export async function openTerminal(args: OpenTerminalArgs): Promise<InternalTerm
   ): number | undefined => {
     if (!args.recordEvents) return undefined;
     const preview = truncateUtf8(renderScreen());
-    // Use the SAME clock the asciicast frames use (offset from `start`,
-    // which is captured at Bun.spawn). That way the UI seeks the player
-    // directly to this value with no frame arithmetic.
-    const castTimeSec = (Date.now() - start) / 1000;
+    // Stamp the step half a millisecond past its last ingested frame:
+    // frame times are strictly increasing in 1ms steps (see `ingest`),
+    // so the stamp sits strictly BETWEEN the op's own last frame and
+    // any later op's first frame. That makes the boundary unambiguous
+    // in both directions — an inclusive seek (`<= stamp`) shows the
+    // op's own frame and can never pull in the next op's, and the
+    // viewer's exclusive `waitFor` seek (stamp − 0.0004, which
+    // disambiguates legacy wall-clock stamps that tied with the next
+    // op's echo) still lands past the op's own frame. Same clock as
+    // the frames (offset from `start`), so the UI seeks directly.
+    const castTimeSec = lastFrameT + 0.0005;
     // Return the event seq so callers can `wrap()` their result value
     // against it — e.g. `expect(await term.waitFor(...))` then links its
     // assertion to this step (sourceSeq) and the UI nests it here.