@unotest/core 0.31.0 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,89 @@
 # Changelog
 
+## [0.33.0] - 2026-09-06
+
+### Patch Changes
+
+- 8846a06: Viewer: a run started the moment the viewer came up is shown, not lost
+  until the next change.
+
+  Watching a directory becomes live a moment after the watcher reports it
+  is ready, and a run directory created inside that gap was not merely
+  late — it was invisible until something else changed in the same day,
+  which in a quiet environment is the next run. Measured at 1-3% on macOS
+  with a busy machine, and the window is exactly "open the viewer, start a
+  run". The viewer now proves the watch delivers before it declares itself
+  up: it creates a directory of its own and waits to hear about it, so
+  boot completes on evidence rather than on a promise. A tree it cannot
+  write to, or a probe that never comes back, costs a warning in the log
+  and boots as before.
+
+  A directory whose name starts with a dot is never reported as a run — an
+  editor's leftovers, or the watcher's own probe, can no longer appear in
+  the run list as a phantom.
+
+  Run queue: a waiter whose process paused is no longer mistaken for dead
+  — the queue stamps its own files with its own clock.
+
+  A run waiting for a slot proves it is alive by touching its ticket, and
+  what it is judged against was the modification time the filesystem
+  wrote: on a network share that is the server's clock, and against a
+  machine busy enough to keep a process off the CPU, a ticket written a
+  moment ago could look like it belonged to a process that died. The queue
+  now stamps every file it creates with the same clock it judges them by.
+
+- Updated dependencies [2abfd4d]
+- Updated dependencies [b3e1220]
+- Updated dependencies [b3e1220]
+- Updated dependencies [5d1bde3]
+  - @unotest/protocol@0.33.0
+  - @unotest/dsl@0.33.0
+
+## [0.32.0] - 2026-09-05
+
+### Patch Changes
+
+- 047ca68: A failure somebody paused on stays a failure, with the evidence to show for it.
+
+  A run driven through the debugger — `run_test` then `resume`, or the viewer's
+  Continue — reported `completed` after a failure it had paused on, wrote no
+  failure bundle and no `failure/` artifacts, and left `list_failures` with
+  nothing to show. Continuing past a failure is how it gets inspected; it was
+  never meant to retract it. The verdict is now decided where the run's own
+  events are seen, so the journal, `runtime.json` and the reply agree, and a
+  debug run leaves the same evidence a plain `unotest-web e2e` run does.
+
+  `abort_runtime` (and Stop, and SIGTERM) now also ends the run in
+  `runtime.json`, not only in `steps.jsonl`: the control file used to keep
+  saying `paused-step` about a run that was over, so anything reading it rather
+  than the journal saw a pause that never ended.
+
+- 047ca68: A `step.soft(...)` failure no longer stops a debug run — or goes missing from it.
+
+  Under a debugger (`run_test`, or `e2e --debug`), every soft failure raised
+  the debug wheel: the run stopped on each one and an agent had to `resume`
+  its way through them. Worse, it was then lost — a paused failure is consumed
+  where it paused, so it never reached the `step.soft` envelope that records
+  it, the envelope closed as if the block had passed, and a run with three
+  soft failures could finish green with none of them listed.
+
+  Pausing is now for a failure that ENDS the run. A failure under any
+  enclosing soft step is recorded and stepped over exactly as it is on the
+  command line, and `runtime.json` — which the `run_test` reply is built from —
+  carries every soft failure of the run, not just the last stop.
+
+  A hard failure still pauses: that is what the debugger is for.
+
+  The same holds on mobile: a `step.soft(...)` failure no longer stops a run
+  under the debugger, and every soft failure of a run is now part of its
+  runtime state instead of being lost at the pause.
+
+- Updated dependencies [8aa0f30]
+- Updated dependencies [047ca68]
+- Updated dependencies [047ca68]
+  - @unotest/protocol@0.32.0
+  - @unotest/dsl@0.32.0
+
 ## [0.31.0] - 2026-09-04
 
 ### Minor Changes

package/dist/index.d.ts

@@ -172,6 +172,18 @@ interface RuntimeStateWriter {
     writeThrottled(): Promise<void>;
     /** Final flush — emit terminal state once more. Idempotent. */
     close(): Promise<void>;
+    /** Final flush from a path that cannot await: an abort or a signal
+     *  handler that ends with `process.exit`, where a promise never
+     *  settles and the file would keep whatever the run last wrote —
+     *  `paused-step` forever, on a run that is over.
+     *
+     *  `state` names the terminal state explicitly, because the writer
+     *  cannot infer it: on the signal path the runtime is still `running`
+     *  as far as it knows, and the truth is that we are killing it.
+     *
+     *  Shares `close()`'s idempotence — whichever runs first wins, and the
+     *  other is a no-op. On a signal the order is not ours to choose. */
+    closeSync(state?: RuntimeStateFile["state"]): void;
 }
 declare function createRuntimeStateWriter(deps: RuntimeStateWriterDeps): RuntimeStateWriter;
 

package/dist/index.js

@@ -252,6 +252,7 @@ var JOURNAL_TEXT_CAP_BYTES = VAR_TRUNCATE_BYTES;
 
 // src/runtime-state-writer.ts
 import { RUNTIME_FILE } from "@unotest/protocol";
