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

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/CliRunEntryTest.res

@@ -0,0 +1,57 @@
+// Regression tests for the CLI runner's per-test deadline (A2) and the
+// Collector's skip-depth reset (A4). Before A2 a hung test body wedged the whole
+// run — `runEntry` awaited it with no deadline. Before A4 a throwing `xdescribe`
+// left `skipDepth` > 0, silently skipping every subsequently loaded file; the
+// reset lives in `Collector.activate`.
+
+open JestGlobals
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+
+let hangingEntry = (~timeout): Collector.entry => {
+  id: "hangs",
+  name: "hangs forever",
+  describePath: [],
+  slice: None,
+  // A body that never resolves — the pathological hung test.
+  body: () => Promise.make((_resolve, _reject) => ()),
+  status: Collector.Runnable,
+  location: None,
+  timeout,
+}
+
+describe("Cli.runEntry deadline", () => {
+  testPromise("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli.runEntry(hangingEntry(~timeout=Some(50)))
+    expect(r.status)->toEqual(RunnerTypes.Fail)
+    switch r.mismatch {
+    | Some(Outcome.Throw({error})) => expect(error->String.includes("timed out"))->toEqual(true)
+    | _ => JsError.throwWithMessage("expected a timeout Throw mismatch")
+    }
+  })
+
+  testPromise("a body that resolves within the deadline passes", async () => {
+    let entry: Collector.entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: [],
+      slice: None,
+      body: () => Promise.resolve(Outcome.pass),
+      status: Collector.Runnable,
+      location: None,
+      timeout: Some(1000),
+    }
+    let r = await Cli.runEntry(entry)
+    expect(r.status)->toEqual(RunnerTypes.Pass)
+  })
+})
+
+describe("Collector.activate", () => {
+  testSync("resets a leaked skipDepth to zero", () => {
+    // Simulate the leak a throwing xdescribe body would leave behind.
+    Collector.skipDepth := 3
+    Collector.activate()
+    expect(Collector.skipDepth.contents)->toEqual(0)
+    Collector.deactivate()
+  })
+})

package/tests/CliRunEntryTest.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Cli$ReventlessGwt from "../src/Cli.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "../src/Collector.res.mjs";
+
+function hangingEntry(timeout) {
+  return {
+    id: "hangs",
+    name: "hangs forever",
+    describePath: [],
+    slice: undefined,
+    body: () => new Promise((_resolve, _reject) => {}),
+    status: "Runnable",
+    location: undefined,
+    timeout: timeout
+  };
+}
+
+globalThis.describe("Cli.runEntry deadline", () => {
+  globalThis.test("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli$ReventlessGwt.runEntry(hangingEntry(50));
+    globalThis.expect(r.status).toEqual("Fail");
+    let match = r.mismatch;
+    if (match === undefined) {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    if (match.TAG !== "Throw") {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    globalThis.expect(match.error.includes("timed out")).toEqual(true);
+  });
+  globalThis.test("a body that resolves within the deadline passes", async () => {
+    let entry_describePath = [];
+    let entry_body = () => Promise.resolve(Outcome$ReventlessGwt.pass);
+    let entry_timeout = 1000;
+    let entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: entry_describePath,
+      slice: undefined,
+      body: entry_body,
+      status: "Runnable",
+      location: undefined,
+      timeout: entry_timeout
+    };
+    let r = await Cli$ReventlessGwt.runEntry(entry);
+    globalThis.expect(r.status).toEqual("Pass");
+  });
+});
+
+globalThis.describe("Collector.activate", () => {
+  globalThis.test("resets a leaked skipDepth to zero", () => {
+    Collector$ReventlessGwt.skipDepth.contents = 3;
+    Collector$ReventlessGwt.activate();
+    globalThis.expect(Collector$ReventlessGwt.skipDepth.contents).toEqual(0);
+    Collector$ReventlessGwt.deactivate();
+  });
+});
+
+export {
+  hangingEntry,
+}
+/*  Not a pure module */

package/tests/WatchDebounceTest.res

@@ -49,10 +49,11 @@ describe("Watch.debounce coalescing", () => {
     expect(calls.contents)->toEqual([Watch.Unlink])
   })
 
