@unotest/core 0.31.0 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [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 {
+      }
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unotest/core",
-  "version": "0.31.0",
+  "version": "0.32.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/protocol": "^0.32.0",
+    "@unotest/dsl": "^0.32.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",