@reventlessdev/reventless-gwt 1.0.0-alpha.115 → 1.0.0-alpha.117

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.117 (2026-07-16)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
+# 1.0.0-alpha.116 (2026-07-16)
+
+* refactor(gwt)!: focus the package on the GWT test harness library ([925e944](https://github.com/ReventlessDev/reventless-core/commit/925e944e996613f4fb894564696ea8e1ff6b7489))
+
+### BREAKING CHANGES
+
+* the reventless-dev / reventless-gwt bin entries and the
+runner/formatter modules are no longer part of this package.
+
+
+
 # 1.0.0-alpha.115 (2026-07-15)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,12 +1,8 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.115",
-  "description": "Given-When-Then DSLs and CLI runner for Reventless slice testing",
+  "version": "1.0.0-alpha.117",
+  "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
-  "bin": {
-    "reventless-dev": "./bin/reventless-dev.mjs",
-    "reventless-gwt": "./bin/reventless-dev.mjs"
-  },
   "jest": {
     "testMatch": [
       "<rootDir>/tests/**/*Test.res.mjs"
@@ -17,23 +13,20 @@
     ]
   },
   "dependencies": {
-    "chokidar": "^3.6.0",
-    "picocolors": "^1.1.1",
     "sury": "11.0.0-alpha.4",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.169",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.100",
-    "@reventlessdev/reventless-domain-protocol": "1.0.0-alpha.20",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.77"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.28",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.8",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.170",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.78",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.101"
   },
   "devDependencies": {
-    "rescript": "^12.3.0",
+    "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
     "@reventlessdev/reventless-ppx": "1.0.0-alpha.53"
   },
   "peerDependencies": {
-    "rescript": "^12.3.0"
+    "rescript": "12.3.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/rescript.json

@@ -23,7 +23,6 @@
     }
   ],
   "dependencies": [
-    "@reventlessdev/reventless-domain-protocol",
     "sury",
     "@reventlessdev/rescript-jest",
     "@reventlessdev/rescript-effect",

package/bin/reventless-dev.mjs

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-// Thin launcher for the reventless-dev CLI (formerly reventless-gwt). The heavy lifting lives in
-// Cli.res — this file only resolves the compiled module and exits with the
-// code Cli.main returns.
-//
-// `LOG_LEVEL=silent` is the default so framework Info/Debug logs don't
-// interleave with NDJSON / TAP / JUnit streams. Set `LOG_LEVEL=info` (or
-// debug/warn/error) explicitly to re-enable. We use a dynamic `import()` so
-// the env is applied BEFORE any ReScript module runs its top-level
-// `Logger.fromEnv()` call.
-
-if (!process.env.LOG_LEVEL) process.env.LOG_LEVEL = "silent";
-
-const { main } = await import("../src/Cli.res.mjs");
-
-main()
-  .then((code) => process.exit(typeof code === "number" ? code : 0))
-  .catch((err) => {
-    console.error(err && err.stack ? err.stack : err);
-    process.exit(1);
-  });

package/src/Bind.res

@@ -1,29 +0,0 @@
-// CLI-mode binding for test files.
-//
-// Mirrors the shape of `JestBind` (`describe`, `test`, `testPromise`) but
-// pushes directly into `Collector` instead of forwarding to Jest globals.
-// Test files can either:
-//
-//   1. Rely on the DSL default (every `*_GWT.res` module uses `JestBind`
-//      internally, which routes to `Collector` when the CLI has activated it),
-//      or
-//   2. Explicitly `open ReventlessGwt.Bind` to get these functions bound at
-//      compile time — useful for ad-hoc harnesses or tests that want to
-//      bypass the JestBind fallback entirely.
-//
-// Either way, the runtime contract is identical: each call pushes one entry
-// into `Collector.entries`. The CLI drains the list after dynamic-import
-// resolves.
-
-let describe = (label: string, body: unit => unit) =>
-  Collector.pushDescribe(label, body)
-
-let test = (~slice=?, name: string, body: unit => Outcome.outcome) => {
-  let location = Collector.captureLocation(1)
-  Collector.push(~slice?, ~location?, name, () => Promise.resolve(body()))
-}
-
-let testPromise = (~slice=?, name: string, body: unit => promise<Outcome.outcome>) => {
-  let location = Collector.captureLocation(1)
-  Collector.push(~slice?, ~location?, name, body)
-}

package/src/Bind.res.mjs

@@ -1,22 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Collector$ReventlessGwt from "./Collector.res.mjs";
-
-let describe = Collector$ReventlessGwt.pushDescribe;
-
-function test(slice, name, body) {
-  let location = Collector$ReventlessGwt.captureLocation(1);
-  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, undefined, name, body);
-}
-
-export {
-  describe,
-  test,
-  testPromise,
-}
-/* No side effect */

package/src/BuildClassifier.res

@@ -1,147 +0,0 @@
-// Turns a ReScript v12 `rescript build -w` stdout line-stream into build status
-// callbacks. One classifier per managed package.
-//
-// The watch output cycle is:
-//   Parsed N source files          ← a compile pass begins
-//   Compiled N modules
-//   Finished incremental compilation   ← success terminator
-// On a type/syntax error there is NO terminator — rescript prints a
-// "We've found a bug for you!" block and waits. So success is detected on the
-// "Finished … compilation" line; failure is detected by an error marker and
-// flushed after the output settles (debounced), since there is no end line.
-//
-// Backstop: a build that prints "Parsed …" but then emits neither a terminator
-// nor a recognised error marker — a crashed/hung watcher, or an error in a form
-// the markers miss — would otherwise pin the consumer (the VS Code status bar)
-// at "building" forever. A generous wall-clock watchdog fails such a build so
-// the UI recovers.
-
-@val external now: unit => float = "performance.now"
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-@val external clearTimeout: float => unit = "clearTimeout"
-
-let stripAnsi: string => string = %raw(`s => s.replace(/\x1b\[[0-9;]*m/g, "")`)
-
-type callbacks = {
-  onStart: unit => unit,
-  onOk: float => unit,
-  onFail: string => unit,
-}
-
-let isStartLine = (l: string) =>
-  String.startsWith(l, "Parsed ") && String.endsWith(l, "source files")
-
-let isFinishLine = (l: string) =>
-  String.includes(l, "Finished") && String.includes(l, "compilation")
-
-let isErrorMarker = (l: string) =>
-  String.includes(l, "We've found a bug for you!") ||
-  String.includes(l, "Syntax error") ||
-  (String.startsWith(l, "Found ") && String.includes(l, "error"))
-
-// Returns a `feed` function: hand it each raw stdout line. `watchdogMs` bounds
-// how long a started-but-unterminated compile may stay "building" before it is
-// reported failed (see the backstop note above).
-let make = (~watchdogMs: int=120_000, cb: callbacks): (string => unit) => {
-  let compiling = ref(false)
-  let hasError = ref(false)
-  let startTime = ref(0.0)
-  let buffer = ref([])
-  let timer: ref<option<float>> = ref(None)
-  let watchdog: ref<option<float>> = ref(None)
-
-  let clearTimer = () =>
-    switch timer.contents {
-    | Some(t) => {
-        clearTimeout(t)
-        timer := None
-      }
-    | None => ()
-    }
-
-  let clearWatchdog = () =>
-    switch watchdog.contents {
-    | Some(t) => {
-        clearTimeout(t)
-        watchdog := None
-      }
-    | None => ()
-    }
-
-  let reset = () => {
-    compiling := false
-    hasError := false
-    buffer := []
-  }
-
-  // Cap the failure message so a pathological build can't emit an unbounded
-  // line. 20 was too tight — a multi-error build has several "We've found a bug"
-  // blocks and the tail (later errors) was silently dropped; keep enough to
-  // carry a handful of blocks.
-  let maxMessageLines = 200
-
-  // After output settles, a build that saw an error (and thus no "Finished"
-  // terminator) is reported failed, capturing a concise message. The condition
-  // is `hasError` alone — not `compiling && hasError` — so an error emitted
-  // *before* the first "Parsed …" line (a crashed toolchain, a pnpm/resolution
-  // failure) still settles into an `onFail` instead of leaving the consumer
-  // pinned at its previous state forever.
-  let settle = () =>
-    if hasError.contents {
-      let msg = buffer.contents->Array.slice(~start=0, ~end=maxMessageLines)->Array.join("\n")
-      clearWatchdog()
-      cb.onFail(msg)
-      reset()
-    }
-
-  let arm = () => {
-    clearTimer()
-    timer := Some(setTimeout(settle, 400))
-  }
-
-  // Last-resort timer: fail a build still compiling after `watchdogMs` with no
-  // terminator and no recognised error, so the consumer never spins forever.
-  let armWatchdog = () => {
-    clearWatchdog()
-    watchdog :=
-      Some(
-        setTimeout(() =>
-          if compiling.contents {
-            clearTimer()
-            cb.onFail("build watchdog: no completion within " ++ Int.toString(watchdogMs / 1000) ++ "s")
-            reset()
-          }
-        , watchdogMs),
-      )
-  }
-
-  line => {
-    let l = stripAnsi(line)->String.trim
-    if isStartLine(l) {
-      if !compiling.contents {
-        cb.onStart()
-      }
-      compiling := true
-      hasError := false
-      buffer := []
-      startTime := now()
-      arm()
-      armWatchdog()
-    } else if isFinishLine(l) {
-      clearTimer()
-      clearWatchdog()
-      if compiling.contents {
-        cb.onOk(now() -. startTime.contents)
-        reset()
-      }
-    } else {
-      if String.length(l) > 0 {
-        buffer.contents->Array.push(l)
-      }
-      if isErrorMarker(l) {
-        hasError := true
-      }
-      arm()
-    }
-  }
-}

package/src/BuildClassifier.res.mjs

@@ -1,136 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let stripAnsi = (s => s.replace(/\x1b\[[0-9;]*m/g, ""));
-
-function isStartLine(l) {
-  if (l.startsWith("Parsed ")) {
-    return l.endsWith("source files");
-  } else {
-    return false;
-  }
-}
-
-function isFinishLine(l) {
-  if (l.includes("Finished")) {
-    return l.includes("compilation");
-  } else {
-    return false;
-  }
-}
-
-function isErrorMarker(l) {
-  if (l.includes("We've found a bug for you!") || l.includes("Syntax error")) {
-    return true;
-  } else if (l.startsWith("Found ")) {
-    return l.includes("error");
-  } else {
-    return false;
-  }
-}
-
-function make(watchdogMsOpt, cb) {
-  let watchdogMs = watchdogMsOpt !== undefined ? watchdogMsOpt : 120000;
-  let compiling = {
-    contents: false
-  };
-  let hasError = {
-    contents: false
-  };
-  let startTime = {
-    contents: 0.0
-  };
-  let buffer = {
-    contents: []
-  };
-  let timer = {
-    contents: undefined
-  };
-  let watchdog = {
-    contents: undefined
-  };
-  let clearTimer = () => {
-    let t = timer.contents;
-    if (t !== undefined) {
-      clearTimeout(t);
-      timer.contents = undefined;
-      return;
-    }
-  };
-  let clearWatchdog = () => {
-    let t = watchdog.contents;
-    if (t !== undefined) {
-      clearTimeout(t);
-      watchdog.contents = undefined;
-      return;
-    }
-  };
-  let reset = () => {
-    compiling.contents = false;
-    hasError.contents = false;
-    buffer.contents = [];
-  };
-  let settle = () => {
-    if (!hasError.contents) {
-      return;
-    }
-    let msg = buffer.contents.slice(0, 200).join("\n");
-    clearWatchdog();
-    cb.onFail(msg);
-    reset();
-  };
-  let arm = () => {
-    clearTimer();
-    timer.contents = setTimeout(settle, 400);
-  };
-  let armWatchdog = () => {
-    clearWatchdog();
-    watchdog.contents = setTimeout(() => {
-      if (compiling.contents) {
-        clearTimer();
-        cb.onFail("build watchdog: no completion within " + (watchdogMs / 1000 | 0).toString() + "s");
-        return reset();
-      }
-    }, watchdogMs);
-  };
-  return line => {
-    let l = stripAnsi(line).trim();
-    if (isStartLine(l)) {
-      if (!compiling.contents) {
-        cb.onStart();
-      }
-      compiling.contents = true;
-      hasError.contents = false;
-      buffer.contents = [];
-      startTime.contents = performance.now();
-      arm();
-      return armWatchdog();
-    } else if (isFinishLine(l)) {
-      clearTimer();
-      clearWatchdog();
-      if (compiling.contents) {
-        cb.onOk(performance.now() - startTime.contents);
-        return reset();
-      } else {
-        return;
-      }
-    } else {
-      if (l.length > 0) {
-        buffer.contents.push(l);
-      }
-      if (isErrorMarker(l)) {
-        hasError.contents = true;
-      }
-      return arm();
-    }
-  };
-}
-
-export {
-  stripAnsi,
-  isStartLine,
-  isFinishLine,
-  isErrorMarker,
-  make,
-}
-/* No side effect */

package/src/Cancellation.res

@@ -1,37 +0,0 @@
-// SIGINT / SIGTERM trap. Sets a module-level flag that the main loop
-// polls between tests. The VS Code and JSON streaming formatters flush a
-// `runEnd` event with the skipped remainder before the process exits.
-
-type process
-@val external process: process = "process"
-@send external onSignal: (process, string, unit => unit) => unit = "on"
-@send external exit: (process, int) => unit = "exit"
-
-let cancelled = ref(false)
-let handlers: ref<array<unit => unit>> = ref([])
-
-let isCancelled = () => cancelled.contents
-
-let onCancel = (handler: unit => unit) =>
-  handlers := Array.concat(handlers.contents, [handler])
-
-let install = () => {
-  let handler = () => {
-    if !cancelled.contents {
-      cancelled := true
-      handlers.contents->Array.forEach(h =>
-        try h() catch {
-        | _ => ()
-        }
-      )
-    } 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)
-  process->onSignal("SIGTERM", handler)
-}

package/src/Cancellation.res.mjs

@@ -1,46 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let cancelled = {
-  contents: false
-};
-
-let handlers = {
-  contents: []
-};
-
-function isCancelled() {
-  return cancelled.contents;
-}
-
-function onCancel(handler) {
-  handlers.contents = handlers.contents.concat([handler]);
-}
-
-function install() {
-  let handler = () => {
-    if (cancelled.contents) {
-      process.exit(130);
-    } else {
-      cancelled.contents = true;
-      handlers.contents.forEach(h => {
-        try {
-          return h();
-        } catch (exn) {
-          return;
-        }
-      });
-    }
-  };
-  process.on("SIGINT", handler);
-  process.on("SIGTERM", handler);
-}
-
-export {
-  cancelled,
-  handlers,
-  isCancelled,
-  onCancel,
-  install,
-}
-/* No side effect */

package/src/ChildProcess.res

@@ -1,102 +0,0 @@
-// Minimal `node:child_process` binding for the watch-mode build manager. The
-// only consumer is ProcessManager, which spawns one `pnpm run start`
-// (`rescript build -w`) per package. Children are spawned **detached** so each
-// gets its own process group; killing the negative pid then tears down the whole
-// tree (pnpm + the rescript watcher it spawns) — no orphaned compilers.
-
-type t
-type stream
-
-type spawnOptions = {
-  cwd: string,
-  detached: bool,
-  env: Dict.t<string>,
-}
-
-@module("node:child_process")
-external _spawn: (string, array<string>, spawnOptions) => t = "spawn"
-
-@val external _processEnv: Dict.t<string> = "process.env"
-
-// Merge the current process env with optional overrides into a fresh dict — node's
-// `spawn` replaces the whole env, so callers that pass `~env` still inherit PATH etc.
-let mergeEnv = (overrides: option<Dict.t<string>>): Dict.t<string> => {
-  let m = Dict.make()
-  _processEnv->Dict.toArray->Array.forEach(((k, v)) => m->Dict.set(k, v))
-  switch overrides {
-  | Some(o) => o->Dict.toArray->Array.forEach(((k, v)) => m->Dict.set(k, v))
-  | None => ()
-  }
-  m
-}
-
-@get external _pid: t => Nullable.t<int> = "pid"
-@get external _stdout: t => stream = "stdout"
-@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"
-
-let spawn = (cmd: string, args: array<string>, ~cwd: string, ~env: option<Dict.t<string>>=?): t =>
-  _spawn(cmd, args, {cwd, detached: true, env: mergeEnv(env)})
-
-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. 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("")
-  _streamOn(s, "data", chunk => {
-    buf := buf.contents ++ chunk
-    let rec drain = () =>
-      switch String.indexOf(buf.contents, "\n") {
-      | -1 => ()
-      | idx => {
-          let line = String.slice(buf.contents, ~start=0, ~end=idx)
-          buf := String.slice(buf.contents, ~start=idx + 1, ~end=String.length(buf.contents))
-          cb(line)
-          drain()
-        }
-      }
-    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)
-let onStderrLine = (proc: t, cb: string => unit): unit => onLines(proc->_stderr, cb)
-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 =>
-  switch proc->pid {
-  | Some(p) =>
-    try {
-      _processKill(-p, signal)
-    } catch {
-    | _ => ignore(proc->_kill(signal))
-    }
-  | None => ignore(proc->_kill(signal))
-  }