@unotest/core 0.30.0 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,78 @@
 # 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
+
+- 100ab9d: `buildRuntimeInspection` keeps `stepTag` and `soft` on `lastFailure` and
+  passes the runtime's `softFailures` list through into `runtime.json`, so
+  `inspect_runtime` and `run_test` can report the case a data-driven step
+  was on and every soft step that failed.
+
+### Patch Changes
+
+- b8e105b: `capUtf8(text, maxBytes)` — cut a string to a UTF-8 byte budget without
+  splitting a code point — exported next to `JOURNAL_TEXT_CAP_BYTES`
+  (4 KB). The runtime-state var snapshot now caps by bytes through it (it
+  used to count UTF-16 units); the run journal's `note` / `log` payloads
+  use the same cap.
+- Updated dependencies [b8e105b]
+- Updated dependencies [9ae6d59]
+- Updated dependencies [56784b3]
+- Updated dependencies [e048334]
+- Updated dependencies [100ab9d]
+- Updated dependencies [100ab9d]
+- Updated dependencies [ad7c918]
+- Updated dependencies [ad7c918]
+- Updated dependencies [dcf4c9e]
+  - @unotest/protocol@0.31.0
+  - @unotest/dsl@0.31.0
+
 ## [0.30.0] - 2026-09-03
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { RunArtifact, RunManifest, RunSources, RuntimeStateFile, RuntimeState, DbgCommand, PickerMode, DbgCommandRecord, DbgCommandProbe, IRunQueue, EnqueueRunInput, RunQueueTicketHandle, QueueSnapshot, QueueTicket, RunQueueLease, BundleGitInfo, BundleManifest, ScheduleEntry } from '@unotest/protocol';
+import { RunArtifact, RunManifest, RunSources, RuntimeStateFile, SoftFailureRecord, RuntimeState, DbgCommand, PickerMode, DbgCommandRecord, DbgCommandProbe, IRunQueue, EnqueueRunInput, RunQueueTicketHandle, QueueSnapshot, QueueTicket, RunQueueLease, BundleGitInfo, BundleManifest, ScheduleEntry } from '@unotest/protocol';
 export { isRecord } from '@unotest/protocol';
 import { ExecutionEvent } from '@unotest/dsl/executor';
 
@@ -91,7 +91,7 @@ type RuntimeExecState = "starting" | "running" | "paused-step" | "paused-failure
 /** Normalized, protocol-shaped runtime view assembled from a manager snapshot.
  *  Feeds straight into `RuntimeStateFile` (the writer adds runId / wsEndpoint /
  *  wheel / updatedAt) — hence a Pick, not a re-spelled mirror. */
-type RuntimeInspection = Pick<RuntimeStateFile, "scenario" | "testFn" | "state" | "current" | "vars" | "callStack" | "lastFailure">;
+type RuntimeInspection = Pick<RuntimeStateFile, "scenario" | "testFn" | "state" | "current" | "vars" | "callStack" | "lastFailure" | "softFailures">;
 /** Raw inputs from a `TestRuntimeManager.inspect()` snapshot, before
  *  protocol-normalization. `lastFailure` is the manager's richer record; only
  *  line/col/message survive into the protocol form. */
@@ -108,7 +108,13 @@ interface RuntimeInspectionInput {
             message: string;
             name?: string;
         };
+        /** Evaluated `{tag}` of the enclosing `step(...)`, when any. */
+        stepTag?: string;
+        /** The failure sat inside a `step.soft(...)` — the run went on. */
+        soft?: boolean;
     } | null;
+    /** Failed `step.soft(...)` blocks so far, in run order. */
+    softFailures?: readonly SoftFailureRecord[];
 }
 declare function buildRuntimeInspection(input: RuntimeInspectionInput, stringifyVar: (v: unknown) => string): RuntimeInspection;
 declare function toProtocolRuntimeState(state: RuntimeExecState, lastEvent: ExecutionEvent | null): RuntimeState;
@@ -121,6 +127,17 @@ declare function extractCallStack(ev: ExecutionEvent | null): {
     file: string;
     line: number;
 }[];
+/** Cut `s` to at most `maxBytes` of UTF-8 without splitting a code point.
+ *  Shared by the runtime-state var snapshot and the run journal's `note` /
+ *  `log` events, so "what fits in a line" means one thing everywhere. */
+declare function capUtf8(s: string, maxBytes: number): {
+    text: string;
+    truncated: boolean;
+};
+/** The journal's cap for one `note` / `log` payload — the same 4 KB the
+ *  var snapshot uses: a small object or a response body fits, an HTML
+ *  document does not. */
+declare const JOURNAL_TEXT_CAP_BYTES = 4096;
 
 /** Runner-specific extras merged into every snapshot. Evaluated on each write
  *  so live values (the current wheel owner) stay fresh. */
@@ -155,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;
 
@@ -498,4 +527,4 @@ declare class BundleIdMismatchError extends UnotestError {
     constructor(claimed: string, computed: string);
 }
 
