omkit 0.0.7 → 0.0.8

package/dist/actions/tail-log.js

@@ -1,6 +1,7 @@
 import { watch as fsWatch } from "node:fs";
 import { open, stat } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
+import { StringDecoder } from "node:string_decoder";
 import { action } from "../core/action.js";
 /**
  * Tails a (possibly not-yet-existing) text/log file and streams each appended
@@ -23,15 +24,13 @@ export const tailLog = action("Tail Log").run(async ({ logs, signal }, target, o
     const { source = name, level = "info", fromStart = false, encoding = "utf8", debounceMs = 50, } = opts;
     let pos = 0; // bytes consumed so far
     let pending = ""; // partial trailing line, buffered until its newline
+    // Decodes bytes to text across reads. It holds back an incomplete trailing
+    // multi-byte char (split across a chunk or read boundary) until its remaining
+    // bytes arrive, so a character straddling a boundary never decodes to `�`.
+    let decoder = new StringDecoder(encoding);
     // Append every complete line in `text`, keeping any remainder for next time.
     const feed = (text) => {
-        // Strip NUL bytes first. Log rotators (log4js/streamroller) can pre-allocate
-        // or leave a rotated file padded with \0, and a NUL run contains no newline —
-        // so without this the whole padded region buffers and flushes as one huge
-        // bogus line (the tell-tale "line of blanks/spaces"). NUL is never valid in
-        // a text log, so dropping it is safe; a NUL-only stretch collapses to "" and
-        // is skipped by the empty-line guard below.
-        pending += text.replace(/\0/g, "");
+        pending += text;
         let newline;
         while ((newline = pending.indexOf("\n")) !== -1) {
             const line = pending.slice(0, newline).replace(/\r$/, "");
@@ -49,8 +48,11 @@ export const tailLog = action("Tail Log").run(async ({ logs, signal }, target, o
             return; // missing/unreadable — wait for the next event
         }
         if (size < pos) {
+            // Truncation/rotation: restart from the top and drop any buffered partial
+            // line and half-decoded char — they belong to the old file's bytes.
             pos = 0;
             pending = "";
+            decoder = new StringDecoder(encoding);
         }
         if (size <= pos)
             return;
@@ -64,15 +66,9 @@ export const tailLog = action("Tail Log").run(async ({ logs, signal }, target, o
                 if (bytesRead === 0)
                     break;
                 pos += bytesRead;
-                // Strip NUL bytes before decoding. Some log rotators on Windows
-                // temporarily expose sparse/preallocated regions filled with 0x00.
-                let out = 0;
-                for (let i = 0; i < bytesRead; i++) {
-                    if (buffer[i] !== 0)
-                        buffer[out++] = buffer[i];
-                }
-                if (out > 0)
-                    feed(buffer.subarray(0, out).toString(encoding));
+                // decoder.write returns only fully-decoded chars, buffering any partial
+                // trailing multi-byte char for the next chunk/read.
+                feed(decoder.write(buffer.subarray(0, bytesRead)));
             }
         }
         finally {

package/dist/core/output.js

@@ -113,10 +113,20 @@ export const streamLog = async (logs) => {
         }
     }
     finally {
-        jsonl.end();
-        pretty.end();
+        // End AND wait for both streams to fully close before resolving. {@link writeLog}
+        // truncates and rewrites these same files at finalize; if a buffered chunk from
+        // this stream landed *after* that truncation, the OS would zero-fill the gap —
+        // a multi-MB run of NUL bytes in run.log. `run` awaits this promise before
+        // calling `writeLog`, so this writer is guaranteed done before the rewrite.
+        await Promise.all([streamClosed(jsonl), streamClosed(pretty)]);
     }
 };
+/** Resolve once a write stream has flushed and closed its file descriptor. */
+const streamClosed = (stream) => new Promise((resolve) => {
+    stream.on("close", () => resolve());
+    stream.on("error", () => resolve()); // a stream error still frees the file; don't hang
+    stream.end();
+});
 let seq = 0;
 /** Serialize a value for a snapshot file, tolerating circular refs / non-JSON values. */
 const serialize = (value) => {

package/dist/core/run.js

@@ -126,8 +126,11 @@ export function run(...actions) {
     process.on("unhandledRejection", onUnhandled);
     narrate(`run started · ${scriptPath()}`);
     // Start streaming log entries to disk immediately — incremental writes survive
-    // hard kills where the final writeLog never runs.
-    void streamLog(logs).catch(() => { });
+    // hard kills where the final writeLog never runs. Kept so finalize can await it
+    // *before* writeLog rewrites the same files: otherwise a late flush from this
+    // stream lands past writeLog's truncation and the OS zero-fills the gap (a
+    // multi-MB NUL run in run.log).
+    const streaming = streamLog(logs).catch(() => { });
     const launch = (instance) => {
         narrate(`launch ${instance.name}`);
         // The action logs into the one shared store (entries carry their `source`;
@@ -184,6 +187,10 @@ export function run(...actions) {
         process.off("uncaughtException", onUncaught);
         process.off("unhandledRejection", onUnhandled);
         narrate("finished");
+        // Wait for the incremental streamer to fully close its files, so its last
+        // flush can't land after writeLog truncates+rewrites them (which would leave
+        // a NUL gap). The log is already closed, so this resolves promptly.
+        await streaming;
         const file = await writeLog(logs);
         // Direct to the terminal — the file's already written, so this line isn't in it.
         console.log(marker("run", `log → ${file}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "A tiny runtime for developer workflows: typed actions that pass runtime capabilities and emit typed events, under one run and one shared log. The operational/runtime layer to tskb's knowledge layer.",
   "type": "module",
   "main": "./dist/index.js",