@unotest/core 0.32.0 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # 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

package/dist/index.js

@@ -715,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");
@@ -725,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);
@@ -874,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);
       }
     }
@@ -915,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 {
@@ -1049,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.32.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.32.0",
-    "@unotest/dsl": "^0.32.0"
+    "@unotest/dsl": "^0.33.0",
+    "@unotest/protocol": "^0.33.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",