+import { renameSync, writeFileSync } from "fs";
 import { rename as rename3, writeFile as writeFile4 } from "fs/promises";
 import { join as join5 } from "path";
 function createRuntimeStateWriter(deps) {
@@ -261,25 +262,34 @@ function createRuntimeStateWriter(deps) {
   const now = deps.nowFn ?? Date.now;
   let lastWriteAt = 0;
   let closed = false;
-  const writeNow = /* @__PURE__ */ __name(async () => {
-    if (closed) return;
+  const snapshot = /* @__PURE__ */ __name((state) => {
     const insp = deps.inspect();
-    if (!insp) return;
+    if (!insp) return null;
     const file = {
       runId: deps.runId,
       scenario: insp.scenario,
       testFn: insp.testFn,
-      state: insp.state,
+      state: state ?? insp.state,
       current: insp.current,
       vars: insp.vars,
       callStack: insp.callStack,
       lastFailure: insp.lastFailure,
+      // Every soft failure the run went past, not just the last one it
+      // stopped at: a soft step records and carries on, so `lastFailure`
+      // alone leaves a reader (the viewer, `inspect_runtime`, the agent's
+      // run reply) believing a run with three of them had none.
+      ...insp.softFailures && insp.softFailures.length > 0 ? { softFailures: [...insp.softFailures] } : {},
       ...deps.extra ? deps.extra() : {},
       updatedAt: now()
     };
+    return JSON.stringify(deps.redact ? deps.redact(file) : file);
+  }, "snapshot");
+  const writeNow = /* @__PURE__ */ __name(async () => {
+    if (closed) return;
+    const body = snapshot();
+    if (body === null) return;
     try {
-      const safe = deps.redact ? deps.redact(file) : file;
-      await writeFile4(tmpPath, JSON.stringify(safe), "utf8");
+      await writeFile4(tmpPath, body, "utf8");
       await rename3(tmpPath, path);
       lastWriteAt = now();
     } catch {
@@ -295,6 +305,23 @@ function createRuntimeStateWriter(deps) {
       if (closed) return;
       await writeNow();
       closed = true;
+    },
+    closeSync(state) {
+      if (closed) return;
+      closed = true;
+      let body;
+      try {
+        body = snapshot(state);
+      } catch {
+        return;
+      }
+      if (body === null) return;
+      try {
+        writeFileSync(tmpPath, body, "utf8");
+        renameSync(tmpPath, path);
+        lastWriteAt = now();
+      } catch {
+      }
     }
   };
 }
@@ -688,7 +715,7 @@ import {
   writeFile as writeFile6
 } from "fs/promises";
 import { dirname as dirname3, join as join8 } from "path";
-async function createExclusive(path, contents) {
+async function createExclusive(path, contents, now) {
   let handle;
   try {
     handle = await open2(path, "wx");
@@ -698,27 +725,33 @@ async function createExclusive(path, contents) {
   }
   try {
     await handle.writeFile(contents, "utf8");
+    await handle.utimes(...stampOf(now));
   } finally {
     await handle.close();
   }
   return true;
 }
 __name(createExclusive, "createExclusive");
-async function writeFileAtomic(path, contents, tmpToken) {
+async function writeFileAtomic(path, contents, tmpToken, now) {
   const tmp = join8(dirname3(path), `.tmp-${tmpToken}`);
   await writeFile6(tmp, contents, "utf8");
+  await utimes2(tmp, ...stampOf(now));
   await rename4(tmp, path);
 }
 __name(writeFileAtomic, "writeFileAtomic");
 async function touchFile(path, now) {
-  const seconds = now / 1e3;
   try {
-    await utimes2(path, seconds, seconds);
+    await utimes2(path, ...stampOf(now));
   } catch (e) {
     if (!isErrno(e, "ENOENT")) throw e;
   }
 }
 __name(touchFile, "touchFile");
+function stampOf(now) {
+  const seconds = now / 1e3;
+  return [seconds, seconds];
+}
+__name(stampOf, "stampOf");
 async function fileAgeMs(path, now) {
   try {
     const s = await stat(path);
@@ -847,7 +880,8 @@ var SlotPool = class {
     for (let n = 0; n < this.opts.total && taken.length < count; n++) {
       await keepAlive?.();
       const name = `${SLOT_PREFIX}${n}`;
-      if (await createExclusive(join9(this.opts.dir, name), body)) {
+      const path = join9(this.opts.dir, name);
+      if (await createExclusive(path, body, this.opts.now())) {
         taken.push(name);
       }
     }
@@ -888,7 +922,7 @@ var SlotPool = class {
     });
     const token = this.opts.token();
     for (let attempt = 0; attempt < mutex.attempts; attempt++) {
-      if (await createExclusive(mutex.path, token)) {
+      if (await createExclusive(mutex.path, token, this.opts.now())) {
         try {
           return await body(() => touchFile(mutex.path, this.opts.now()));
         } finally {
@@ -1022,7 +1056,8 @@ var FsRunQueue = class {
       await writeFileAtomic(
         join10(this.ticketsDir, name),
         JSON.stringify(ticket),
-        `${name}-${this.random()}`
+        `${name}-${this.random()}`,
+        createdAt
       );
     } catch (e) {
       throw new QueueUnavailableError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unotest/core",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "description": "Shared runner-side utilities for the @unotest ecosystem: JSONL run-artifact writer (steps.jsonl + heartbeat), atomic run-manifest + run-sources writers, atomic runtime-state writer with a protocol-normalizing runtime-inspection helper, layered .env reader/applier (target + environment axes), idempotent .gitignore updater. Used by @unotest/web and @unotest/mobile; depends on @unotest/protocol plus a type-only import of @unotest/dsl/executor event types (M-20). Unlike protocol (pure data), this package owns the thin filesystem layer both runners need.",
   "license": "MIT",
   "publishConfig": {
@@ -29,8 +29,8 @@
   ],
   "dependencies": {
     "chokidar": "^4.0.3",
-    "@unotest/protocol": "^0.31.0",
-    "@unotest/dsl": "^0.31.0"
+    "@unotest/dsl": "^0.33.0",
+    "@unotest/protocol": "^0.33.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",