@reventlessdev/reventless-gwt 1.0.0-alpha.114 → 1.0.0-alpha.116

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.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
+
+
+
+
+
 # 1.0.0-alpha.114 (2026-07-14)
 
 ### Bug Fixes

package/package.json

@@ -1,12 +1,8 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.114",
-  "description": "Given-When-Then DSLs and CLI runner for Reventless slice testing",
+  "version": "1.0.0-alpha.116",
+  "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,15 +13,12 @@
     ]
   },
   "dependencies": {
-    "chokidar": "^3.6.0",
-    "picocolors": "^1.1.1",
     "sury": "11.0.0-alpha.4",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.168",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
-    "@reventlessdev/reventless-domain-protocol": "1.0.0-alpha.20",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.99",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.169",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.77",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.100"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/rescript.json

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

package/src/JestBind.res

@@ -2,10 +2,10 @@
 //
 // GWT DSLs emit `Outcome.outcome` from every `then*` combinator. Test files
 // registered via `JestBind.test` / `JestBind.testPromise` have their body's
-// outcome translated into a Jest pass/fail, unless the standalone CLI runner
-// has activated its in-process `Collector` — in which case the call pushes
-// straight into the collector and skips Jest. This lets the same test file
-// run under either `pnpm jest` or `reventless-gwt run` without modification.
+// outcome translated into a Jest pass/fail, unless an external runner has
+// registered an in-process sink (`RunnerHook`) — in which case the call is
+// routed to that sink and skips Jest. This lets the same test file run under
+// either plain `jest` or an external GWT runner without modification.
 //
 // `~slice` is the slice/component name — each DSL threads `Spec.name` through
 // so failure hints read `Look at AddCategory.decide` rather than the generic
@@ -29,27 +29,25 @@ let assertOutcome = (~slice=?, outcome: Outcome.outcome): unit =>
   }
 
 let describe = (label: string, body: unit => unit) =>
