@reventlessdev/reventless-gwt 1.0.0-alpha.75 → 1.0.0-alpha.77

package/src/ProcessManager.res

@@ -10,6 +10,13 @@ type managed = {
 
 let running: Dict.t<managed> = Dict.make()
 
+// Per-dir count of unexpected watcher exits, so a build-watcher that crashes on
+// startup (bad config, missing binary) is respawned a bounded number of times
+// rather than either freezing the build status forever or spinning in a tight
+// respawn loop.
+let restarts: Dict.t<int> = Dict.make()
+let maxRestarts = 3
+
 let isManaging = (dir: string): bool =>
   switch running->Dict.get(dir) {
   | Some(_) => true
@@ -19,12 +26,33 @@ let isManaging = (dir: string): bool =>
 // Spawn `pnpm run start` (the package's `rescript build -w`) in `pkg.dir`,
 // unless one is already managed there. `onStdout` receives each output line so
 // the caller can classify compiler markers (Phase 5).
-let spawnWatcher = (pkg: PackageScan.pkg, ~onStdout: (string, string) => unit): unit =>
+let rec spawnWatcher = (pkg: PackageScan.pkg, ~onStdout: (string, string) => unit): unit =>
   switch running->Dict.get(pkg.dir) {
   | Some(_) => ()
   | None => {
       let proc = ChildProcess.spawn("pnpm", ["run", "start"], ~cwd=pkg.dir)
       ChildProcess.onStdoutLine(proc, line => onStdout(pkg.dir, line))
+      // stderr carries compiler/pnpm crash output; without this a watcher that
+      // dies on stderr was invisible until the caller's 120s watchdog.
+      ChildProcess.onStderrLine(proc, line => onStdout(pkg.dir, line))
+      // A spawn failure ("error") never reaches "close"; surface it as output.
+      ChildProcess.onError(proc, msg => onStdout(pkg.dir, msg))
+      // Detect an unexpected exit. We compare the stored proc identity: an
+      // intentional `stop` deletes the entry synchronously before "close" fires,
+      // so if we still own this exact proc, the watcher crashed — respawn it up
+      // to `maxRestarts` times so build status doesn't freeze.
+      ChildProcess.onClose(proc, _code =>
+        switch running->Dict.get(pkg.dir) {
+        | Some(m) if m.proc === proc =>
+          running->Dict.delete(pkg.dir)
+          let n = restarts->Dict.get(pkg.dir)->Option.getOr(0)
+          if n < maxRestarts {
+            restarts->Dict.set(pkg.dir, n + 1)
+            spawnWatcher(pkg, ~onStdout)
+          }
+        | _ => ()
+        }
+      )
       running->Dict.set(pkg.dir, {dir: pkg.dir, proc})
     }
   }
@@ -58,20 +86,36 @@ let stop = (dir: string): bool =>
 let cleanRebuild = (
   pkg: PackageScan.pkg,
   ~onStdout: (string, string) => unit,
-  ~onDone: unit => unit,
+  ~onDone: bool => unit,
 ): unit => {
   let wasManaged = stop(pkg.dir)
-  let step = (cmd: string, args: array<string>, next: unit => unit): unit => {
+  // `next` receives the step's exit code so the chain can tell a failed clean or
+  // build (non-zero / crash) from success — the previous shape discarded exit
+  // codes and always reported the rebuild as OK, masking compile failures.
+  let step = (cmd: string, args: array<string>, next: option<int> => unit): unit => {
     let proc = ChildProcess.spawn(cmd, args, ~cwd=pkg.dir)
+    // "error" (spawn failure) and "close" can both fire; ensure the chain
+    // advances exactly once.
+    let settled = ref(false)
+    let settle = (code: option<int>) =>
+      if !settled.contents {
+        settled := true
+        next(code)
+      }
     ChildProcess.onStdoutLine(proc, line => onStdout(pkg.dir, line))
-    ChildProcess.onClose(proc, _ => next())
+    ChildProcess.onStderrLine(proc, line => onStdout(pkg.dir, line))
+    ChildProcess.onError(proc, msg => {
+      onStdout(pkg.dir, msg)
+      settle(None)
+    })
+    ChildProcess.onClose(proc, code => settle(code))
   }
-  step("pnpm", ["exec", "rescript", "clean"], () =>
-    step("pnpm", ["exec", "rescript", "build"], () => {
+  step("pnpm", ["exec", "rescript", "clean"], _cleanCode =>
+    step("pnpm", ["exec", "rescript", "build"], buildCode => {
       if wasManaged {
         spawnWatcher(pkg, ~onStdout)
       }
-      onDone()
+      onDone(buildCode == Some(0))
     })
   )
 }

package/src/ProcessManager.res.mjs

@@ -1,10 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as ChildProcess$ReventlessGwt from "./ChildProcess.res.mjs";
 
 let running = {};
 
+let restarts = {};
+
 function isManaging(dir) {
   return running[dir] !== undefined;
 }
@@ -19,6 +23,23 @@ function spawnWatcher(pkg, onStdout) {
     "start"
   ], pkg.dir, undefined);
   ChildProcess$ReventlessGwt.onStdoutLine(proc, line => onStdout(pkg.dir, line));
+  ChildProcess$ReventlessGwt.onStderrLine(proc, line => onStdout(pkg.dir, line));
+  ChildProcess$ReventlessGwt.onError(proc, msg => onStdout(pkg.dir, msg));
+  ChildProcess$ReventlessGwt.onClose(proc, _code => {
+    let m = running[pkg.dir];
+    if (m === undefined) {
+      return;
+    }
+    if (m.proc !== proc) {
+      return;
+    }
+    Stdlib_Dict.$$delete(running, pkg.dir);
+    let n = Stdlib_Option.getOr(restarts[pkg.dir], 0);
+    if (n < 3) {
+      restarts[pkg.dir] = n + 1 | 0;
+      return spawnWatcher(pkg, onStdout);
+    }
+  });
   running[pkg.dir] = {
     dir: pkg.dir,
     proc: proc
@@ -40,22 +61,36 @@ function cleanRebuild(pkg, onStdout, onDone) {
   let wasManaged = stop(pkg.dir);
   let step = (cmd, args, next) => {
     let proc = ChildProcess$ReventlessGwt.spawn(cmd, args, pkg.dir, undefined);
+    let settled = {
+      contents: false
+    };
+    let settle = code => {
+      if (!settled.contents) {
+        settled.contents = true;
+        return next(code);
+      }
+    };
     ChildProcess$ReventlessGwt.onStdoutLine(proc, line => onStdout(pkg.dir, line));
-    ChildProcess$ReventlessGwt.onClose(proc, param => next());
+    ChildProcess$ReventlessGwt.onStderrLine(proc, line => onStdout(pkg.dir, line));
+    ChildProcess$ReventlessGwt.onError(proc, msg => {
+      onStdout(pkg.dir, msg);
+      settle(undefined);
+    });
+    ChildProcess$ReventlessGwt.onClose(proc, settle);
   };
   step("pnpm", [
     "exec",
     "rescript",
     "clean"
-  ], () => step("pnpm", [
+  ], _cleanCode => step("pnpm", [
     "exec",
     "rescript",
     "build"
-  ], () => {
+  ], buildCode => {
     if (wasManaged) {
       spawnWatcher(pkg, onStdout);
     }
-    onDone();
+    onDone(Primitive_object.equal(buildCode, 0));
   }));
 }
 
@@ -68,8 +103,12 @@ function managedCount() {
   return Object.keys(running).length;
 }
 
+let maxRestarts = 3;
+
 export {
   running,
+  restarts,
+  maxRestarts,
   isManaging,
   spawnWatcher,
   stop,

package/src/RunWorker.res

@@ -0,0 +1,24 @@
+// Worker entry for a single gwt watch re-run pass.
+//
+// Spawned by `Cli.runWatch` with the run `options` passed as `workerData`. Runs
+// exactly one `runOnce` in this fresh worker (fresh ESM registry → recompiled
+// implementation modules are re-imported, not served stale), emits its NDJSON to
+// stdout (piped to the parent), then exits so the imported graph is reclaimed.
+// The parent never reuses a worker — one per re-run.
+
+@val @module("node:worker_threads") external workerData: Cli.options = "workerData"
+@val external processExit: int => unit = "process.exit"
+
+let () = {
+  let _ =
+    Cli.runOnce(workerData)
+    ->Promise.then(code => {
+      processExit(code)
+      Promise.resolve()
+    })
+    ->Promise.catch(e => {
+      Console.error2("gwt run worker failed:", e)
+      processExit(1)
+      Promise.resolve()
+    })
+}

package/src/RunWorker.res.mjs

@@ -0,0 +1,16 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Cli$ReventlessGwt from "./Cli.res.mjs";
+import * as Nodeworker_threads from "node:worker_threads";
+
+Stdlib_Promise.$$catch(Cli$ReventlessGwt.runOnce(Nodeworker_threads.workerData).then(code => {
+  process.exit(code);
+  return Promise.resolve();
+}), e => {
+  console.error("gwt run worker failed:", e);
+  process.exit(1);
+  return Promise.resolve();
+});
+
+/*  Not a pure module */

package/src/Watch.res

@@ -22,21 +22,6 @@ type event = Add | Change | Unlink
 @val external setTimeout: (unit => unit, int) => float = "setTimeout"
 @val external clearTimeout: float => unit = "clearTimeout"
 
-// Rank events so a coalesced burst reports the *strongest structural* signal
-// with a representative path. A single directory `mv` emits an interleaved
-// burst — `unlink` of the `.res` AND the generated `.res.mjs`, then `add`s at
-// the new path — inside one debounce window. The representative path must be a
-// `.res` *source* unlink (the relocation signal), never a `.res.mjs` or a
-// trailing add, or the consumer misclassifies it as an ordinary change. So an
-// unlink of a `.res` source outranks everything; any other unlink/add outranks
-// a plain edit.
-let rank = (event: event, path: string): int =>
-  switch event {
-  | Unlink => String.endsWith(path, ".res") ? 2 : 1
-  | Add => 1
-  | Change => 0
-  }
-
 // True when an event is the *structural* signal Phase 12 acts on: a source
 // `.res` file leaving a directory (the move/delete half of a relocation).
 // Generated `.res.mjs` outputs end in `.mjs`, so they never match — which is
@@ -45,17 +30,30 @@ let rank = (event: event, path: string): int =>
 let isStructuralSource = (event: event, path: string): bool =>
   event == Unlink && String.endsWith(path, ".res")
 
+// Coalesce a burst of chokidar events into a single debounce window, then emit.
+// A window may span *multiple* packages — a branch switch or a multi-package
+// refactor emits `.res` unlinks under several package roots at once. The old
+// shape kept only one "best" path, so it clean-rebuilt just one package and
+// left the others with stale `.res.mjs`. Instead accumulate the *set* of
+// distinct structural source paths and emit one `Unlink` callback per path
+// (the consumer maps each to its owning package). If the window held no
+// structural signal, emit a single representative event so the consumer does a
+// plain re-run.
 let debounce = (wait: int, fn: (event, string) => unit) => {
   let pending: ref<option<float>> = ref(None)
-  let bestRank = ref(-1)
-  let bestEvent = ref(Change)
-  let bestPath = ref("")
+  let structural: ref<array<string>> = ref([])
+  let sawOther = ref(false)
+  let otherEvent = ref(Change)
+  let otherPath = ref("")
   (event, path) => {
-    let r = rank(event, path)
-    if r >= bestRank.contents {
-      bestRank := r
-      bestEvent := event
-      bestPath := path
+    if isStructuralSource(event, path) {
+      if !(structural.contents->Array.includes(path)) {
+        structural := Array.concat(structural.contents, [path])
+      }
+    } else {
+      sawOther := true
+      otherEvent := event
+      otherPath := path
     }
     switch pending.contents {
     | Some(t) => clearTimeout(t)
@@ -65,12 +63,21 @@ let debounce = (wait: int, fn: (event, string) => unit) => {
       Some(
         setTimeout(() => {
           pending := None
-          let e = bestEvent.contents
-          let p = bestPath.contents
-          bestRank := -1
-          bestEvent := Change
-          bestPath := ""
-          fn(e, p)
+          let paths = structural.contents
+          let other = sawOther.contents
+          let oe = otherEvent.contents
+          let op = otherPath.contents
+          structural := []
+          sawOther := false
+          otherEvent := Change
+          otherPath := ""
+          if paths->Array.length > 0 {
+            // One rebuild per distinct owning package; a plain edit alongside
+            // is covered by each structural rebuild's own re-run.
+            paths->Array.forEach(p => fn(Unlink, p))
+          } else if other {
+            fn(oe, op)
+          }
         }, wait),
       )
   }
@@ -81,7 +88,16 @@ let start = (roots: array<string>, onChange: (event, string) => unit): watcher =
     roots,
     {
       ignoreInitial: true,
-      ignored: ["**/node_modules/**", "**/lib/**", "**/.git/**"],
+      // Keep in sync with Discovery's pruned dirs — writes under `dist/` or
+      // `.history/` are build/editor output, not source, and a `dist/` write
+      // could otherwise drive a re-run loop.
+      ignored: [
+        "**/node_modules/**",
+        "**/lib/**",
+        "**/.git/**",
+        "**/dist/**",
+        "**/.history/**",
+      ],
     },
   )
   let debounced = debounce(120, onChange)

package/src/Watch.res.mjs

@@ -2,21 +2,6 @@
 
 import * as Chokidar from "chokidar";
 
-function rank(event, path) {
-  switch (event) {
-    case "Add" :
-      return 1;
-    case "Change" :
-      return 0;
-    case "Unlink" :
-      if (path.endsWith(".res")) {
-        return 2;
-      } else {
-        return 1;
-      }
-  }
-}
-
 function isStructuralSource(event, path) {
   if (event === "Unlink") {
     return path.endsWith(".res");
@@ -29,21 +14,27 @@ function debounce(wait, fn) {
   let pending = {
     contents: undefined
   };
-  let bestRank = {
-    contents: -1
+  let structural = {
+    contents: []
   };
-  let bestEvent = {
+  let sawOther = {
+    contents: false
+  };
+  let otherEvent = {
     contents: "Change"
   };
-  let bestPath = {
+  let otherPath = {
     contents: ""
   };
   return (event, path) => {
-    let r = rank(event, path);
-    if (r >= bestRank.contents) {
-      bestRank.contents = r;
-      bestEvent.contents = event;
-      bestPath.contents = path;
+    if (isStructuralSource(event, path)) {
+      if (!structural.contents.includes(path)) {
+        structural.contents = structural.contents.concat([path]);
+      }
+    } else {
+      sawOther.contents = true;
+      otherEvent.contents = event;
+      otherPath.contents = path;
     }
     let t = pending.contents;
     if (t !== undefined) {
@@ -51,12 +42,22 @@ function debounce(wait, fn) {
     }
     pending.contents = setTimeout(() => {
       pending.contents = undefined;
-      let e = bestEvent.contents;
-      let p = bestPath.contents;
-      bestRank.contents = -1;
-      bestEvent.contents = "Change";
-      bestPath.contents = "";
-      fn(e, p);
+      let paths = structural.contents;
+      let other = sawOther.contents;
+      let oe = otherEvent.contents;
+      let op = otherPath.contents;
+      structural.contents = [];
+      sawOther.contents = false;
+      otherEvent.contents = "Change";
+      otherPath.contents = "";
+      if (paths.length !== 0) {
+        paths.forEach(p => fn("Unlink", p));
+        return;
+      } else if (other) {
+        return fn(oe, op);
+      } else {
+        return;
+      }
     }, wait);
   };
 }
@@ -67,7 +68,9 @@ function start(roots, onChange) {
     ignored: [
       "**/node_modules/**",
       "**/lib/**",
-      "**/.git/**"
+      "**/.git/**",
+      "**/dist/**",
+      "**/.history/**"
     ]
   });
   let debounced = debounce(120, onChange);
@@ -75,7 +78,6 @@ function start(roots, onChange) {
 }
 
 export {
-  rank,
   isStructuralSource,
   debounce,
   start,

package/src/WatcherProbe.res

@@ -19,14 +19,22 @@
 @module("node:path") external join: (string, string) => string = "join"
 @val external _processKillSig: (int, int) => unit = "process.kill"
 
-// `process.kill(pid, 0)` performs no signal delivery — it only probes existence
-// (throws ESRCH when the pid is gone), which is exactly the liveness check.
+// `process.kill(pid, 0)` performs no signal delivery — it only probes existence.
+// It throws `ESRCH` when the pid is gone (dead) and `EPERM` when the pid exists
+// but is owned by another user (alive, just not ours). A bare catch-all treated
+// EPERM as dead, which would spawn a duplicate watcher over a live foreign one;
+// treat EPERM as alive.
+let _errCode: JsExn.t => option<string> = %raw(`(e) => (e && typeof e.code === "string") ? e.code : undefined`)
 let isAlive = (pid: int): bool =>
   try {
     _processKillSig(pid, 0)
     true
   } catch {
-  | _ => false
+  | exn =>
+    switch JsExn.fromException(exn) {
+    | Some(e) => _errCode(e) == Some("EPERM")
+    | None => false
+    }
   }
 
 let libLock = (dir: string, name: string): string => join(join(dir, "lib"), name)

package/src/WatcherProbe.res.mjs

@@ -3,13 +3,25 @@
 import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let _errCode = ((e) => (e && typeof e.code === "string") ? e.code : undefined);
 
 function isAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (exn) {
-    return false;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let e = Stdlib_JsExn.fromException(exn);
+    if (e !== undefined) {
+      return Primitive_object.equal(_errCode(Primitive_option.valFromOption(e)), "EPERM");
+    } else {
+      return false;
+    }
   }
 }
 
@@ -38,6 +50,7 @@ function hasLiveWatcher(dir) {
 }
 
 export {
+  _errCode,
   isAlive,
   libLock,
   lockHasLivePid,

package/src/Worker.res

@@ -0,0 +1,24 @@
+// Minimal `node:worker_threads` binding for gwt watch re-runs.
+//
+// Node's ESM module registry is keyed by URL and never evicts, so re-importing a
+// recompiled test file in the same process replays tests that close over the
+// *old* instances of their statically-imported implementation modules (the
+// Loader can only cache-bust the test file's own URL, not its transitive
+// imports). Running each watch re-run in a short-lived Worker gives it a fresh
+// registry — the recompiled modules are re-imported — and reclaims the whole
+// imported graph on worker exit (fixing the monotonic-buster memory leak).
+
+type t
+type workerOptions<'a> = {workerData: 'a}
+type url
+
+@new @module("node:worker_threads")
+external make: (url, workerOptions<'a>) => t = "Worker"
+
+// A worker's stdout is piped to the parent's process.stdout by default, so the
+// NDJSON the formatters write inside the worker reaches the client unchanged.
+@send external on: (t, string, 'cb) => unit = "on"
+@send external terminate: t => promise<int> = "terminate"
+
+// The compiled worker entry lives next to this module in the in-source build.
+let runWorkerUrl: url = %raw(`new URL("./RunWorker.res.mjs", import.meta.url)`)

package/src/Worker.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let runWorkerUrl = (new URL("./RunWorker.res.mjs", import.meta.url));
+
+export {
+  runWorkerUrl,
+}
+/* runWorkerUrl Not a pure module */

package/tests/BuildClassifierTest.res

@@ -80,6 +80,45 @@ describe("BuildClassifier", () => {
     expect(fails.contents->Array.length)->toEqual(0)
   })
 
+  testPromise("errors emitted before the first Parsed line still settle to onFail (B3)", async () => {
+    // A crashed toolchain / pnpm resolution failure prints an error block with no
+    // preceding "Parsed …" line. The old `compiling && hasError` guard left this
+    // pinned forever; now `hasError` alone settles it.
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Syntax error: unexpected token")
+    feed("  at Foo.res:3:1")
+    await delay(550)
+    expect(oks.contents)->toEqual(0)
+    expect(fails.contents->Array.length)->toEqual(1)
+    expect((fails.contents->Array.getUnsafe(0))->String.includes("Syntax error"))->toEqual(true)
+  })
+
+  testPromise("a multi-error build keeps error blocks past the old 20-line cap (B3)", async () => {
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => (),
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    feed("We've found a bug for you!")
+    // 30 filler lines push a distinctive later error past the old 20-line window.
+    for i in 1 to 30 {
+      feed("noise line " ++ Int.toString(i))
+    }
+    feed("Found 2 errors")
+    await delay(550)
+    expect(fails.contents->Array.length)->toEqual(1)
+    // The late "Found 2 errors" line survives (dropped under the old cap of 20).
+    expect((fails.contents->Array.getUnsafe(0))->String.includes("Found 2 errors"))->toEqual(true)
+  })
+
   testPromise("strips ANSI colour codes before matching the finish line", async () => {
     let oks = ref(0)
     let feed = BuildClassifier.make({

package/tests/BuildClassifierTest.res.mjs

@@ -109,6 +109,50 @@ globalThis.describe("BuildClassifier", () => {
     globalThis.expect(oks.contents).toEqual(1);
     globalThis.expect(fails.contents.length).toEqual(0);
   });
+  globalThis.test("errors emitted before the first Parsed line still settle to onFail (B3)", async () => {
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Syntax error: unexpected token");
+    feed("  at Foo.res:3:1");
+    await delay(550);
+    globalThis.expect(oks.contents).toEqual(0);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    globalThis.expect(fails.contents[0].includes("Syntax error")).toEqual(true);
+  });
+  globalThis.test("a multi-error build keeps error blocks past the old 20-line cap (B3)", async () => {
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {},
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    feed("We've found a bug for you!");
+    for (let i = 1; i <= 30; ++i) {
+      feed("noise line " + i.toString());
+    }
+    feed("Found 2 errors");
+    await delay(550);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    globalThis.expect(fails.contents[0].includes("Found 2 errors")).toEqual(true);
+  });
   globalThis.test("strips ANSI colour codes before matching the finish line", async () => {
     let oks = {
       contents: 0