@reventlessdev/reventless-gwt 1.0.0-alpha.74 → 1.0.0-alpha.76

package/src/Filter.res.mjs

@@ -14,7 +14,7 @@ function only() {
 function xtest(param, name, _body) {
   if (Collector$ReventlessGwt.isActive()) {
     Collector$ReventlessGwt.markSkipNext();
-    return Collector$ReventlessGwt.push(undefined, undefined, name, () => Promise.resolve(Outcome$ReventlessGwt.pass));
+    return Collector$ReventlessGwt.push(undefined, undefined, undefined, name, () => Promise.resolve(Outcome$ReventlessGwt.pass));
   } else {
     globalThis.xtest(name, () => {});
     return;
@@ -24,10 +24,17 @@ function xtest(param, name, _body) {
 function xdescribe(label, body) {
   if (Collector$ReventlessGwt.isActive()) {
     Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents + 1 | 0;
-    Collector$ReventlessGwt.pushDescribe(label, body);
-    Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+    try {
+      Collector$ReventlessGwt.pushDescribe(label, body);
+      Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+      return;
+    } catch (e) {
+      Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+      throw e;
+    }
   } else {
     globalThis.xdescribe(label, body);
+    return;
   }
 }
 

package/src/FormatterVsCode.res

@@ -262,7 +262,7 @@ let graph = (g: DomainGraph.graph) =>
         label: n.label,
         plugin: n.plugin,
       }),
-      edges: g.edges->Array.map((e): P.graphEdge => {from: e.from, to_: e.to, kind: e.kind}),
+      edges: g.edges->Array.map((e): P.graphEdge => {from: e.from, to_: e.to, kind: e.kind, label: ?e.label}),
     }),
   )
 

package/src/FormatterVsCode.res.mjs

@@ -291,7 +291,8 @@ function graph(g) {
   let e_1 = g.edges.map(e => ({
     from: e.from,
     to: e.to,
-    kind: e.kind
+    kind: e.kind,
+    label: e.label
   }));
   let e = {
     event: "graph",

package/src/JestBind.res

@@ -60,7 +60,7 @@ let testPromise = (
 ) =>
   if Collector.isActive() {
     let location = Collector.captureLocation(1)
-    Collector.push(~slice?, ~location?, name, body)
+    Collector.push(~slice?, ~location?, ~timeout?, name, body)
   } else {
     switch timeout {
     | Some(t) =>

package/src/JestBind.res.mjs

@@ -35,7 +35,7 @@ function todo(label) {
 function test(slice, name, body) {
   if (Collector$ReventlessGwt.isActive()) {
     let location = Collector$ReventlessGwt.captureLocation(1);
-    return Collector$ReventlessGwt.push(slice, location, name, () => Promise.resolve(body()));
+    return Collector$ReventlessGwt.push(slice, location, undefined, name, () => Promise.resolve(body()));
   }
   globalThis.test(name, () => assertOutcome(slice, body()));
 }
@@ -50,7 +50,7 @@ function testPromise(slice, name, timeout, body) {
     return;
   }
   let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, name, body);
+  Collector$ReventlessGwt.push(slice, location, timeout, name, body);
 }
 
 export {

package/src/PlatformRunner.res

@@ -60,6 +60,9 @@ let openEphemeral = (): promise<(netServer, int)> =>
     s->_listen(0, "127.0.0.1", () => resolve((s, (s->_address)["port"])))
   })
 
+let closeServer = (s: netServer): promise<unit> =>
+  Promise.make((resolve, _reject) => s->_close(() => resolve()))
+
 // Hold all n open while collecting ports so they're guaranteed distinct, then
 // release them just before the child binds.
 let allocFreePorts = async (n: int): array<int> => {
@@ -70,7 +73,10 @@ let allocFreePorts = async (n: int): array<int> => {
     servers->Array.push(s)
     ports->Array.push(p)
   }
-  servers->Array.forEach(s => s->_close(() => ()))
+  // Await every close so the ports are actually released before the child binds
+  // them. Closing fire-and-forget returned the ports while the sockets were
+  // still bound, racing the child's bind into EADDRINUSE.
+  let _ = await Promise.all(servers->Array.map(closeServer))
   ports
 }
 
@@ -150,11 +156,26 @@ let run = async (
       }
     ChildProcess.onStdoutLine(proc, handle)
     ChildProcess.onStderrLine(proc, handle)
-    ChildProcess.onClose(proc, code => callbacks.onStop(code))
 
-    // Keep the process alive until cancelled — like runWatch, returning here would
-    // let the bin wrapper process.exit and tear down the child immediately.
-    await Promise.make((resolve, _reject) => Cancellation.onCancel(() => resolve()))
-    0
+    // Keep the parent alive until either the operator cancels or the child exits.
+    // The previous shape awaited cancellation *forever* and always returned 0, so
+    // a crashed platform child left a zombie parent that reported success. Resolve
+    // on child close (or a spawn error) too, and surface the child's exit code.
+    let exitCode = ref(0)
+    await Promise.make((resolve, _reject) => {
+      Cancellation.onCancel(() => resolve())
+      ChildProcess.onError(proc, msg => {
+        callbacks.onLog("platform spawn error: " ++ msg)
+        callbacks.onStop(None)
+        exitCode := 1
+        resolve()
+      })
+      ChildProcess.onClose(proc, code => {
+        callbacks.onStop(code)
+        exitCode := code->Option.getOr(0)
+        resolve()
+      })
+    })
+    exitCode.contents
   }
 }

