@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Delegate_GWT.res.mjs

@@ -0,0 +1,372 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as StubRuntime$ReventlessGwt from "./StubRuntime.res.mjs";
+
+function encPublished(target, payload) {
+  let d = {};
+  d["target"] = target;
+  d["payload"] = payload;
+  return d;
+}
+
+function Make(D) {
+  S.enableJson();
+  let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(D.name, name, timeout, body);
+  let whenInput = ev => D.run(ev);
+  let sortJson = arr => arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
+  let targetOf = j => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["target"]), Stdlib_JSON.Decode.string), "");
+  let dropDirectives = arr => arr.filter(j => targetOf(j) !== "directive");
+  let onlyDirectives = arr => arr.filter(j => targetOf(j) === "directive");
+  let thenPublishedJson = async (actionsP, expected) => {
+    let actual = dropDirectives(await actionsP);
+    if (Primitive_object.equal(sortJson(actual), sortJson(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let thenPublishesNothing = actionsP => thenPublishedJson(actionsP, []);
+  let thenHandlesDirectivesJson = async (actionsP, expected) => {
+    let actual = onlyDirectives(await actionsP);
+    if (Primitive_object.equal(sortJson(actual), sortJson(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  return {
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    whenInput: whenInput,
+    thenPublishedJson: thenPublishedJson,
+    thenPublishesNothing: thenPublishesNothing,
+    thenHandlesDirectivesJson: thenHandlesDirectivesJson
+  };
+}
+
+function FromExtensionPoint(M) {
+  let encEvent = e => Message$ReventlessCore.encode(e, M.ExtensionPoint.eventSchema);
+  let encCommand = c => Message$ReventlessCore.encode(c, M.Delegate.commandSchema);
+  let encDirective = d => encPublished("directive", Message$ReventlessCore.encode(d, M.ExtensionPoint.directiveSchema));
+  let name = M.ExtensionPoint.name;
+  let run = async event => {
+    let f = M.mapOutgoingEvent;
+    if (f !== undefined) {
+      return (await Promise.all(f("gwt-id", event, StubRuntime$ReventlessGwt.meta, StubRuntime$ReventlessGwt.queryEngine).map(async action => {
+        switch (action.TAG) {
+          case "PublishEvent" :
+            return [encPublished(action._0, Message$ReventlessCore.encode(action._1, M.ExtensionPoint.eventSchema))];
+          case "PublishEventAsync" :
+            let match = await action._0;
+            return [encPublished(match[0], Message$ReventlessCore.encode(match[1], M.ExtensionPoint.eventSchema))];
+          case "HandleDirective" :
+            return [encDirective(action._1)];
+        }
+      }))).flat();
+    } else {
+      return [];
+    }
+  };
+  S.enableJson();
+  let test = (name$1, timeout, body) => JestBind$ReventlessGwt.testPromise(name, name$1, timeout, body);
+  let whenInput = run;
+  let sortJson = arr => arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
+  let targetOf = j => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["target"]), Stdlib_JSON.Decode.string), "");
+  let dropDirectives = arr => arr.filter(j => targetOf(j) !== "directive");
+  let onlyDirectives = arr => arr.filter(j => targetOf(j) === "directive");
+  let thenPublishedJson = async (actionsP, expected) => {
+    let actual = dropDirectives(await actionsP);
+    if (Primitive_object.equal(sortJson(actual), sortJson(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let thenPublishesNothing = actionsP => thenPublishedJson(actionsP, []);
+  let thenHandlesDirectivesJson = async (actionsP, expected) => {
+    let actual = onlyDirectives(await actionsP);
+    if (Primitive_object.equal(sortJson(actual), sortJson(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let EvCore = {
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    whenInput: whenInput,
+    thenPublishedJson: thenPublishedJson,
+    thenPublishesNothing: thenPublishesNothing,
+    thenHandlesDirectivesJson: thenHandlesDirectivesJson
+  };
+  let name$1 = M.ExtensionPoint.name;
+  let run$1 = async command => Stdlib_Array.filterMap(M.mapIncomingCommand("gwt-id", command, StubRuntime$ReventlessGwt.meta), action => {
+    if (action.TAG === "PublishCommand") {
+      return encPublished(action._0, Message$ReventlessCore.encode(action._1, M.Delegate.commandSchema));
+    } else {
+      return encDirective(action._1);
+    }
+  });
+  S.enableJson();
+  let test$1 = (name$2, timeout, body) => JestBind$ReventlessGwt.testPromise(name$1, name$2, timeout, body);
+  let whenInput$1 = run$1;
+  let sortJson$1 = arr => arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
+  let targetOf$1 = j => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["target"]), Stdlib_JSON.Decode.string), "");
+  let dropDirectives$1 = arr => arr.filter(j => targetOf$1(j) !== "directive");
+  let onlyDirectives$1 = arr => arr.filter(j => targetOf$1(j) === "directive");
+  let thenPublishedJson$1 = async (actionsP, expected) => {
+    let actual = dropDirectives$1(await actionsP);
+    if (Primitive_object.equal(sortJson$1(actual), sortJson$1(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let thenPublishesNothing$1 = actionsP => thenPublishedJson$1(actionsP, []);
+  let thenHandlesDirectivesJson$1 = async (actionsP, expected) => {
+    let actual = onlyDirectives$1(await actionsP);
+    if (Primitive_object.equal(sortJson$1(actual), sortJson$1(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let CmdCore = {
+    describe: JestBind$ReventlessGwt.describe,
+    test: test$1,
+    whenInput: whenInput$1,
+    thenPublishedJson: thenPublishedJson$1,
+    thenPublishesNothing: thenPublishesNothing$1,
+    thenHandlesDirectivesJson: thenHandlesDirectivesJson$1
+  };
+  let thenPublishesEvent = (actionsP, id, event) => thenPublishedJson(actionsP, [encPublished(id, Message$ReventlessCore.encode(event, M.ExtensionPoint.eventSchema))]);
+  let thenPublishesEvents = (actionsP, pairs) => thenPublishedJson(actionsP, pairs.map(param => encPublished(param[0], Message$ReventlessCore.encode(param[1], M.ExtensionPoint.eventSchema))));
+  let thenPublishesCommand = (actionsP, id, cmd) => thenPublishedJson$1(actionsP, [encPublished(id, Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema))]);
+  let thenPublishesCommands = (actionsP, pairs) => thenPublishedJson$1(actionsP, pairs.map(param => encPublished(param[0], Message$ReventlessCore.encode(param[1], M.Delegate.commandSchema))));
+  let thenHandlesDirective = (actionsP, directive) => thenHandlesDirectivesJson(actionsP, [encDirective(directive)]);
+  let thenHandlesDirectives = (actionsP, directives) => thenHandlesDirectivesJson(actionsP, directives.map(encDirective));
+  let thenHandlesNoDirective = actionsP => thenHandlesDirectivesJson(actionsP, []);
+  return {
+    encEvent: encEvent,
+    encCommand: encCommand,
+    encDirective: encDirective,
+    EvCore: EvCore,
+    CmdCore: CmdCore,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    thenPublishesNothing: thenPublishesNothing,
+    whenDelegateEvent: whenInput,
+    thenPublishesEvent: thenPublishesEvent,
+    thenPublishesEvents: thenPublishesEvents,
+    whenIncomingCommand: whenInput$1,
+    thenPublishesCommand: thenPublishesCommand,
+    thenPublishesCommands: thenPublishesCommands,
+    thenHandlesDirective: thenHandlesDirective,
+    thenHandlesDirectives: thenHandlesDirectives,
+    thenHandlesNoDirective: thenHandlesNoDirective
+  };
+}
+
+function FromExtension(M) {
+  let encCmd = c => Message$ReventlessCore.encode(c, M.Delegate.commandSchema);
+  let encEpCmd = c => Message$ReventlessCore.encode(c, M.ExtensionPoint.commandSchema);
+  let encDirective = d => encPublished("directive", Message$ReventlessCore.encode(d, M.ExtensionPoint.directiveSchema));
+  let name = M.Delegate.name;
+  let run = async event => (await Promise.all(M.mapIncomingEvent("gwt-id", event, StubRuntime$ReventlessGwt.meta, StubRuntime$ReventlessGwt.pluginDefinition, StubRuntime$ReventlessGwt.queryEngine).map(async action => {
+    switch (action.TAG) {
+      case "PublishAggregateCommand" :
+        return [encPublished(action._0, Message$ReventlessCore.encode(action._1, M.Delegate.commandSchema))];
+      case "PublishAggregateCommandAsync" :
+        let match = await action._0;
+        return [encPublished(match[0], Message$ReventlessCore.encode(match[1], M.Delegate.commandSchema))];
+      case "PublishAggregateCommandsAsync" :
+        return (await action._0).map(param => encPublished(param[0], Message$ReventlessCore.encode(param[1], M.Delegate.commandSchema)));
+      case "PublishStateChangeSliceCommand" :
+        return [encPublished(M.Delegate.name, Message$ReventlessCore.encode(action._0, M.Delegate.commandSchema))];
+      case "PublishStateChangeSliceCommandAsync" :
+        let cmd = await action._0;
+        return [encPublished(M.Delegate.name, Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema))];
+      case "PublishStateChangeSliceCommandsAsync" :
+        return (await action._0).map(cmd => encPublished(M.Delegate.name, Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema)));
+      case "PublishExtensionPointCommand" :
+        return [encPublished(action._0, Message$ReventlessCore.encode(action._1, M.ExtensionPoint.commandSchema))];
+      case "ForwardCommand" :
+        let match$1 = action._0;
+        return [encPublished(match$1.extensionPointName + `:` + match$1.id, match$1.commandJson)];
+      case "HandleDirective" :
+        return [encDirective(action._1)];
+    }
+  }))).flat();
+  S.enableJson();
+  let test = (name$1, timeout, body) => JestBind$ReventlessGwt.testPromise(name, name$1, timeout, body);
+  let whenInput = run;
+  let sortJson = arr => arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
+  let targetOf = j => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["target"]), Stdlib_JSON.Decode.string), "");
+  let dropDirectives = arr => arr.filter(j => targetOf(j) !== "directive");
+  let onlyDirectives = arr => arr.filter(j => targetOf(j) === "directive");
+  let thenPublishedJson = async (actionsP, expected) => {
+    let actual = dropDirectives(await actionsP);
+    if (Primitive_object.equal(sortJson(actual), sortJson(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let thenPublishesNothing = actionsP => thenPublishedJson(actionsP, []);
+  let thenHandlesDirectivesJson = async (actionsP, expected) => {
+    let actual = onlyDirectives(await actionsP);
+    if (Primitive_object.equal(sortJson(actual), sortJson(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let EvCore = {
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    whenInput: whenInput,
+    thenPublishedJson: thenPublishedJson,
+    thenPublishesNothing: thenPublishesNothing,
+    thenHandlesDirectivesJson: thenHandlesDirectivesJson
+  };
+  let name$1 = M.Delegate.name;
+  let run$1 = async event => {
+    let f = M.mapOutgoingEvent;
+    if (f !== undefined) {
+      return Stdlib_Array.filterMap(f("gwt-id", event, StubRuntime$ReventlessGwt.meta, StubRuntime$ReventlessGwt.pluginDefinition), action => {
+        switch (action.TAG) {
+          case "PublishExtensionPointCommand" :
+            return encPublished(action._0, Message$ReventlessCore.encode(action._1, M.ExtensionPoint.commandSchema));
+          case "ForwardCommand" :
+            let match = action._0;
+            return encPublished(match.extensionPointName + `:` + match.id, match.commandJson);
+          case "HandleDirective" :
+            return encDirective(action._1);
+        }
+      });
+    } else {
+      return [];
+    }
+  };
+  S.enableJson();
+  let test$1 = (name$2, timeout, body) => JestBind$ReventlessGwt.testPromise(name$1, name$2, timeout, body);
+  let whenInput$1 = run$1;
+  let sortJson$1 = arr => arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
+  let targetOf$1 = j => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["target"]), Stdlib_JSON.Decode.string), "");
+  let dropDirectives$1 = arr => arr.filter(j => targetOf$1(j) !== "directive");
+  let onlyDirectives$1 = arr => arr.filter(j => targetOf$1(j) === "directive");
+  let thenPublishedJson$1 = async (actionsP, expected) => {
+    let actual = dropDirectives$1(await actionsP);
+    if (Primitive_object.equal(sortJson$1(actual), sortJson$1(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let thenPublishesNothing$1 = actionsP => thenPublishedJson$1(actionsP, []);
+  let thenHandlesDirectivesJson$1 = async (actionsP, expected) => {
+    let actual = onlyDirectives$1(await actionsP);
+    if (Primitive_object.equal(sortJson$1(actual), sortJson$1(expected))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expected,
+        actual: actual
+      });
+    }
+  };
+  let OutCore = {
+    describe: JestBind$ReventlessGwt.describe,
+    test: test$1,
+    whenInput: whenInput$1,
+    thenPublishedJson: thenPublishedJson$1,
+    thenPublishesNothing: thenPublishesNothing$1,
+    thenHandlesDirectivesJson: thenHandlesDirectivesJson$1
+  };
+  let thenPublishesCommand = (actionsP, cmd) => thenPublishedJson(actionsP, [encPublished(M.Delegate.name, Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema))]);
+  let thenPublishesCommands = (actionsP, cmds) => thenPublishedJson(actionsP, cmds.map(cmd => encPublished(M.Delegate.name, Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema))));
+  let thenPublishesAggregateCommand = (actionsP, id, cmd) => thenPublishedJson(actionsP, [encPublished(id, Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema))]);
+  let thenPublishesExtensionPointCommand = (actionsP, id, cmd) => thenPublishedJson$1(actionsP, [encPublished(id, Message$ReventlessCore.encode(cmd, M.ExtensionPoint.commandSchema))]);
+  let thenHandlesDirective = (actionsP, directive) => thenHandlesDirectivesJson(actionsP, [encDirective(directive)]);
+  let thenHandlesDirectives = (actionsP, directives) => thenHandlesDirectivesJson(actionsP, directives.map(encDirective));
+  let thenHandlesNoDirective = actionsP => thenHandlesDirectivesJson(actionsP, []);
+  return {
+    encCmd: encCmd,
+    encEpCmd: encEpCmd,
+    encDirective: encDirective,
+    EvCore: EvCore,
+    OutCore: OutCore,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    thenPublishesNothing: thenPublishesNothing,
+    whenIncomingEvent: whenInput,
+    thenPublishesCommand: thenPublishesCommand,
+    thenPublishesCommands: thenPublishesCommands,
+    thenPublishesAggregateCommand: thenPublishesAggregateCommand,
+    whenDelegateEvent: whenInput$1,
+    thenPublishesExtensionPointCommand: thenPublishesExtensionPointCommand,
+    thenHandlesDirective: thenHandlesDirective,
+    thenHandlesDirectives: thenHandlesDirectives,
+    thenHandlesNoDirective: thenHandlesNoDirective
+  };
+}
+
+let EPMapping;
+
+let ExtMapping;
+
+export {
+  EPMapping,
+  ExtMapping,
+  encPublished,
+  Make,
+  FromExtensionPoint,
+  FromExtension,
+}
+/* S Not a pure module */

package/src/Diff.res

@@ -0,0 +1,91 @@
+// Produces a structural `fieldDiff` for the JSON format (§3.3) and TAP
+// emitters. Walks two JSON values and returns a list of differing leaves
+// as `{path, expected, actual}` entries. Rendered values use
+// `RenderRescript.render` so diff rows read as ReScript, not JSON.
+
+type entry = {
+  path: string,
+  expected: string,
+  actual: string,
+}
+
+let joinPath = (prefix, segment) =>
+  if prefix == "" {
+    segment
+  } else {
+    prefix ++ "." ++ segment
+  }
+
+let rec walk = (~path="", expected: JSON.t, actual: JSON.t, acc: array<entry>) =>
+  switch (expected, actual) {
+  | (Object(e), Object(a)) =>
+    let keys =
+      Array.concat(e->Dict.keysToArray, a->Dict.keysToArray)
+      ->Array.reduce([], (uniq, k) =>
+        if Array.includes(uniq, k) {
+          uniq
+        } else {
+          Array.concat(uniq, [k])
+        }
+      )
+    keys->Array.reduce(acc, (acc, k) => {
+      let childExpected =
+        e->Dict.get(k)->Option.getOr(JSON.Encode.null)
+      let childActual =
+        a->Dict.get(k)->Option.getOr(JSON.Encode.null)
+      walk(~path=joinPath(path, k), childExpected, childActual, acc)
+    })
+  | (Array(e), Array(a)) =>
+    let lenE = e->Array.length
+    let lenA = a->Array.length
+    let len = lenE > lenA ? lenE : lenA
+    let rec loop = (i, acc) =>
+      if i >= len {
+        acc
+      } else {
+        let childExpected =
+          e->Array.get(i)->Option.getOr(JSON.Encode.null)
+        let childActual =
+          a->Array.get(i)->Option.getOr(JSON.Encode.null)
+        let acc = walk(
+          ~path=joinPath(path, Int.toString(i)),
+          childExpected,
+          childActual,
+          acc,
+        )
+        loop(i + 1, acc)
+      }
+    loop(0, acc)
+  | _ =>
+    if expected == actual {
+      acc
+    } else {
+      Array.concat(
+        acc,
+        [
+          {
+            path,
+            expected: RenderRescript.render(expected),
+            actual: RenderRescript.render(actual),
+          },
+        ],
+      )
+    }
+  }
+
+let diff = (expected: JSON.t, actual: JSON.t): array<entry> =>
+  walk(expected, actual, [])
+
+let diffArrays = (expected: array<JSON.t>, actual: array<JSON.t>): array<entry> =>
+  walk(JSON.Encode.array(expected), JSON.Encode.array(actual), [])
+
+let toJson = (e: entry): JSON.t => {
+  let obj = Dict.make()
+  obj->Dict.set("path", JSON.Encode.string(e.path))
+  obj->Dict.set("expected", JSON.Encode.string(e.expected))
+  obj->Dict.set("actual", JSON.Encode.string(e.actual))
+  JSON.Encode.object(obj)
+}
+
+let toJsonArray = (entries: array<entry>): JSON.t =>
+  entries->Array.map(toJson)->JSON.Encode.array

package/src/Diff.res.mjs

@@ -0,0 +1,98 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+function joinPath(prefix, segment) {
+  if (prefix === "") {
+    return segment;
+  } else {
+    return prefix + "." + segment;
+  }
+}
+
+function walk(pathOpt, expected, actual, acc) {
+  let path = pathOpt !== undefined ? pathOpt : "";
+  if (Array.isArray(expected)) {
+    if (Array.isArray(actual)) {
+      let lenE = expected.length;
+      let lenA = actual.length;
+      let len = lenE > lenA ? lenE : lenA;
+      let _i = 0;
+      let _acc = acc;
+      while (true) {
+        let acc$1 = _acc;
+        let i = _i;
+        if (i >= len) {
+          return acc$1;
+        }
+        let childExpected = Stdlib_Option.getOr(expected[i], null);
+        let childActual = Stdlib_Option.getOr(actual[i], null);
+        let acc$2 = walk(joinPath(path, i.toString()), childExpected, childActual, acc$1);
+        _acc = acc$2;
+        _i = i + 1 | 0;
+        continue;
+      };
+    }
+  } else if (expected !== null) {
+    switch (typeof expected) {
+      case "object" :
+        if (typeof actual === "object" && actual !== null && !Array.isArray(actual)) {
+          let keys = Stdlib_Array.reduce(Object.keys(expected).concat(Object.keys(actual)), [], (uniq, k) => {
+            if (uniq.includes(k)) {
+              return uniq;
+            } else {
+              return uniq.concat([k]);
+            }
+          });
+          return Stdlib_Array.reduce(keys, acc, (acc, k) => {
+            let childExpected = Stdlib_Option.getOr(expected[k], null);
+            let childActual = Stdlib_Option.getOr(actual[k], null);
+            return walk(joinPath(path, k), childExpected, childActual, acc);
+          });
+        }
+        break;
+    }
+  }
+  if (Primitive_object.equal(expected, actual)) {
+    return acc;
+  } else {
+    return acc.concat([{
+        path: path,
+        expected: RenderRescript$ReventlessGwt.render(undefined, expected),
+        actual: RenderRescript$ReventlessGwt.render(undefined, actual)
+      }]);
+  }
+}
+
+function diff(expected, actual) {
+  return walk(undefined, expected, actual, []);
+}
+
+function diffArrays(expected, actual) {
+  return walk(undefined, expected, actual, []);
+}
+
+function toJson(e) {
+  let obj = {};
+  obj["path"] = e.path;
+  obj["expected"] = e.expected;
+  obj["actual"] = e.actual;
+  return obj;
+}
+
+function toJsonArray(entries) {
+  return entries.map(toJson);
+}
+
+export {
+  joinPath,
+  walk,
+  diff,
+  diffArrays,
+  toJson,
+  toJsonArray,
+}
+/* No side effect */

package/src/Discovery.res

@@ -0,0 +1,105 @@
+// Walks a directory tree and returns absolute paths of compiled GWT test
+// files (`*_GWT.res.mjs` plus `*GwtTest.res.mjs` — the two shapes used in
+// the monorepo today). Respects a minimal ignore set (`node_modules`,
+// `lib`, `.git`, `dist`, `.history`). Pruning `lib` covers compiled
+// `lib/bs` / `lib/ocaml` outputs. Full `.gitignore` parsing is out of scope;
+// the ignore set is enough to make a bare cwd scan (the auto-discovery
+// default) cheap and correct across a multi-package workspace.
+
+type dirent = {
+  name: string,
+  @as("isDirectory") _isDirectory: unit => bool,
+  @as("isFile") _isFile: unit => bool,
+}
+
+type readdirOpts = {withFileTypes: bool}
+
+@module("node:fs/promises")
+external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
+
+type stats = {
+  @as("isDirectory") _isDirectory: unit => bool,
+  @as("isFile") _isFile: unit => bool,
+}
+
+@module("node:fs/promises") external _stat: string => promise<stats> = "stat"
+
+@module("node:path") external join: (string, string) => string = "join"
+@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
+// 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"
+let isPruned = (entries: array<dirent>) => entries->Array.some(e => e.name == gwtIgnoreFile)
+
+let isGwtTestFile = (name: string) =>
+  String.endsWith(name, "_GWT.res.mjs") ||
+  String.endsWith(name, "GwtTest.res.mjs") ||
+  String.endsWith(name, "Gwt.res.mjs")
+
+// Depth-first, pushing into a shared accumulator instead of rebuilding it with
+// `Array.concat` per entry (which was O(n²) over a large tree). The traversal
+// order is unchanged: files and nested subtree results still land in on-disk
+// entry order.
+let rec walk = async (dir: string, acc: array<string>): unit => {
+  let entries = try {
+    await _readdir(dir, {withFileTypes: true})
+  } catch {
+  | _ => []
+  }
+  if isPruned(entries) {
+    ()
+  } else {
+    for i in 0 to entries->Array.length - 1 {
+      let entry = entries->Array.getUnsafe(i)
+      if !shouldIgnore(entry.name) {
+        let full = join(dir, entry.name)
+        if entry._isDirectory() {
+          await walk(full, acc)
+        } else if entry._isFile() && isGwtTestFile(entry.name) {
+          acc->Array.push(full)
+        }
+      }
+    }
+  }
+}
+
+// Returns absolute paths of `*GWT*.res.mjs` test files reachable from the
+// supplied roots. A root may be a directory or a single file.
+let discover = async (roots: array<string>): array<string> => {
+  let found = []
+  for i in 0 to roots->Array.length - 1 {
+    let root = roots->Array.getUnsafe(i)
+    let absolute = isAbsolute(root) ? root : resolve(root)
+    let isDir = try {
+      let s = await _stat(absolute)
+      s._isDirectory()
+    } catch {
+    | _ => false
+    }
+    if isDir {
+      await walk(absolute, found)
+    } else if isGwtTestFile(absolute) {
+      found->Array.push(absolute)
+    }
+  }
+  // Deduplicate (if roots overlap).
+  let seen = Dict.make()
+  let unique = []
+  found->Array.forEach(path =>
+    switch seen->Dict.get(path) {
+    | Some(_) => ()
+    | None => {
+        seen->Dict.set(path, true)
+        unique->Array.push(path)
+      }
+    }
+  )
+  unique
+}