-  if Collector.isActive() {
-    Collector.pushDescribe(label, body)
-  } else {
-    JestGlobals.describe(label, body)
+  switch RunnerHook.get() {
+  | Some(sink) => sink.describe(label, body)
+  | None => JestGlobals.describe(label, body)
   }
 
 // Pending-spec placeholder emitted by the codegen for slices with no upstream
-// specification. Registers a non-running, non-failing entry under both runners.
+// specification. Registers a non-running, non-failing entry under both drivers.
 let todo = (label: string) =>
-  if Collector.isActive() {
-    Collector.pushTodo(label)
-  } else {
-    JestGlobals.todo(label)
+  switch RunnerHook.get() {
+  | Some(sink) => sink.todo(label)
+  | None => JestGlobals.todo(label)
   }
 
 let test = (~slice=?, name: string, body: unit => Outcome.outcome) =>
-  if Collector.isActive() {
-    let location = Collector.captureLocation(1)
-    Collector.push(~slice?, ~location?, name, () => Promise.resolve(body()))
-  } else {
-    JestGlobals.testSync(name, () => assertOutcome(~slice?, body()))
+  switch RunnerHook.get() {
+  | Some(sink) =>
+    let location = sink.captureLocation(1)
+    sink.test(~slice?, ~location?, name, () => Promise.resolve(body()))
+  | None => JestGlobals.testSync(name, () => assertOutcome(~slice?, body()))
   }
 
 let testPromise = (
@@ -58,10 +56,11 @@ let testPromise = (
   ~timeout: option<int>=?,
   body: unit => promise<Outcome.outcome>,
 ) =>
-  if Collector.isActive() {
-    let location = Collector.captureLocation(1)
-    Collector.push(~slice?, ~location?, ~timeout?, name, body)
-  } else {
+  switch RunnerHook.get() {
+  | Some(sink) =>
+    let location = sink.captureLocation(1)
+    sink.test(~slice?, ~location?, ~timeout?, name, body)
+  | None =>
     switch timeout {
     | Some(t) =>
       JestGlobals.testWithTimeout(name, async () => assertOutcome(~slice?, await body()), t)

package/src/JestBind.res.mjs

@@ -3,7 +3,7 @@
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Hint$ReventlessGwt from "./Hint.res.mjs";
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
-import * as Collector$ReventlessGwt from "./Collector.res.mjs";
+import * as RunnerHook$ReventlessGwt from "./RunnerHook.res.mjs";
 
 function assertOutcome(slice, outcome) {
   if (outcome.TAG === "Ok") {
@@ -15,8 +15,9 @@ function assertOutcome(slice, outcome) {
 }
 
 function describe(label, body) {
-  if (Collector$ReventlessGwt.isActive()) {
-    return Collector$ReventlessGwt.pushDescribe(label, body);
+  let sink = RunnerHook$ReventlessGwt.get();
+  if (sink !== undefined) {
+    return sink.describe(label, body);
   } else {
     globalThis.describe(label, body);
     return;
@@ -24,8 +25,9 @@ function describe(label, body) {
 }
 
 function todo(label) {
-  if (Collector$ReventlessGwt.isActive()) {
-    return Collector$ReventlessGwt.pushTodo(label);
+  let sink = RunnerHook$ReventlessGwt.get();
+  if (sink !== undefined) {
+    return sink.todo(label);
   } else {
     globalThis.test.todo(label);
     return;
@@ -33,15 +35,17 @@ function todo(label) {
 }
 
 function test(slice, name, body) {
-  if (Collector$ReventlessGwt.isActive()) {
-    let location = Collector$ReventlessGwt.captureLocation(1);
-    return Collector$ReventlessGwt.push(slice, location, undefined, name, () => Promise.resolve(body()));
+  let sink = RunnerHook$ReventlessGwt.get();
+  if (sink !== undefined) {
+    let location = sink.captureLocation(1);
+    return sink.test(slice, location, undefined, name, () => Promise.resolve(body()));
   }
   globalThis.test(name, () => assertOutcome(slice, body()));
 }
 
 function testPromise(slice, name, timeout, body) {
-  if (!Collector$ReventlessGwt.isActive()) {
+  let sink = RunnerHook$ReventlessGwt.get();
+  if (sink === undefined) {
     if (timeout !== undefined) {
       globalThis.test(name, async () => assertOutcome(slice, await body()), timeout);
     } else {
@@ -49,8 +53,8 @@ function testPromise(slice, name, timeout, body) {
     }
     return;
   }
-  let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, timeout, name, body);
+  let location = sink.captureLocation(1);
+  sink.test(slice, location, timeout, name, body);
 }
 
 export {

package/src/RunnerHook.res

@@ -0,0 +1,38 @@
+// Registration seam that lets an external runner intercept GWT test
+// registration in-process instead of forwarding to Jest.
+//
+// By default no runner is registered, so `JestBind` forwards every
+// `describe` / `test` / `testPromise` to Jest's globals — the workflow the
+// example apps use (`npx jest`), unchanged. An external runner may register an
+// in-process sink at startup; `JestBind` then routes each registration to the
+// sink instead, so the same `*_GWT.res` file runs unmodified under either
+// driver.
+
+type location = {
+  file: string,
+  line: int,
+  column: int,
+}
+
+type sink = {
+  describe: (string, unit => unit) => unit,
+  todo: string => unit,
+  // Capture the caller's source location by walking the current stack, skipping
+  // `n` internal frames. Invoked directly from `JestBind` so the resolved frame
+  // is the user's test file (the skip count is tuned for that call site).
+  captureLocation: int => option<location>,
+  test: (
+    ~slice: string=?,
+    ~location: location=?,
+    ~timeout: int=?,
+    string,
+    unit => promise<Outcome.outcome>,
+  ) => unit,
+}
+
+// The currently-registered sink, if any. `None` → plain Jest behaviour.
+let current: ref<option<sink>> = ref(None)
+
+let register = (s: sink) => current := Some(s)
+let reset = () => current := None
+let get = () => current.contents

package/src/RunnerHook.res.mjs

@@ -0,0 +1,26 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let current = {
+  contents: undefined
+};
+
+function register(s) {
+  current.contents = s;
+}
+
+function reset() {
+  current.contents = undefined;
+}
+
+function get() {
+  return current.contents;
+}
+
+export {
+  current,
+  register,
+  reset,
+  get,
+}
+/* No side 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)
-}