-export { type ArtifactRedactor, type BundleFile, BundleFormatError, BundleIdMismatchError, BundlePathError, type BundleProvenance, BundleTooLargeError, type DebugCommandsWatcherDeps, type DebugControlTarget, type DebugWatcherLogger, type E2EFlags, FsRunQueue, type FsRunQueueOptions, type GitignoreUpdate, type GlobalPoolOptions, type IRunArtifactWriter, JsonlRunArtifactWriter, type JsonlRunArtifactWriterOptions, type PackedBundle, QueueTicketLostError, QueueUnavailableError, QueueWaitAbortedError, type RunHeartbeat, type RuntimeExecState, type RuntimeInspection, type RuntimeInspectionInput, type RuntimeStateExtra, type RuntimeStateWriter, type RuntimeStateWriterDeps, type TarEntry, UnotestError, type UnpackOptions, type UnpackedBundle, type WriteManifestInput, type WriteRunSourcesInput, appendUniqueLines, applyEnvLayers, assertSafeBundlePath, buildRuntimeInspection, computeBundleId, computeSchedulesFingerprint, computeTreeSha256, createRunArtifactWriter, createRuntimeStateWriter, currentLocation, extractCallStack, globalPoolFromEnv, leaseEnv, levenshteinDistance, packBundle, parseE2EFlags, readDebuggerBreakpoints, readEnvFile, readEnvLayers, readTar, startDebugCommandsWatcher, startRunHeartbeat, suggestClosest, toProtocolRuntimeState, unpackBundle, writeRunManifest, writeRunSources, writeTar };
+export { type ArtifactRedactor, type BundleFile, BundleFormatError, BundleIdMismatchError, BundlePathError, type BundleProvenance, BundleTooLargeError, type DebugCommandsWatcherDeps, type DebugControlTarget, type DebugWatcherLogger, type E2EFlags, FsRunQueue, type FsRunQueueOptions, type GitignoreUpdate, type GlobalPoolOptions, type IRunArtifactWriter, JOURNAL_TEXT_CAP_BYTES, JsonlRunArtifactWriter, type JsonlRunArtifactWriterOptions, type PackedBundle, QueueTicketLostError, QueueUnavailableError, QueueWaitAbortedError, type RunHeartbeat, type RuntimeExecState, type RuntimeInspection, type RuntimeInspectionInput, type RuntimeStateExtra, type RuntimeStateWriter, type RuntimeStateWriterDeps, type TarEntry, UnotestError, type UnpackOptions, type UnpackedBundle, type WriteManifestInput, type WriteRunSourcesInput, appendUniqueLines, applyEnvLayers, assertSafeBundlePath, buildRuntimeInspection, capUtf8, computeBundleId, computeSchedulesFingerprint, computeTreeSha256, createRunArtifactWriter, createRuntimeStateWriter, currentLocation, extractCallStack, globalPoolFromEnv, leaseEnv, levenshteinDistance, packBundle, parseE2EFlags, readDebuggerBreakpoints, readEnvFile, readEnvLayers, readTar, startDebugCommandsWatcher, startRunHeartbeat, suggestClosest, toProtocolRuntimeState, unpackBundle, writeRunManifest, writeRunSources, writeTar };

package/dist/index.js

@@ -171,8 +171,11 @@ function buildRuntimeInspection(input, stringifyVar) {
     lastFailure: input.lastFailure ? {
       line: input.lastFailure.line,
       col: input.lastFailure.col,
-      error: { message: input.lastFailure.error.message }
-    } : null
+      error: { message: input.lastFailure.error.message },
+      ...input.lastFailure.stepTag !== void 0 ? { stepTag: input.lastFailure.stepTag } : {},
+      ...input.lastFailure.soft ? { soft: true } : {}
+    } : null,
+    ...input.softFailures && input.softFailures.length > 0 ? { softFailures: input.softFailures.map((f) => ({ ...f })) } : {}
   };
 }
 __name(buildRuntimeInspection, "buildRuntimeInspection");
@@ -227,13 +230,29 @@ function serializeVars(vars, stringifyVar) {
 }
 __name(serializeVars, "serializeVars");
 function truncate(s) {
-  if (s.length <= VAR_TRUNCATE_BYTES) return s;
-  return s.slice(0, VAR_TRUNCATE_BYTES) + "\u2026";
+  const capped = capUtf8(s, VAR_TRUNCATE_BYTES);
+  return capped.truncated ? `${capped.text}\u2026` : capped.text;
 }
 __name(truncate, "truncate");
+function capUtf8(s, maxBytes) {
+  const encoder = new TextEncoder();
+  if (encoder.encode(s).byteLength <= maxBytes) return { text: s, truncated: false };
+  let bytes = 0;
+  let end = 0;
+  for (const ch of s) {
+    const size = encoder.encode(ch).byteLength;
+    if (bytes + size > maxBytes) break;
+    bytes += size;
+    end += ch.length;
+  }
+  return { text: s.slice(0, end), truncated: true };
+}
+__name(capUtf8, "capUtf8");
+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) {
@@ -243,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 {
@@ -277,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 {
+      }
     }
   };
 }
@@ -1578,6 +1623,7 @@ export {
   BundlePathError,
   BundleTooLargeError,
   FsRunQueue,
+  JOURNAL_TEXT_CAP_BYTES,
   JsonlRunArtifactWriter,
   QueueTicketLostError,
   QueueUnavailableError,
@@ -1587,6 +1633,7 @@ export {
   applyEnvLayers,
   assertSafeBundlePath,
   buildRuntimeInspection,
+  capUtf8,
   computeBundleId,
   computeSchedulesFingerprint,
   computeTreeSha256,

package/package.json

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