-  testPromise("interleaved .res.mjs unlinks don't steal the representative path", async () => {
+  testPromise("interleaved .res.mjs unlinks never surface; each distinct .res source does", async () => {
     // The real directory-mv burst chokidar emits: source AND generated files
-    // unlink interleaved. The coalesced path must be a `.res` source, not the
-    // last-seen `.res.mjs` (which would misclassify as a non-structural change).
+    // unlink interleaved. Only `.res` sources are emitted (never a `.res.mjs`),
+    // and every *distinct* source is emitted — two moved modules must both drive
+    // a rebuild, not collapse to one representative.
     let calls = ref([])
     let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
     fire(Watch.Unlink, "/p/src/old/A.res")
@@ -62,10 +63,37 @@ describe("Watch.debounce coalescing", () => {
     fire(Watch.Add, "/p/src/new/A.res")
     fire(Watch.Add, "/p/src/new/A.res.mjs")
     await delay(120)
-    expect(calls.contents->Array.length)->toEqual(1)
-    let (e, p) = calls.contents->Array.getUnsafe(0)
-    expect(e)->toEqual(Watch.Unlink)
-    expect(Watch.isStructuralSource(e, p))->toEqual(true)
+    let paths = calls.contents->Array.map(((_, p)) => p)
+    expect(calls.contents->Array.every(((e, p)) => Watch.isStructuralSource(e, p)))->toEqual(true)
+    expect(paths->Array.includes("/p/src/old/A.res"))->toEqual(true)
+    expect(paths->Array.includes("/p/src/old/A_Behavior.res"))->toEqual(true)
+    expect(paths->Array.some(p => p->String.endsWith(".mjs")))->toEqual(false)
+    expect(calls.contents->Array.length)->toEqual(2)
+  })
+
+  testPromise("a burst spanning two packages emits an unlink per package (A4.1)", async () => {
+    // Regression: the old single-`bestPath` debounce clean-rebuilt only one
+    // package on a multi-package burst, stranding the other with stale .res.mjs.
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
+    fire(Watch.Unlink, "/pkgA/src/Foo.res")
+    fire(Watch.Unlink, "/pkgB/src/Bar.res")
+    await delay(120)
+    let paths = calls.contents->Array.map(((_, p)) => p)
+    expect(paths->Array.includes("/pkgA/src/Foo.res"))->toEqual(true)
+    expect(paths->Array.includes("/pkgB/src/Bar.res"))->toEqual(true)
+    expect(calls.contents->Array.length)->toEqual(2)
+  })
+
+  testPromise("a structural signal suppresses a co-occurring plain change", async () => {
+    // A structural rebuild does its own re-run, so a plain edit in the same
+    // window must not also emit a separate Change (which would double-run).
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
+    fire(Watch.Change, "/p/src/Edited.res")
+    fire(Watch.Unlink, "/p/src/old/Moved.res")
+    await delay(120)
+    expect(calls.contents)->toEqual([Watch.Unlink])
   })
 
   testPromise("a lone change stays a change (incremental re-run)", async () => {

package/tests/WatchDebounceTest.res.mjs

@@ -55,7 +55,7 @@ globalThis.describe("Watch.debounce coalescing", () => {
     await delay(120);
     globalThis.expect(calls.contents).toEqual(["Unlink"]);
   });
-  globalThis.test("interleaved .res.mjs unlinks don't steal the representative path", async () => {
+  globalThis.test("interleaved .res.mjs unlinks never surface; each distinct .res source does", async () => {
     let calls = {
       contents: []
     };
@@ -72,11 +72,42 @@ globalThis.describe("Watch.debounce coalescing", () => {
     fire("Add", "/p/src/new/A.res");
     fire("Add", "/p/src/new/A.res.mjs");
     await delay(120);
-    globalThis.expect(calls.contents.length).toEqual(1);
-    let match = calls.contents[0];
-    let e = match[0];
-    globalThis.expect(e).toEqual("Unlink");
-    globalThis.expect(Watch$ReventlessGwt.isStructuralSource(e, match[1])).toEqual(true);
+    let paths = calls.contents.map(param => param[1]);
+    globalThis.expect(calls.contents.every(param => Watch$ReventlessGwt.isStructuralSource(param[0], param[1]))).toEqual(true);
+    globalThis.expect(paths.includes("/p/src/old/A.res")).toEqual(true);
+    globalThis.expect(paths.includes("/p/src/old/A_Behavior.res")).toEqual(true);
+    globalThis.expect(paths.some(p => p.endsWith(".mjs"))).toEqual(false);
+    globalThis.expect(calls.contents.length).toEqual(2);
+  });
+  globalThis.test("a burst spanning two packages emits an unlink per package (A4.1)", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, p) => {
+      calls.contents = calls.contents.concat([[
+          e,
+          p
+        ]]);
+    });
+    fire("Unlink", "/pkgA/src/Foo.res");
+    fire("Unlink", "/pkgB/src/Bar.res");
+    await delay(120);
+    let paths = calls.contents.map(param => param[1]);
+    globalThis.expect(paths.includes("/pkgA/src/Foo.res")).toEqual(true);
+    globalThis.expect(paths.includes("/pkgB/src/Bar.res")).toEqual(true);
+    globalThis.expect(calls.contents.length).toEqual(2);
+  });
+  globalThis.test("a structural signal suppresses a co-occurring plain change", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, _p) => {
+      calls.contents = calls.contents.concat([e]);
+    });
+    fire("Change", "/p/src/Edited.res");
+    fire("Unlink", "/p/src/old/Moved.res");
+    await delay(120);
+    globalThis.expect(calls.contents).toEqual(["Unlink"]);
   });
   globalThis.test("a lone change stays a change (incremental re-run)", async () => {
     let calls = {