package/src/PlatformRunner.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Nodenet from "node:net";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Cancellation$ReventlessGwt from "./Cancellation.res.mjs";
 import * as ChildProcess$ReventlessGwt from "./ChildProcess.res.mjs";
 import * as PlatformScan$ReventlessGwt from "./PlatformScan.res.mjs";
@@ -44,6 +45,12 @@ function openEphemeral() {
   });
 }
 
+function closeServer(s) {
+  return new Promise((resolve, _reject) => {
+    s.close(() => resolve());
+  });
+}
+
 async function allocFreePorts(n) {
   let servers = [];
   let ports = [];
@@ -52,9 +59,7 @@ async function allocFreePorts(n) {
     servers.push(match[0]);
     ports.push(match[1]);
   }
-  servers.forEach(s => {
-    s.close(() => {});
-  });
+  await Promise.all(servers.map(closeServer));
   return ports;
 }
 
@@ -136,9 +141,24 @@ async function run(roots, backend, fixedPortsOpt, callbacks) {
     };
     ChildProcess$ReventlessGwt.onStdoutLine(proc, handle);
     ChildProcess$ReventlessGwt.onStderrLine(proc, handle);
-    ChildProcess$ReventlessGwt.onClose(proc, code => callbacks.onStop(code));
-    await new Promise((resolve, _reject) => Cancellation$ReventlessGwt.onCancel(() => resolve()));
-    return 0;
+    let exitCode = {
+      contents: 0
+    };
+    await new Promise((resolve, _reject) => {
+      Cancellation$ReventlessGwt.onCancel(() => resolve());
+      ChildProcess$ReventlessGwt.onError(proc, msg => {
+        callbacks.onLog("platform spawn error: " + msg);
+        callbacks.onStop(undefined);
+        exitCode.contents = 1;
+        resolve();
+      });
+      ChildProcess$ReventlessGwt.onClose(proc, code => {
+        callbacks.onStop(code);
+        exitCode.contents = Stdlib_Option.getOr(code, 0);
+        resolve();
+      });
+    });
+    return exitCode.contents;
   }
   callbacks.onLog("no reventless-local platform package (src/Main.res.mjs + @reventlessdev/reventless-local) found under: " + roots.join(", "));
   return 1;
@@ -148,6 +168,7 @@ export {
   tapSentinel,
   classifyLine,
   openEphemeral,
+  closeServer,
   allocFreePorts,
   fixedPlatformPorts,
   run,

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)