@atolis-hq/wake 0.3.83 → 0.3.85

package/dist/src/persistence/filesystem/file-event-journal.js

@@ -15,6 +15,15 @@ export class FileEventJournal {
         return this.changeSignalSource;
     }
     cached;
+    // Every read (readStream/readAll/readLatest/latestGlobalPosition) reaches
+    // scan(), and the resident host's tick loop calls those many times a
+    // second while work is progressing. Without coalescing, calls that land
+    // concurrently each independently decide the cache is stale and each
+    // re-read and re-parse the entire on-disk journal — under I/O pressure
+    // (e.g. a concurrently running build/test process competing for disk),
+    // enough of these can overlap at once to exhaust the heap. Sharing one
+    // in-flight decode among concurrent callers makes that impossible.
+    inFlightScan;
     async append(stream, expectedSequence, drafts) {
         return withFileLock(join(this.root, 'locks', 'event-journal.lock'), async () => {
             const current = await this.scan();
@@ -97,7 +106,17 @@ export class FileEventJournal {
             : [...priorEntries, updatedEntry];
         this.cached = { entries, events: [...priorEvents, ...newEnvelopes] };
     }
-    async scan() {
+    scan() {
+        if (this.inFlightScan !== undefined)
+            return this.inFlightScan;
+        const run = this.scanUncoalesced().finally(() => {
+            if (this.inFlightScan === run)
+                this.inFlightScan = undefined;
+        });
+        this.inFlightScan = run;
+        return run;
+    }
+    async scanUncoalesced() {
         const directory = join(this.root, 'events');
         let files;
         try {

package/dist/src/surfaces/cli/commands/sandbox-entrypoint.js

@@ -1,3 +1,17 @@
+/**
+ * Never resolves, and never lets the process exit either. The supervised
+ * child is spawned detached and unref'd (see spawnDetached), so an
+ * unresolved Promise alone is not enough here — a Promise executor registers
+ * no libuv handle, and once other pending I/O quiets down Node treats the
+ * still-pending top-level await as unsettled and exits anyway. A ref'd
+ * timer is a real handle, so it keeps the process alive for as long as this
+ * Promise is meant to.
+ */
+export function waitForever() {
+    return new Promise(() => {
+        setInterval(() => { }, 1 << 30);
+    });
+}
 /**
  * Restarts `wake start` on every exit — a first-boot crash (e.g. missing
  * sandbox auth) must not stop the retry loop, since the operator's only path