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

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 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.115 (2026-07-15)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
+# 1.0.0-alpha.114 (2026-07-14)
+
+### Bug Fixes
+
+* show debug logs on the local platform (both launch paths) ([81837d7](https://github.com/ReventlessDev/reventless-core/commit/81837d7e02abe1065a722b43b195adef2c836794))
+### Features
+
+* **core:** thread ~comp through Projection.handleAction for attributed action logging ([fa32d93](https://github.com/ReventlessDev/reventless-core/commit/fa32d93dedabea1b1f655f01a4ea769a5908b143))
+
+
 # 1.0.0-alpha.113 (2026-07-14)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.113",
+  "version": "1.0.0-alpha.115",
   "description": "Given-When-Then DSLs and CLI runner for Reventless slice testing",
   "license": "Apache-2.0",
   "bin": {
@@ -21,11 +21,11 @@
     "picocolors": "^1.1.1",
     "sury": "11.0.0-alpha.4",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.167",
-    "@reventlessdev/reventless-domain-protocol": "1.0.0-alpha.20",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
-    "@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-infra": "3.0.0-alpha.100",
+    "@reventlessdev/reventless-domain-protocol": "1.0.0-alpha.20",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.77"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/Cli.res

@@ -60,7 +60,7 @@ let sha256 = (s: string): string => createHash("sha256")->hashUpdate(s)->hashDig
 // re-emit forces the client to re-render the domain view for nothing.
 let lastDomainHash: ref<option<string>> = ref(None)
 
-let dateNowIso: unit => string = %raw(`() => new Date().toISOString()`)
+let dateNowIso = (): string => Date.make()->Date.toISOString
 
 let parseFormat = (s: string) =>
   switch s {
@@ -229,23 +229,6 @@ let passesFilter = (id: string, filters: array<string>) =>
   filters->Array.length == 0 ||
     filters->Array.some(f => id->String.includes(f))
 
-// Extract a human-readable message from any thrown value. JS Errors carry a
-// `.message`; ReScript exceptions are tagged objects (`RE_EXN_ID` + an optional
-// string payload), e.g. `failwith("…")` raises `Failure("…")`. Without this the
-// catch block below collapsed every ReScript exception to "unknown error",
-// hiding messages like a slice's `failwith("not implemented: …")`.
-let exnMessage: exn => string = %raw(`function(e) {
-  if (e == null) return "unknown error"
-  if (typeof e === "string") return e
-  if (typeof e.message === "string" && e.message.length) return e.message
-  if (typeof e.RE_EXN_ID === "string") {
-    var id = e.RE_EXN_ID
-    var tag = id.lastIndexOf(".") >= 0 ? id.slice(id.lastIndexOf(".") + 1) : id
-    return (typeof e._1 === "string" && e._1.length) ? e._1 : tag
-  }
-  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
@@ -304,8 +287,8 @@ let runEntry = async (entry: Collector.entry): RunnerTypes.testResult => {
     } catch {
     | exn => {
         status := Fail
-        let err = exnMessage(exn)
-        let stack: string = %raw(`(e => (e && e.stack) || "")`)(exn)
+        let err = ExnMessage.extract(exn)
+        let stack = ExnMessage.stack(exn)
         mismatch := Some(Outcome.Throw({error: err, stack: stack}))
       }
     }
@@ -326,6 +309,7 @@ let runEntry = async (entry: Collector.entry): RunnerTypes.testResult => {
 
 let loadAndCollect = async (path: string): array<Collector.entry> => {
   Collector.activate()
+  RunnerHook.register(Collector.asSink)
   Collector.setCurrentFile(path)
   try {
     await Loader.loadFile(path)

package/src/Cli.res.mjs

@@ -16,6 +16,8 @@ import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as Collector$ReventlessGwt from "./Collector.res.mjs";
 import * as Discovery$ReventlessGwt from "./Discovery.res.mjs";
 import * as LocalHost$ReventlessGwt from "./LocalHost.res.mjs";
+import * as ExnMessage$ReventlessGwt from "./ExnMessage.res.mjs";
+import * as RunnerHook$ReventlessGwt from "./RunnerHook.res.mjs";
 import * as DomainGraph$ReventlessGwt from "./DomainGraph.res.mjs";
 import * as PackageScan$ReventlessGwt from "./PackageScan.res.mjs";
 import * as RunnerTypes$ReventlessGwt from "./RunnerTypes.res.mjs";
@@ -44,7 +46,9 @@ let lastDomainHash = {
   contents: undefined
 };
 
-let dateNowIso = (() => new Date().toISOString());
+function dateNowIso() {
+  return new Date().toISOString();
+}
 
 function parseFormat(s) {
   switch (s) {
@@ -320,18 +324,6 @@ function passesFilter(id, filters) {
   }
 }
 
-let exnMessage = (function(e) {
-  if (e == null) return "unknown error"
-  if (typeof e === "string") return e
-  if (typeof e.message === "string" && e.message.length) return e.message
-  if (typeof e.RE_EXN_ID === "string") {
-    var id = e.RE_EXN_ID
-    var tag = id.lastIndexOf(".") >= 0 ? id.slice(id.lastIndexOf(".") + 1) : id
-    return (typeof e._1 === "string" && e._1.length) ? e._1 : tag
-  }
-  return "unknown error"
-});
-
 function raceWithTimeout(body, ms) {
   let handleRef = {
     contents: undefined
@@ -383,8 +375,8 @@ async function runEntry(entry) {
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       status = "Fail";
-      let err = exnMessage(exn);
-      let stack = ((e => (e && e.stack) || ""))(exn);
+      let err = ExnMessage$ReventlessGwt.extract(exn);
+      let stack = ExnMessage$ReventlessGwt.stack(exn);
       mismatch = {
         TAG: "Throw",
         error: err,
@@ -408,6 +400,7 @@ async function runEntry(entry) {
 
 async function loadAndCollect(path) {
   Collector$ReventlessGwt.activate();
+  RunnerHook$ReventlessGwt.register(Collector$ReventlessGwt.asSink);
   Collector$ReventlessGwt.setCurrentFile(path);
   try {
     await Loader$ReventlessGwt.loadFile(path);
@@ -426,7 +419,7 @@ async function loadAndCollect(path) {
 }
 
 async function runFiles(opts, paths, onFileFinished, onTestStart, onTestFinished) {
-  let startedAt = dateNowIso();
+  let startedAt = new Date().toISOString();
   let startTime = performance.now();
   let files = [];
   for (let i = 0, i_finish = paths.length; i < i_finish; ++i) {
@@ -560,7 +553,7 @@ async function runOnce(opts) {
   let p = opts.paths;
   let paths = p !== undefined ? p : await Discovery$ReventlessGwt.discover(opts.roots);
   if (opts.format === "Json" && opts.stream) {
-    FormatterJson$ReventlessGwt.streamRunStart(opts.toolVersion, dateNowIso(), opts.schemaVersion);
+    FormatterJson$ReventlessGwt.streamRunStart(opts.toolVersion, new Date().toISOString(), opts.schemaVersion);
   }
   let match = opts.format;
   let match$1 = opts.stream;
@@ -929,7 +922,6 @@ export {
   help,
   parseArgv,
   passesFilter,
-  exnMessage,
   defaultTimeoutMs,
   raceWithTimeout,
   runEntry,

package/src/Collector.res

@@ -11,11 +11,9 @@
 
 type status = Skipped | Runnable | Only
 
-type location = {
-  file: string,
-  line: int,
-  column: int,
-}
+// Source location shape is shared with `RunnerHook` so this collector can be
+// exposed as a `RunnerHook.sink` without a conversion layer.
+type location = RunnerHook.location
 
 type entry = {
   id: string,
@@ -210,3 +208,15 @@ let captureLocation = (skip: int): option<location> => {
     find(skip + 1)
   }
 }
+
+// Expose this collector as a `RunnerHook.sink` so a driver can route `JestBind`
+// registrations here. `captureLocation` is bound directly (no wrapper closure)
+// so the stack depth `JestBind` skips when capturing the caller's location is
+// unchanged from calling `captureLocation` inline.
+let asSink: RunnerHook.sink = {
+  describe: pushDescribe,
+  todo: pushTodo,
+  captureLocation,
+  test: (~slice=?, ~location=?, ~timeout=?, name, body) =>
+    push(~slice?, ~location?, ~timeout?, name, body),
+}

package/src/Collector.res.mjs

@@ -191,6 +191,15 @@ function captureLocation(skip) {
   };
 }
 
+let asSink_test = push;
+
+let asSink = {
+  describe: pushDescribe,
+  todo: pushTodo,
+  captureLocation: captureLocation,
+  test: asSink_test
+};
+
 export {
   active,
   describeStack,
@@ -214,5 +223,6 @@ export {
   drain,
   parseFrame,
   captureLocation,
+  asSink,
 }
 /* No side effect */

package/src/ComponentScan.res

@@ -26,8 +26,6 @@ external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
 @module("node:fs") external _existsSync: string => bool = "existsSync"
 @module("node:path") external join: (string, string) => string = "join"
 
-let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
-let shouldIgnore = (name: string) => Array.includes(ignoreNames, name)
 
 // A directory carrying this sentinel file — and its whole subtree — is pruned
 // from the component scan, matching `Discovery`'s `.gwtignore` convention so
@@ -51,7 +49,7 @@ let rec walk = async (dir: string, acc: array<string>): array<string> => {
   let found = ref(acc)
   for i in 0 to entries->Array.length - 1 {
     let entry = entries->Array.getUnsafe(i)
-    if !shouldIgnore(entry.name) {
+    if !ScanIgnore.shouldIgnore(entry.name) {
       let full = join(dir, entry.name)
       if entry._isDirectory() {
         let nested = await walk(full, [])

package/src/ComponentScan.res.mjs

@@ -4,20 +4,9 @@ import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Promises from "node:fs/promises";
+import * as ScanIgnore$ReventlessGwt from "./ScanIgnore.res.mjs";
 import * as ComponentMeta$ReventlessGwt from "./ComponentMeta.res.mjs";
 
-let ignoreNames = [
-  "node_modules",
-  ".git",
-  "dist",
-  "lib",
-  ".history"
-];
-
-function shouldIgnore(name) {
-  return ignoreNames.includes(name);
-}
-
 let gwtIgnoreFile = ".gwtignore";
 
 function isPruned(entries) {
@@ -43,7 +32,7 @@ async function walk(dir, acc) {
   let found = acc;
   for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
     let entry = entries[i];
-    if (!ignoreNames.includes(entry.name)) {
+    if (!ScanIgnore$ReventlessGwt.shouldIgnore(entry.name)) {
       let full = Nodepath.join(dir, entry.name);
       if (entry.isDirectory()) {
         let nested = await walk(full, []);
@@ -94,8 +83,6 @@ async function scan(pkgDirs) {
 }
 
 export {
-  ignoreNames,
-  shouldIgnore,
   gwtIgnoreFile,
   isPruned,
   isSrcResFile,

package/src/Discovery.res

@@ -28,11 +28,8 @@ type stats = {
 @module("node:path") external isAbsolute: string => bool = "isAbsolute"
 @module("node:path") external resolve: string => string = "resolve"
 
-let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
-let shouldIgnore = (name: string) => Array.includes(ignoreNames, name)
-
 // A directory carrying this sentinel file — and its whole subtree — is pruned
-// from discovery. Unlike the `ignoreNames` dir-name list, this is filesystem
+// from discovery. Unlike the `ScanIgnore.names` dir-name list, this is filesystem
 // state, so it excludes generated/vendored trees (e.g. codegen golden fixtures)
 // even when compiled `*_GWT.res.mjs` are present on disk.
 let gwtIgnoreFile = ".gwtignore"
@@ -58,7 +55,7 @@ let rec walk = async (dir: string, acc: array<string>): unit => {
   } else {
     for i in 0 to entries->Array.length - 1 {
       let entry = entries->Array.getUnsafe(i)
-      if !shouldIgnore(entry.name) {
+      if !ScanIgnore.shouldIgnore(entry.name) {
         let full = join(dir, entry.name)
         if entry._isDirectory() {
           await walk(full, acc)

package/src/Discovery.res.mjs

@@ -2,18 +2,7 @@
 
 import * as Nodepath from "node:path";
 import * as Promises from "node:fs/promises";
-
-let ignoreNames = [
-  "node_modules",
-  ".git",
-  "dist",
-  "lib",
-  ".history"
-];
-
-function shouldIgnore(name) {
-  return ignoreNames.includes(name);
-}
+import * as ScanIgnore$ReventlessGwt from "./ScanIgnore.res.mjs";
 
 let gwtIgnoreFile = ".gwtignore";
 
@@ -43,7 +32,7 @@ async function walk(dir, acc) {
   }
   for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
     let entry = entries[i];
-    if (!ignoreNames.includes(entry.name)) {
+    if (!ScanIgnore$ReventlessGwt.shouldIgnore(entry.name)) {
       let full = Nodepath.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full, acc);
@@ -88,8 +77,6 @@ async function discover(roots) {
 }
 
 export {
-  ignoreNames,
-  shouldIgnore,
   gwtIgnoreFile,
   isPruned,
   isGwtTestFile,

package/src/ExnMessage.res

@@ -0,0 +1,14 @@
+// Typed bindings for the exception reflection in the companion `ExnReflect.mjs`.
+// Inspecting an arbitrary thrown value's shape (`.message`, `RE_EXN_ID`/`_1`,
+// `.stack`, a bare string, `throw null`) is untyped work ReScript can't
+// pattern-match, so it lives whole in that JS module — no `%raw`, no `Obj.magic`
+// here. Used by the runner's catch block to surface a test body's real error
+// (e.g. a slice's `failwith("not implemented: …")`) instead of "unknown error".
+
+// A human-readable message from any thrown value.
+@module("./ExnReflect.mjs")
+external extract: exn => string = "extractMessage"
+
+// The `.stack` of a thrown JS `Error`, or "" when absent.
+@module("./ExnReflect.mjs")
+external stack: exn => string = "stackOf"

package/src/ExnMessage.res.mjs

@@ -0,0 +1,17 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ExnReflectMjs from "./ExnReflect.mjs";
+
+function extract(prim) {
+  return ExnReflectMjs.extractMessage(prim);
+}
+
+function stack(prim) {
+  return ExnReflectMjs.stackOf(prim);
+}
+
+export {
+  extract,
+  stack,
+}
+/* ./ExnReflect.mjs Not a pure module */

package/src/ExnReflect.mjs

@@ -0,0 +1,24 @@
+// Untyped reflection over an arbitrary thrown value — the shapes ReScript can't
+// pattern-match. Kept whole in JS so the ReScript side (ExnMessage.res) is a
+// clean typed binding with no `%raw` or `Obj.magic`.
+
+// A human-readable message: a `throw null`, a bare thrown string, a JS `Error`
+// (`.message`), or a ReScript exception's constructor payload (`RE_EXN_ID` +
+// `_1`, e.g. `failwith("…")` raises `Failure`).
+export function extractMessage(e) {
+  if (e == null) return "unknown error";
+  if (typeof e === "string") return e;
+  if (typeof e.message === "string" && e.message.length) return e.message;
+  if (typeof e.RE_EXN_ID === "string") {
+    const id = e.RE_EXN_ID;
+    const dot = id.lastIndexOf(".");
+    const tag = dot >= 0 ? id.slice(dot + 1) : id;
+    return typeof e._1 === "string" && e._1.length ? e._1 : tag;
+  }
+  return "unknown error";
+}
+
+// The `.stack` of a thrown JS `Error`, or "" for anything without one.
+export function stackOf(e) {
+  return (e && e.stack) || "";
+}

package/src/FormatterVsCode.res

@@ -100,7 +100,7 @@ let locateInSource = (mjsPath: string, label: string): option<Collector.location
             if col < 0 {
               find(i + 1)
             } else {
-              Some({Collector.file: resPath, line: i + 1, column: col})
+              Some({RunnerHook.file: resPath, line: i + 1, column: col})
             }
           }
         find(0)

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/MultiSourceProjection_GWT.res.mjs

@@ -45,9 +45,9 @@ function Make(Projection) {
   let deleteSubState = (store, id, subId, getSubId) => {
     store[id] = Stdlib_Option.getOr(Stdlib_Option.map(store[id], states => states.filter(state => Primitive_object.notequal(getSubId(state), subId))), []);
   };
+  let handleActions = (actions, operations) => Projection$ReventlessCore.handleActions(undefined, actions, operations, Projection.subIdConfig);
   let update = async (store, events$p) => {
-    let actions = events$p.map(event$p => Projection.project(event$p));
-    await Projection$ReventlessCore.handleActions(actions, {
+    await handleActions(events$p.map(event$p => Projection.project(event$p)), {
       load: extra => Promise.resolve({
         TAG: "Ok",
         _0: states(store, extra)
@@ -163,7 +163,7 @@ function Make(Projection) {
           _0: undefined
         });
       }
-    }, Projection.subIdConfig);
+    });
     if (Projection.subIdConfig !== undefined) {
       return Stdlib_Dict.mapValues(store, states => states.toSorted((state1, state2) => Primitive_string.compare(getSubId(state1), getSubId(state2))));
     } else {

package/src/PlatformRunner.res

@@ -11,6 +11,8 @@
 
 let tapSentinel = "@@RVLESS_EVT@@ "
 
+@val external _envLogLevel: option<string> = "process.env.LOG_LEVEL"
+
 type lineClass =
   | Domain(JSON.t) // a tap line; the parsed `{event:"domainEvent",…}` payload
   | Ready // the Domain GraphQL server's "listening on …" line
@@ -110,6 +112,18 @@ let run = async (
     let pPort = ports->Array.getUnsafe(1)
     let dMcp = ports->Array.getUnsafe(2)
     let pMcp = ports->Array.getUnsafe(3)
+    // The gwt bin defaults LOG_LEVEL=silent so its OWN stdout stays pure NDJSON;
+    // the platform child is a separate process whose stdout we parse, so it needs
+    // real logs — the "listening on" line drives readiness and the rest becomes
+    // platformLog. Default it to the local platform's own verbosity (debug — same
+    // as `pnpm run serve`, which relies on reventless-local's Debug default), so
+    // projection/action debug lines surface in the runner log. An explicit
+    // LOG_LEVEL the developer set (anything but the bin's silent default) is
+    // honored, so `LOG_LEVEL=info` still quietens it.
+    let childLogLevel = switch _envLogLevel {
+    | Some(l) if l != "silent" && l != "" => l
+    | _ => "debug"
+    }
     let env = Dict.fromArray([
       ("REVENTLESS_EVENT_TAP", "ndjson"),
       ("REVENTLESS_LOCAL_BACKEND", backend),
@@ -118,11 +132,7 @@ let run = async (
       ("REVENTLESS_DOMAIN_MCP_PORT", Int.toString(dMcp)),
       ("REVENTLESS_PLATFORM_MCP_PORT", Int.toString(pMcp)),
       ("NODE_OPTIONS", "--disable-warning=ExperimentalWarning"),
-      // The gwt bin defaults LOG_LEVEL=silent so its OWN stdout stays pure NDJSON;
-      // the platform child is a separate process whose stdout we parse, so it needs
-      // real logs — the "listening on" line drives readiness and the rest becomes
-      // platformLog. Override the inherited silent.
-      ("LOG_LEVEL", "info"),
+      ("LOG_LEVEL", childLogLevel),
       // The child's stdout is a pipe (we line-parse it), so the framework's sink
       // detection would auto-pick JSON (non-TTY). But every consumer of `onLog`
       // renders ANSI — the CLI forwards to the developer's terminal, the extension

package/src/PlatformRunner.res.mjs

@@ -80,6 +80,8 @@ async function run(roots, backend, fixedPortsOpt, callbacks) {
     let pPort = ports[1];
     let dMcp = ports[2];
     let pMcp = ports[3];
+    let l = process.env.LOG_LEVEL;
+    let childLogLevel = l !== undefined && l !== "silent" && l !== "" ? l : "debug";
     let env = Object.fromEntries([
       [
         "REVENTLESS_EVENT_TAP",
@@ -111,7 +113,7 @@ async function run(roots, backend, fixedPortsOpt, callbacks) {
       ],
       [
         "LOG_LEVEL",
-        "info"
+        childLogLevel
       ],
       [
         "REVENTLESS_LOG_FORMAT",

package/src/PlatformScan.res

@@ -31,7 +31,6 @@ external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
 @module("node:path") external join: (string, string) => string = "join"
 
 let localPlatformDep = "@reventlessdev/reventless-local"
-let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
 
 // Pure predicate: given a package.json's text and whether src/Main.res.mjs exists,
 // decide whether this is a launchable platform package and surface its name +
@@ -116,7 +115,7 @@ let rec walk = async (dir: string, acc: array<platformPkg>): array<platformPkg>
     }
     for i in 0 to entries->Array.length - 1 {
       let entry = entries->Array.getUnsafe(i)
-      if entry._isDirectory() && !Array.includes(ignoreNames, entry.name) {
+      if entry._isDirectory() && !ScanIgnore.shouldIgnore(entry.name) {
         let _ = await walk(join(dir, entry.name), acc)
       }
     }

package/src/PlatformScan.res.mjs

@@ -5,17 +5,10 @@ import * as Nodepath from "node:path";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Promises from "node:fs/promises";
+import * as ScanIgnore$ReventlessGwt from "./ScanIgnore.res.mjs";
 
 let localPlatformDep = "@reventlessdev/reventless-local";
 
-let ignoreNames = [
-  "node_modules",
-  ".git",
-  "dist",
-  "lib",
-  ".history"
-];
-
 function matchPlatform(pkgJsonText, mainExists) {
   if (!mainExists) {
     return;
@@ -94,7 +87,7 @@ async function walk(dir, acc) {
     }
     for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
       let entry = entries[i];
-      if (entry.isDirectory() && !ignoreNames.includes(entry.name)) {
+      if (entry.isDirectory() && !ScanIgnore$ReventlessGwt.shouldIgnore(entry.name)) {
         await walk(Nodepath.join(dir, entry.name), acc);
       }
     }
@@ -123,7 +116,6 @@ async function scan(roots) {
 
 export {
   localPlatformDep,
-  ignoreNames,
   matchPlatform,
   inspectDir,
   walk,

package/src/Projection_GWT.res.mjs

@@ -59,9 +59,10 @@ function Make(Spec) {
     let deleteSubState = (store, id, subId, getSubId) => {
       store[id] = Stdlib_Option.getOr(Stdlib_Option.map(store[id], states => states.filter(state => Primitive_object.notequal(getSubId(state), subId))), []);
     };
+    let runActions = (actions, operations) => Projection$ReventlessCore.handleActions(undefined, actions, operations, Spec.subIdConfig);
     let update = async (store, events) => {
       let actions = events.map(ev => Projection.project(ev)).flat();
-      await Projection$ReventlessCore.handleActions(actions, {
+      await runActions(actions, {
         load: extra => Promise.resolve({
           TAG: "Ok",
           _0: states(store, extra)
@@ -177,7 +178,7 @@ function Make(Spec) {
             _0: undefined
           });
         }
-      }, Spec.subIdConfig);
+      });
       if (Spec.subIdConfig !== undefined) {
         return Stdlib_Dict.mapValues(store, states => states.toSorted((s1, s2) => Primitive_string.compare(getSubId(s1), getSubId(s2))));
       } else {

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/src/ScanIgnore.res

@@ -0,0 +1,11 @@
+// Single source for the directory names pruned from every monorepo scan — test
+// discovery, component scan, platform scan — and the equivalent chokidar globs
+// for the watch. Previously duplicated verbatim across the three walkers and,
+// divergently, as inline globs in `Watch`; that drift once let `dist/` writes
+// drive a re-run loop.
+let names = ["node_modules", ".git", "dist", "lib", ".history"]
+
+let shouldIgnore = (name: string): bool => names->Array.includes(name)
+
+// chokidar-style globs derived from the same list (the watch's ignore set).
+let globs = names->Array.map(n => "**/" ++ n ++ "/**")

package/src/ScanIgnore.res.mjs

@@ -0,0 +1,23 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let names = [
+  "node_modules",
+  ".git",
+  "dist",
+  "lib",
+  ".history"
+];
+
+function shouldIgnore(name) {
+  return names.includes(name);
+}
+
+let globs = names.map(n => "**/" + n + "/**");
+
+export {
+  names,
+  shouldIgnore,
+  globs,
+}
+/* globs Not a pure module */

package/src/Watch.res

@@ -88,16 +88,10 @@ let start = (roots: array<string>, onChange: (event, string) => unit): watcher =
     roots,
     {
       ignoreInitial: true,
-      // Keep in sync with Discovery's pruned dirs — writes under `dist/` or
+      // Shared with the scanners via `ScanIgnore` — 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/**",
-      ],
+      ignored: ScanIgnore.globs,
     },
   )
   let debounced = debounce(120, onChange)

package/src/Watch.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Chokidar from "chokidar";
+import * as ScanIgnore$ReventlessGwt from "./ScanIgnore.res.mjs";
 
 function isStructuralSource(event, path) {
   if (event === "Unlink") {
@@ -65,13 +66,7 @@ function debounce(wait, fn) {
 function start(roots, onChange) {
   let w = Chokidar.watch(roots, {
     ignoreInitial: true,
-    ignored: [
-      "**/node_modules/**",
-      "**/lib/**",
-      "**/.git/**",
-      "**/dist/**",
-      "**/.history/**"
-    ]
+    ignored: ScanIgnore$ReventlessGwt.globs
   });
   let debounced = debounce(120, onChange);
   return w.on("add", p => debounced("Add", p)).on("change", p => debounced("Change", p)).on("unlink", p => debounced("Unlink", p));

package/tests/ExnMessageTest.res

@@ -0,0 +1,42 @@
+// Pins `ExnMessage.extract` across the value shapes it inspects: ReScript
+// exceptions (matched or reflected via `RE_EXN_ID`/`_1`), thrown JS `Error`s,
+// bare thrown strings, and non-message values. The reflective cases are the
+// reason the extractor exists, so they are asserted explicitly.
+
+open JestGlobals
+
+exception Boom(string)
+exception NoPayload
+
+// Fixtures the type system can't produce as a well-typed `exn`.
+let jsError: exn = %raw(`new Error("kaboom")`)
+let rawString: exn = %raw(`"just a string"`)
+let nullish: exn = %raw(`null`)
+let bareObject: exn = %raw(`({ some: "thing" })`)
+
+describe("ExnMessage.extract", () => {
+  testSync("Failure carries its message (the failwith path)", () =>
+    expect(ExnMessage.extract(Failure("not implemented: X")))->toEqual("not implemented: X")
+  )
+  testSync("empty Failure falls back to the constructor tag", () =>
+    expect(ExnMessage.extract(Failure("")))->toEqual("Failure")
+  )
+  testSync("a custom exception with a string payload yields the payload", () =>
+    expect(ExnMessage.extract(Boom("custom boom")))->toEqual("custom boom")
+  )
+  testSync("a payload-less custom exception yields its constructor tag", () =>
+    expect(ExnMessage.extract(NoPayload))->toEqual("NoPayload")
+  )
+  testSync("a thrown JS Error yields its .message", () =>
+    expect(ExnMessage.extract(jsError))->toEqual("kaboom")
+  )
+  testSync("a bare thrown string is returned as-is", () =>
+    expect(ExnMessage.extract(rawString))->toEqual("just a string")
+  )
+  testSync("a value with no message/RE_EXN_ID falls back", () =>
+    expect(ExnMessage.extract(bareObject))->toEqual("unknown error")
+  )
+  testSync("null-ish falls back", () =>
+    expect(ExnMessage.extract(nullish))->toEqual("unknown error")
+  )
+})

package/tests/ExnMessageTest.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ExnMessage$ReventlessGwt from "../src/ExnMessage.res.mjs";
+
+let Boom = /* @__PURE__ */Primitive_exceptions.create("ExnMessageTest-ReventlessGwt.Boom");
+
+let NoPayload = /* @__PURE__ */Primitive_exceptions.create("ExnMessageTest-ReventlessGwt.NoPayload");
+
+let jsError = (new Error("kaboom"));
+
+let rawString = "just a string";
+
+let nullish = null;
+
+let bareObject = ({ some: "thing" });
+
+globalThis.describe("ExnMessage.extract", () => {
+  globalThis.test("Failure carries its message (the failwith path)", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract({
+      RE_EXN_ID: "Failure",
+      _1: "not implemented: X"
+    })).toEqual("not implemented: X");
+  });
+  globalThis.test("empty Failure falls back to the constructor tag", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract({
+      RE_EXN_ID: "Failure",
+      _1: ""
+    })).toEqual("Failure");
+  });
+  globalThis.test("a custom exception with a string payload yields the payload", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract({
+      RE_EXN_ID: Boom,
+      _1: "custom boom"
+    })).toEqual("custom boom");
+  });
+  globalThis.test("a payload-less custom exception yields its constructor tag", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract({
+      RE_EXN_ID: NoPayload
+    })).toEqual("NoPayload");
+  });
+  globalThis.test("a thrown JS Error yields its .message", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract(jsError)).toEqual("kaboom");
+  });
+  globalThis.test("a bare thrown string is returned as-is", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract(rawString)).toEqual("just a string");
+  });
+  globalThis.test("a value with no message/RE_EXN_ID falls back", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract(bareObject)).toEqual("unknown error");
+  });
+  globalThis.test("null-ish falls back", () => {
+    globalThis.expect(ExnMessage$ReventlessGwt.extract(nullish)).toEqual("unknown error");
+  });
+});
+
+export {
+  Boom,
+  NoPayload,
+  jsError,
+  rawString,
+  nullish,
+  bareObject,
+}
+/* jsError Not a pure module */