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

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.76 (2026-07-02)
+
+### Bug Fixes
+
+* **gwt:** harden watch runner process/lifecycle/fidelity (plan A2–A4) ([9d5d566](https://github.com/ReventlessDev/reventless-core/commit/9d5d566f2de572b6de19c18e5a1d3dd53982f1e8))
+* **gwt:** run each watch re-run in a fresh worker (plan A1/B2) ([af71131](https://github.com/ReventlessDev/reventless-core/commit/af711312b8d6f7482ee22faaa3265e72ca3ed68b))
+
+
+# 1.0.0-alpha.75 (2026-06-29)
+
+### Features
+
+* external-system boxes for translation slices (Event Graph data) ([3f8ad39](https://github.com/ReventlessDev/reventless-core/commit/3f8ad39b78a3cb1182d59a0e1fb203b7dcb7379b))
+
+
 # 1.0.0-alpha.74 (2026-06-27)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.74",
+  "version": "1.0.0-alpha.76",
   "description": "Given-When-Then DSLs and CLI runner for Reventless slice testing",
   "license": "Apache-2.0",
   "bin": {
@@ -20,17 +20,17 @@
     "chokidar": "^3.6.0",
     "picocolors": "^1.1.1",
     "sury": "11.0.0-alpha.4",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.23",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.134",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.81",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.61",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.3",
-    "@reventlessdev/reventless-vscode-protocol": "1.0.0-alpha.8"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.83",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.136",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.63",
+    "@reventlessdev/reventless-vscode-protocol": "1.0.0-alpha.9"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.47"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.48"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/Bind.res.mjs

@@ -6,12 +6,12 @@ let describe = Collector$ReventlessGwt.pushDescribe;
 
 function test(slice, name, body) {
   let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, name, () => Promise.resolve(body()));
+  Collector$ReventlessGwt.push(slice, location, undefined, name, () => Promise.resolve(body()));
 }
 
 function testPromise(slice, name, body) {
   let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, name, body);
+  Collector$ReventlessGwt.push(slice, location, undefined, name, body);
 }
 
 export {

package/src/Cancellation.res

@@ -24,6 +24,12 @@ let install = () => {
         | _ => ()
         }
       )
+    } else {
+      // Second signal: the first requested a graceful drain, but a hung await
+      // can keep the process alive indefinitely. Honour the operator's repeat
+      // SIGINT/SIGTERM as a hard exit (130 = terminated by SIGINT) so only the
+      // one signal — not SIGKILL — is needed to break out.
+      process->exit(130)
     }
   }
   process->onSignal("SIGINT", handler)

package/src/Cancellation.res.mjs

@@ -19,7 +19,9 @@ function onCancel(handler) {
 
 function install() {
   let handler = () => {
-    if (!cancelled.contents) {
+    if (cancelled.contents) {
+      process.exit(130);
+    } else {
       cancelled.contents = true;
       handlers.contents.forEach(h => {
         try {
@@ -28,7 +30,6 @@ function install() {
           return;
         }
       });
-      return;
     }
   };
   process.on("SIGINT", handler);

package/src/ChildProcess.res

@@ -35,7 +35,9 @@ let mergeEnv = (overrides: option<Dict.t<string>>): Dict.t<string> => {
 @get external _stderr: t => stream = "stderr"
 @send external _streamSetEncoding: (stream, string) => unit = "setEncoding"
 @send external _streamOn: (stream, string, string => unit) => unit = "on"
+@send external _streamOnEnd: (stream, string, unit => unit) => unit = "on"
 @send external _procOnClose: (t, string, Nullable.t<int> => unit) => unit = "on"
+@send external _procOnError: (t, string, JsExn.t => unit) => unit = "on"
 @send external _kill: (t, string) => bool = "kill"
 @val external _processKill: (int, string) => unit = "process.kill"
 
@@ -45,7 +47,10 @@ let spawn = (cmd: string, args: array<string>, ~cwd: string, ~env: option<Dict.t
 let pid = (proc: t): option<int> => proc->_pid->Nullable.toOption
 
 // Subscribe to a stream line-by-line (stdout or stderr), buffering partial
-// chunks. Used to classify ReScript compiler markers in Phase 5.
+// chunks. Used to classify ReScript compiler markers in Phase 5. On stream
+// `end` the final unterminated line is flushed — crash/panic messages
+// typically lack a trailing newline, so without this the last (often most
+// diagnostic) line was silently dropped.
 let onLines = (s: stream, cb: string => unit): unit => {
   _streamSetEncoding(s, "utf8")
   let buf = ref("")
@@ -63,6 +68,13 @@ let onLines = (s: stream, cb: string => unit): unit => {
       }
     drain()
   })
+  _streamOnEnd(s, "end", () =>
+    if buf.contents != "" {
+      let last = buf.contents
+      buf := ""
+      cb(last)
+    }
+  )
 }
 
 let onStdoutLine = (proc: t, cb: string => unit): unit => onLines(proc->_stdout, cb)
@@ -70,6 +82,12 @@ let onStderrLine = (proc: t, cb: string => unit): unit => onLines(proc->_stderr,
 let onClose = (proc: t, cb: option<int> => unit): unit =>
   _procOnClose(proc, "close", code => cb(code->Nullable.toOption))
 
+// A spawn failure (ENOENT for a missing binary, EACCES, …) emits `"error"` on
+// the child, not `"close"`. Without a listener Node re-throws it as an uncaught
+// exception and crashes the whole CLI. Route the message to the caller instead.
+let onError = (proc: t, cb: string => unit): unit =>
+  _procOnError(proc, "error", e => cb(e->JsExn.message->Option.getOr("spawn failed")))
+
 // Kill the child's whole process group (negative pid) so the rescript watcher
 // pnpm spawned dies too. Falls back to a direct kill if the pid is gone.
 let killTree = (proc: t, signal: string): unit =>

package/src/ChildProcess.res.mjs

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Nodechild_process from "node:child_process";
 
@@ -49,6 +51,14 @@ function onLines(s, cb) {
     };
     drain();
   });
+  s.on("end", () => {
+    if (buf.contents === "") {
+      return;
+    }
+    let last = buf.contents;
+    buf.contents = "";
+    cb(last);
+  });
 }
 
 function onStdoutLine(proc, cb) {
@@ -63,6 +73,10 @@ function onClose(proc, cb) {
   proc.on("close", code => cb((code == null) ? undefined : Primitive_option.some(code)));
 }
 
+function onError(proc, cb) {
+  proc.on("error", e => cb(Stdlib_Option.getOr(Stdlib_JsExn.message(e), "spawn failed")));
+}
+
 function killTree(proc, signal) {
   let p = Primitive_option.fromNullable(proc.pid);
   if (p !== undefined) {
@@ -87,6 +101,7 @@ export {
   onStdoutLine,
   onStderrLine,
   onClose,
+  onError,
   killTree,
 }
-/* node:child_process Not a pure module */
+/* Stdlib_JsExn Not a pure module */

package/src/Cli.res

@@ -222,6 +222,42 @@ let exnMessage: exn => string = %raw(`function(e) {
   return "unknown error"
 }`)
 
+// Default per-test deadline (ms) when a test body doesn't set `~timeout`.
+// Mirrors Jest's default so behaviour is consistent across both runners.
+let defaultTimeoutMs = 5000
+
+// Resolve to a timeout `Outcome` after `ms`. Raced against the test body so a
+// hung await reports a failure instead of wedging the entire run.
+type timeoutHandle
+@val external setTimeout: (unit => unit, int) => timeoutHandle = "setTimeout"
+@val external clearTimeout: timeoutHandle => unit = "clearTimeout"
+let raceWithTimeout = (body: unit => promise<Outcome.outcome>, ms: int): promise<
+  Outcome.outcome,
+> => {
+  let handleRef: ref<option<timeoutHandle>> = ref(None)
+  let timeout = Promise.make((resolve, _reject) => {
+    handleRef :=
+      Some(
+        setTimeout(
+          () =>
+            resolve(
+              Outcome.fail(
+                Throw({error: `timed out after ${Int.toString(ms)}ms`, stack: ""}),
+              ),
+            ),
+          ms,
+        ),
+      )
+  })
+  Promise.race([body(), timeout])->Promise.then(o => {
+    switch handleRef.contents {
+    | Some(h) => clearTimeout(h)
+    | None => ()
+    }
+    Promise.resolve(o)
+  })
+}
+
 // Execute a single entry, catching exceptions and thrown values so a
 // misbehaved slice doesn't abort the rest of the suite.
 let runEntry = async (entry: Collector.entry): RunnerTypes.testResult => {
@@ -232,7 +268,8 @@ let runEntry = async (entry: Collector.entry): RunnerTypes.testResult => {
   | Collector.Skipped => status := Skip
   | _ =>
     try {
-      let outcome = await entry.body()
+      let deadline = entry.timeout->Option.getOr(defaultTimeoutMs)
+      let outcome = await raceWithTimeout(entry.body, deadline)
       switch outcome {
       | Ok() => status := Pass
       | Error(m) => {
@@ -531,6 +568,37 @@ let runWatch = async (opts: options): int => {
     await emitDiscovery(paths)
     startBuildWatchers(paths)
   }
+  // Each re-run pass executes in a short-lived Worker so it gets a fresh ESM
+  // module registry (recompiled implementation modules are re-imported instead
+  // of served stale from Node's never-evicting cache) and reclaims the imported
+  // graph on exit. The worker's stdout is piped to ours, so its NDJSON reaches
+  // the client unchanged. One worker per pass; the parent keeps ownership of the
+  // build watchers and chokidar.
+  let currentWorker: ref<option<Worker.t>> = ref(None)
+  Cancellation.onCancel(() =>
+    switch currentWorker.contents {
+    | Some(w) =>
+      let _ = Worker.terminate(w)
+    | None => ()
+    }
+  )
+  let runInWorker = (): promise<unit> =>
+    Promise.make((resolve, _reject) => {
+      let w = Worker.make(Worker.runWorkerUrl, {workerData: opts})
+      currentWorker := Some(w)
+      let settled = ref(false)
+      let settle = () =>
+        if !settled.contents {
+          settled := true
+          currentWorker := None
+          resolve()
+        }
+      w->Worker.on("exit", (_code: int) => settle())
+      w->Worker.on("error", e => {
+        Console.error2("gwt run worker error:", e)
+        settle()
+      })
+    })
   let runInProgress = ref(false)
   let rerunPending = ref(false)
   let run = async () => {
@@ -538,13 +606,17 @@ let runWatch = async (opts: options): int => {
       rerunPending := true
     } else {
       runInProgress := true
-      let _ = await runOnce(opts)
-      runInProgress := false
-      if rerunPending.contents {
+      let _ = await runInWorker()
+      // Drain every re-run request that arrived while a pass was in flight.
+      // Clearing `runInProgress` before awaiting the pending pass (the previous
+      // shape) let a third concurrent `run` start mid-drain, which corrupts the
+      // module-global `Collector` and interleaves NDJSON events. Hold the flag
+      // across the whole drain loop so only one pass ever runs at a time.
+      while rerunPending.contents {
         rerunPending := false
-        let _ = await runOnce(opts)
-        ()
+        let _ = await runInWorker()
       }
+      runInProgress := false
     }
   }
   let _ = await run()
@@ -560,33 +632,67 @@ let runWatch = async (opts: options): int => {
   // completion. Edits and adds stay on the lean incremental re-run. VS Code
   // only: a human terminal `watch` keeps the re-run-only loop (it doesn't own
   // the builds, so there's nothing to clean-rebuild).
+  // Guards against two structural paths from the *same* burst (a multi-file move
+  // within one package) each launching a concurrent clean-rebuild of that
+  // package. The first sets the flag; siblings coalesce into its completion
+  // re-run. Watch now emits one callback per distinct structural path, so this
+  // is what makes "rebuild every distinct owning package" (not per-file) true.
+  let rebuilding: Dict.t<bool> = Dict.make()
   let structuralRebuild = (path: string): unit =>
     switch PackageScan.findOwning(path) {
     | None => ignore(run())
+    | Some(pkg) if rebuilding->Dict.get(pkg.dir)->Option.getOr(false) => ()
     | Some(pkg) =>
+      rebuilding->Dict.set(pkg.dir, true)
       let t0 = Date.now()
       FormatterVsCode.buildStart(pkg.dir)
       // Surface a compile error during the rebuild (the clean/build stream is
       // classified for the error marker); the re-run is gated on completion
       // below, not on the classifier, since a one-shot `rescript build` has no
       // "Finished … compilation" terminator.
+      let sawError = ref(false)
       let feed = BuildClassifier.make({
         onStart: () => (),
         onOk: _ms => (),
-        onFail: msg => FormatterVsCode.buildFail(pkg.dir, msg),
+        onFail: msg => {
+          sawError := true
+          FormatterVsCode.buildFail(pkg.dir, msg)
+        },
       })
       ProcessManager.cleanRebuild(
         pkg,
         ~onStdout=(_dir, line) => feed(line),
-        ~onDone=() => {
-          FormatterVsCode.buildOk(pkg.dir, Date.now() -. t0)
+        ~onDone=ok => {
+          rebuilding->Dict.set(pkg.dir, false)
+          // Only report success when the build actually succeeded. On failure
+          // the classifier's `onFail` has usually already emitted the compiler
+          // error; emit a fallback `buildFail` only if it didn't (e.g. a crash
+          // with no recognisable marker), so we never claim `buildOk` over a
+          // broken build and re-run against stale `.res.mjs`.
+          if ok {
+            FormatterVsCode.buildOk(pkg.dir, Date.now() -. t0)
+          } else if !sawError.contents {
+            FormatterVsCode.buildFail(pkg.dir, "clean rebuild failed")
+          }
           ignore(run())
         },
       )
     }
+  // A test file added mid-session runs (discover re-scans each pass) but never
+  // appears in the client's tree, which was emitted once at start. On an `Add`
+  // of a *source* `.res` re-emit the discovery stream (idempotent snapshot) and
+  // (re)claim build watchers for any new package before re-running.
+  let refreshDiscovery = async () => {
+    let paths = await Discovery.discover(roots)
+    await emitDiscovery(paths)
+    startBuildWatchers(paths)
+    ignore(run())
+  }
   let _watcher = Watch.start(roots, (event, path) =>
     if opts.format == VsCode && Watch.isStructuralSource(event, path) {
       structuralRebuild(path)
+    } else if opts.format == VsCode && event == Watch.Add && path->String.endsWith(".res") {
+      ignore(refreshDiscovery())
     } else {
       ignore(run())
     }

package/src/Cli.res.mjs

@@ -3,9 +3,12 @@
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Watch$ReventlessGwt from "./Watch.res.mjs";
+import * as Nodeworker_threads from "node:worker_threads";
 import * as Loader$ReventlessGwt from "./Loader.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Worker$ReventlessGwt from "./Worker.res.mjs";
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as Collector$ReventlessGwt from "./Collector.res.mjs";
 import * as Discovery$ReventlessGwt from "./Discovery.res.mjs";
@@ -317,6 +320,29 @@ let exnMessage = (function(e) {
   return "unknown error"
 });
 
+function raceWithTimeout(body, ms) {
+  let handleRef = {
+    contents: undefined
+  };
+  let timeout = new Promise((resolve, _reject) => {
+    handleRef.contents = Primitive_option.some(setTimeout(() => resolve(Outcome$ReventlessGwt.fail({
+      TAG: "Throw",
+      error: `timed out after ` + ms.toString() + `ms`,
+      stack: ""
+    })), ms));
+  });
+  return Promise.race([
+    body(),
+    timeout
+  ]).then(o => {
+    let h = handleRef.contents;
+    if (h !== undefined) {
+      clearTimeout(Primitive_option.valFromOption(h));
+    }
+    return Promise.resolve(o);
+  });
+}
+
 async function runEntry(entry) {
   let start = performance.now();
   let status = "Pass";
@@ -334,7 +360,8 @@ async function runEntry(entry) {
   }
   if (exit === 1) {
     try {
-      let outcome = await entry.body();
+      let deadline = Stdlib_Option.getOr(entry.timeout, 5000);
+      let outcome = await raceWithTimeout(entry.body, deadline);
       if (outcome.TAG === "Ok") {
         status = "Pass";
       } else {
@@ -375,7 +402,7 @@ async function loadAndCollect(path) {
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "import failed");
-    Collector$ReventlessGwt.push(undefined, undefined, `<file-load-error>`, () => Promise.resolve(Outcome$ReventlessGwt.fail({
+    Collector$ReventlessGwt.push(undefined, undefined, undefined, `<file-load-error>`, () => Promise.resolve(Outcome$ReventlessGwt.fail({
       TAG: "Throw",
       error: "Failed to load " + path + ": " + msg,
       stack: ""
@@ -598,6 +625,37 @@ async function runWatch(opts) {
     await emitDiscovery(paths);
     startBuildWatchers(paths);
   }
+  let currentWorker = {
+    contents: undefined
+  };
+  Cancellation$ReventlessGwt.onCancel(() => {
+    let w = currentWorker.contents;
+    if (w !== undefined) {
+      Primitive_option.valFromOption(w).terminate();
+      return;
+    }
+  });
+  let runInWorker = () => new Promise((resolve, _reject) => {
+    let w = new Nodeworker_threads.Worker(Worker$ReventlessGwt.runWorkerUrl, {
+      workerData: opts
+    });
+    currentWorker.contents = Primitive_option.some(w);
+    let settled = {
+      contents: false
+    };
+    let settle = () => {
+      if (!settled.contents) {
+        settled.contents = true;
+        currentWorker.contents = undefined;
+        return resolve();
+      }
+    };
+    w.on("exit", _code => settle());
+    w.on("error", e => {
+      console.error("gwt run worker error:", e);
+      settle();
+    });
+  });
   let runInProgress = {
     contents: false
   };
@@ -608,40 +666,62 @@ async function runWatch(opts) {
     if (runInProgress.contents) {
       rerunPending.contents = true;
       return;
-    } else {
-      runInProgress.contents = true;
-      await runOnce(opts);
-      runInProgress.contents = false;
-      if (rerunPending.contents) {
-        rerunPending.contents = false;
-        await runOnce(opts);
-        return;
-      } else {
-        return;
-      }
     }
+    runInProgress.contents = true;
+    await runInWorker();
+    while (rerunPending.contents) {
+      rerunPending.contents = false;
+      await runInWorker();
+    };
+    runInProgress.contents = false;
   };
   await run();
+  let rebuilding = {};
+  let refreshDiscovery = async () => {
+    let paths = await Discovery$ReventlessGwt.discover(roots);
+    await emitDiscovery(paths);
+    startBuildWatchers(paths);
+    run();
+  };
   Watch$ReventlessGwt.start(roots, (event, path) => {
     if (opts.format === "VsCode" && Watch$ReventlessGwt.isStructuralSource(event, path)) {
       let pkg = PackageScan$ReventlessGwt.findOwning(path);
       if (pkg !== undefined) {
+        if (Stdlib_Option.getOr(rebuilding[pkg.dir], false)) {
+          return;
+        }
+        rebuilding[pkg.dir] = true;
         let t0 = Date.now();
         FormatterVsCode$ReventlessGwt.buildStart(pkg.dir);
+        let sawError = {
+          contents: false
+        };
         let feed = BuildClassifier$ReventlessGwt.make(undefined, {
           onStart: () => {},
           onOk: _ms => {},
-          onFail: msg => FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, msg)
+          onFail: msg => {
+            sawError.contents = true;
+            FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, msg);
+          }
         });
-        return ProcessManager$ReventlessGwt.cleanRebuild(pkg, (_dir, line) => feed(line), () => {
-          FormatterVsCode$ReventlessGwt.buildOk(pkg.dir, Date.now() - t0);
+        return ProcessManager$ReventlessGwt.cleanRebuild(pkg, (_dir, line) => feed(line), ok => {
+          rebuilding[pkg.dir] = false;
+          if (ok) {
+            FormatterVsCode$ReventlessGwt.buildOk(pkg.dir, Date.now() - t0);
+          } else if (!sawError.contents) {
+            FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, "clean rebuild failed");
+          }
           run();
         });
       }
       run();
       return;
     } else {
-      run();
+      if (opts.format === "VsCode" && event === "Add" && path.endsWith(".res")) {
+        refreshDiscovery();
+      } else {
+        run();
+      }
       return;
     }
   });
@@ -728,6 +808,8 @@ async function main() {
   }
 }
 
+let defaultTimeoutMs = 5000;
+
 export {
   toolVersion,
   dateNowIso,
@@ -737,6 +819,8 @@ export {
   parseArgv,
   passesFilter,
   exnMessage,
+  defaultTimeoutMs,
+  raceWithTimeout,
   runEntry,
   loadAndCollect,
   runFiles,

package/src/Collector.res

@@ -25,6 +25,10 @@ type entry = {
   body: unit => promise<Outcome.outcome>,
   status: status,
   location: option<location>,
+  // Per-test deadline in ms (from `~timeout` on `testPromise`). `None` = use the
+  // runner default. The CLI runner races the body against this; the Jest arm
+  // passes it to Jest's own timeout instead.
+  timeout: option<int>,
 }
 
 let active = ref(false)
@@ -43,6 +47,10 @@ let activate = () => {
   hasOnly := false
   skipNext := false
   onlyNext := false
+  // Reset the skip nesting depth too: a throwing `xdescribe` body in a prior
+  // file could otherwise leave it > 0, silently skipping every test in every
+  // subsequently loaded file.
+  skipDepth := 0
   currentFile := None
 }
 
@@ -73,6 +81,7 @@ let buildId = (describePath, name) => {
 let push = (
   ~slice=?,
   ~location=?,
+  ~timeout=?,
   name: string,
   body: unit => promise<Outcome.outcome>,
 ) => {
@@ -97,6 +106,7 @@ let push = (
     body,
     status,
     location,
+    timeout,
   }
   entries := Array.concat(entries.contents, [entry])
 }
@@ -115,6 +125,7 @@ let pushTodo = (name: string) => {
     body: () => Promise.resolve(Outcome.pass),
     status: Skipped,
     location: None,
+    timeout: None,
   }
   entries := Array.concat(entries.contents, [entry])
 }

package/src/Collector.res.mjs

@@ -42,6 +42,7 @@ function activate() {
   hasOnly.contents = false;
   skipNext.contents = false;
   onlyNext.contents = false;
+  skipDepth.contents = 0;
   currentFile.contents = undefined;
 }
 
@@ -86,7 +87,7 @@ function buildId(describePath, name) {
   }
 }
 
-function push(slice, location, name, body) {
+function push(slice, location, timeout, name, body) {
   let status = skipDepth.contents > 0 ? "Skipped" : (
       skipNext.contents ? (skipNext.contents = false, "Skipped") : (
           onlyNext.contents ? (onlyNext.contents = false, "Only") : "Runnable"
@@ -101,7 +102,8 @@ function push(slice, location, name, body) {
     slice: slice,
     body: body,
     status: status,
-    location: location
+    location: location,
+    timeout: timeout
   };
   entries.contents = entries.contents.concat([entry]);
 }
@@ -117,7 +119,8 @@ function pushTodo(name) {
     slice: undefined,
     body: entry_body,
     status: "Skipped",
-    location: undefined
+    location: undefined,
+    timeout: undefined
   };
   entries.contents = entries.contents.concat([entry]);
 }

package/src/Filter.res

@@ -29,8 +29,17 @@ let xtest = (~slice as _: option<string>=?, name: string, _body: unit => Outcome
 let xdescribe = (label: string, body: unit => unit) =>
   if Collector.isActive() {
     Collector.skipDepth := Collector.skipDepth.contents + 1
-    Collector.pushDescribe(label, body)
-    Collector.skipDepth := Collector.skipDepth.contents - 1
+    // Decrement on both the normal and the throwing path (ReScript has no
+    // `finally`): a body that raises must not leak the incremented depth and
+    // skip every following sibling/file.
+    try {
+      Collector.pushDescribe(label, body)
+      Collector.skipDepth := Collector.skipDepth.contents - 1
+    } catch {
+    | e =>
+      Collector.skipDepth := Collector.skipDepth.contents - 1
+      throw(e)
+    }
   } else {
     jestXDescribe(label, body)
   }