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

package/src/FormatterTap.res.mjs

@@ -2,8 +2,7 @@
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Hint$ReventlessGwt from "./Hint.res.mjs";
-import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
-import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+import * as MismatchRender$ReventlessGwt from "./MismatchRender.res.mjs";
 
 function write(s) {
   process.stdout.write(s);
@@ -27,47 +26,30 @@ function yamlLine(indentOpt, key, value) {
 }
 
 function renderMismatchYaml(m) {
-  let lines = [];
-  lines.push(yamlLine(undefined, "kind", yamlString(Outcome$ReventlessGwt.kindName(m))));
-  switch (m.TAG) {
-    case "ErrorMismatch" :
-      let actual = m.actual;
-      lines.push(yamlLine(undefined, "expected", yamlString("Error(" + RenderRescript$ReventlessGwt.render(undefined, m.expected) + ")")));
-      let actualStr = actual !== undefined ? "Error(" + RenderRescript$ReventlessGwt.render(undefined, actual) + ")" : "Ok(" + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + ")";
-      lines.push(yamlLine(undefined, "actual", yamlString(actualStr)));
-      break;
-    case "StateMismatch" :
-      lines.push(yamlLine(undefined, "key", yamlString(m.key)));
-      lines.push(yamlLine(undefined, "expected", yamlString(RenderRescript$ReventlessGwt.renderOption(m.expected))));
-      lines.push(yamlLine(undefined, "actual", yamlString(RenderRescript$ReventlessGwt.renderOption(m.actual))));
-      break;
-    case "NoEventExpected" :
-      lines.push(yamlLine(undefined, "actual", yamlString(RenderRescript$ReventlessGwt.renderMany(m.actual))));
-      break;
-    case "TodoMismatch" :
-      let fmt = arr => arr.map(param => "(" + param[0] + ", " + RenderRescript$ReventlessGwt.render(undefined, param[1]) + ")").join(", ");
-      lines.push(yamlLine(undefined, "expected", yamlString("[" + fmt(m.expected) + "]")));
-      lines.push(yamlLine(undefined, "actual", yamlString("[" + fmt(m.actual) + "]")));
-      break;
-    case "AppendConditionMismatch" :
-      lines.push(yamlLine(undefined, "expected", yamlString(RenderRescript$ReventlessGwt.render(undefined, m.expected))));
-      lines.push(yamlLine(undefined, "actual", yamlString(RenderRescript$ReventlessGwt.render(undefined, m.actual))));
-      break;
-    case "TranslateError" :
-      lines.push(yamlLine(undefined, "expected", yamlString(m.expected)));
-      lines.push(yamlLine(undefined, "actual", yamlString(Stdlib_Option.getOr(m.actual, "(none)"))));
-      break;
-    case "EventsMismatch" :
-    case "QueryRowsMismatch" :
-    case "PublishedActionsMismatch" :
-      lines.push(yamlLine(undefined, "expected", yamlString(RenderRescript$ReventlessGwt.renderMany(m.expected))));
-      lines.push(yamlLine(undefined, "actual", yamlString(RenderRescript$ReventlessGwt.renderMany(m.actual))));
-      break;
-    case "Throw" :
-      lines.push(yamlLine(undefined, "error", yamlString(m.error)));
-      lines.push(yamlLine(undefined, "stack", yamlString(m.stack)));
-      break;
-  }
+  let n = MismatchRender$ReventlessGwt.normalize(m);
+  let lines = [yamlLine(undefined, "kind", yamlString(n.kind))];
+  n.fields.forEach(f => {
+    if (typeof f !== "object") {
+      return;
+    }
+    switch (f.TAG) {
+      case "Expected" :
+        lines.push(yamlLine(undefined, "expected", yamlString(f._0)));
+        return;
+      case "Actual" :
+        lines.push(yamlLine(undefined, "actual", yamlString(f._0)));
+        return;
+      case "Key" :
+        lines.push(yamlLine(undefined, "key", yamlString(f._0)));
+        return;
+      case "Error" :
+        lines.push(yamlLine(undefined, "error", yamlString(f._0)));
+        return;
+      case "Stack" :
+        lines.push(yamlLine(undefined, "stack", yamlString(f._0)));
+        return;
+    }
+  });
   return lines.join("\n");
 }
 

package/src/FormatterVsCode.res

@@ -45,12 +45,6 @@ let relativeToCwd = (abs: string) => pathRelative(processCwd(), abs)
 
 let sourceLineCache: Dict.t<option<array<string>>> = Dict.make()
 
-let resetLocateCache = () => {
-  sourceLineCache
-  ->Dict.keysToArray
-  ->Array.forEach(k => Dict.delete(sourceLineCache, k))
-}
-
 let mjsToRes = (mjsPath: string): option<string> =>
   if String.endsWith(mjsPath, ".res.mjs") {
     Some(String.slice(mjsPath, ~start=0, ~end=String.length(mjsPath) - 4))
@@ -253,18 +247,9 @@ let deadCode = (findings: array<DomainDeadCode.finding>) =>
 
 // Event-Modeling graph (Phase 6) — the node/edge model assembled from each plugin's
 // `pluginStructure` + cross-plugin edges.
-let graph = (g: DomainGraph.graph) =>
-  emit(
-    Graph({
-      nodes: g.nodes->Array.map((n): P.graphNode => {
-        id: n.id,
-        kind: n.kind,
-        label: n.label,
-        plugin: n.plugin,
-      }),
-      edges: g.edges->Array.map((e): P.graphEdge => {from: e.from, to_: e.to, kind: e.kind, label: ?e.label}),
-    }),
-  )
+// `DomainGraph` already builds `P.graphNode`/`P.graphEdge`, so the graph event
+// forwards them directly — no field-by-field re-map to drift from the contract.
+let graph = (g: DomainGraph.graph) => emit(Graph({nodes: g.nodes, edges: g.edges}))
 
 // Component definitions (Phase 6.3) — one `encodePluginStructureEntry` JSON object
 // per plugin (commands/events with field schemas, read-side state schemas), used by
@@ -292,7 +277,7 @@ let domainEvent = (payload: JSON.t) => writeLine(JSON.stringify(payload))
 
 let platformLog = (~line: string) => emit(PlatformLog({line: line}))
 
-let platformStop = (~code: option<int>) => emit(PlatformStop({code: code}))
+let platformStop = (~code: option<int>) => emit(PlatformStop({code: ?code}))
 
 let runStart = (~total: int, ~filter: array<string>) => emit(RunStart({total, filter}))
 

package/src/FormatterVsCode.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Hint$ReventlessGwt from "./Hint.res.mjs";
@@ -43,10 +42,6 @@ function relativeToCwd(abs) {
 
 let sourceLineCache = {};
 
-function resetLocateCache() {
-  Object.keys(sourceLineCache).forEach(k => Stdlib_Dict.$$delete(sourceLineCache, k));
-}
-
 function mjsToRes(mjsPath) {
   if (mjsPath.endsWith(".res.mjs")) {
     return mjsPath.slice(0, mjsPath.length - 4 | 0);
@@ -282,24 +277,11 @@ function deadCode(findings) {
 }
 
 function graph(g) {
-  let e_0 = g.nodes.map(n => ({
-    id: n.id,
-    kind: n.kind,
-    label: n.label,
-    plugin: n.plugin
-  }));
-  let e_1 = g.edges.map(e => ({
-    from: e.from,
-    to: e.to,
-    kind: e.kind,
-    label: e.label
-  }));
-  let e = {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
     event: "graph",
-    nodes: e_0,
-    edges: e_1
-  };
-  let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+    nodes: g.nodes,
+    edges: g.edges
+  });
   process.stdout.write(s + "\n");
 }
 
@@ -527,7 +509,6 @@ export {
   fileLabelOf,
   relativeToCwd,
   sourceLineCache,
-  resetLocateCache,
   mjsToRes,
   readLinesCached,
   escapeForDouble,

package/src/LocalHost.res

@@ -55,23 +55,11 @@ type pluginExports = {"Make": platform => builtPlugin}
 //    plugin keys match the names the framework itself bakes into Plugin.res. ──
 
 // "@scope/my-catalog" → "MyCatalog", "online-shop" → "OnlineShop".
-let packageNameToPluginName = (packageName: string): string => {
-  let base = switch packageName->String.split("/") {
-  | [_scope, local] => local
-  | [local] => local
-  | parts => parts->Array.getUnsafe(parts->Array.length - 1)
-  }
-  base
-  ->String.split("-")
-  ->Array.flatMap(part => part->String.split("_"))
-  ->Array.map(word =>
-    word === ""
-      ? ""
-      : word->String.slice(~start=0, ~end=1)->String.toUpperCase ++
-          word->String.slice(~start=1, ~end=word->String.length)
-  )
-  ->Array.join("")
-}
+// Single-sourced with the plugin generator (spec's `Config`) via
+// `Reventless.PluginName` so the two can't drift — a drift silently breaks
+// graph plugin keys (see the module for the full rationale). Re-exported here
+// under the historical name the tests already pin.
+let packageNameToPluginName = Reventless.PluginName.fromPackageName
 
 let strField = (json, key) =>
   json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
@@ -82,19 +70,15 @@ let readJson = path =>
   }
 
 // plugin.json `name` → else PascalCase(package.json `name`) → else "Plugin".
+// The precedence itself lives in `Reventless.PluginName.resolve`; this only
+// reads the two raw fields with the local node bindings.
 let derivePluginName = (~pluginSrcDir: string): string => {
   let pluginJson = join(pluginSrcDir, "plugin.json")
-  let fromPluginJson =
+  let pluginJsonName =
     existsSync(pluginJson) ? readJson(pluginJson)->Option.flatMap(j => strField(j, "name")) : None
-  switch fromPluginJson {
-  | Some(name) => name
-  | None =>
-    let pkgJson = join(dirname(pluginSrcDir), "package.json")
-    readJson(pkgJson)
-    ->Option.flatMap(j => strField(j, "name"))
-    ->Option.map(packageNameToPluginName)
-    ->Option.getOr("Plugin")
-  }
+  let packageJsonName =
+    readJson(join(dirname(pluginSrcDir), "package.json"))->Option.flatMap(j => strField(j, "name"))
+  Reventless.PluginName.resolve(~pluginJsonName, ~packageJsonName)
 }
 
 // Given workspace package dirs (e.g. from PackageScan), keep those that carry a

package/src/LocalHost.res.mjs

@@ -7,6 +7,7 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Nodemodule from "node:module";
 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 PluginName$Reventless from "@reventlessdev/reventless-spec/src/components/PluginName.res.mjs";
 
 let dynamicImport = ((u) => import(u));
 
@@ -19,34 +20,6 @@ function bustedUrl(absolutePath) {
   return Nodeurl.pathToFileURL(absolutePath).href + "?t=" + counter.contents.toString();
 }
 
-function packageNameToPluginName(packageName) {
-  let parts = packageName.split("/");
-  let len = parts.length;
-  let base;
-  if (len >= 3) {
-    base = parts[parts.length - 1 | 0];
-  } else {
-    switch (len) {
-      case 0 :
-        base = parts[parts.length - 1 | 0];
-        break;
-      case 1 :
-        base = parts[0];
-        break;
-      case 2 :
-        base = parts[1];
-        break;
-    }
-  }
-  return base.split("-").flatMap(part => part.split("_")).map(word => {
-    if (word === "") {
-      return "";
-    } else {
-      return word.slice(0, 1).toUpperCase() + word.slice(1, word.length);
-    }
-  }).join("");
-}
-
 function strField(json, key) {
   return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.string);
 }
@@ -61,12 +34,9 @@ function readJson(path) {
 
 function derivePluginName(pluginSrcDir) {
   let pluginJson = Nodepath.join(pluginSrcDir, "plugin.json");
-  let fromPluginJson = Nodefs.existsSync(pluginJson) ? Stdlib_Option.flatMap(readJson(pluginJson), j => strField(j, "name")) : undefined;
-  if (fromPluginJson !== undefined) {
-    return fromPluginJson;
-  }
-  let pkgJson = Nodepath.join(Nodepath.dirname(pluginSrcDir), "package.json");
-  return Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(readJson(pkgJson), j => strField(j, "name")), packageNameToPluginName), "Plugin");
+  let pluginJsonName = Nodefs.existsSync(pluginJson) ? Stdlib_Option.flatMap(readJson(pluginJson), j => strField(j, "name")) : undefined;
+  let packageJsonName = Stdlib_Option.flatMap(readJson(Nodepath.join(Nodepath.dirname(pluginSrcDir), "package.json")), j => strField(j, "name"));
+  return PluginName$Reventless.resolve(pluginJsonName, packageJsonName);
 }
 
 function discover(packageDirs) {
@@ -111,6 +81,8 @@ async function loadGraph(platformModulePath, plugins) {
   };
 }
 
+let packageNameToPluginName = PluginName$Reventless.fromPackageName;
+
 export {
   dynamicImport,
   counter,

package/src/MismatchRender.res

@@ -0,0 +1,72 @@
+// Single source for rendering an `Outcome.mismatch`'s expected/actual/extras
+// into RenderRescript strings. The Human and TAP formatters previously each held
+// a full 10-arm switch over the mismatch that computed *identical* rendered
+// values (`RenderRescript.render*`, the `Error()`/`Ok()` wrapping, the Todo
+// `(id, value)` pairs) and differed only in framing — aligned `label: value`
+// lines vs YAML `key: "escaped"` lines. This normalizes the value-rendering once;
+// each formatter interprets the `field` list with its own framing.
+//
+// NOT used by JUnit (renders via the older JSON-based `Outcome.format`) nor
+// FormatterJson/VsCode (they consume the raw JSON values to build a structured
+// `{type, payload, rendered}` + `fieldDiff` payload).
+
+// One rendered piece of a mismatch. The constructor carries the *already
+// rendered* string (unescaped — Human uses it raw, TAP yaml-escapes it), except
+// the structural markers `ExpectedNoEvents` (Human prints a literal line; TAP
+// omits it) and `Stack` (Human appends it raw; TAP labels it as a yaml field).
+type field =
+  | Expected(string)
+  | Actual(string)
+  | Key(string)
+  | ExpectedNoEvents
+  | Error(string)
+  | Stack(string)
+
+type normalized = {
+  kind: string,
+  fields: array<field>,
+}
+
+let render = RenderRescript.render
+let renderMany = RenderRescript.renderMany
+let renderOption = RenderRescript.renderOption
+
+let normalize = (m: Outcome.mismatch): normalized => {
+  let fields = switch m {
+  | EventsMismatch({expected, actual}) => [Expected(renderMany(expected)), Actual(renderMany(actual))]
+  | ErrorMismatch({expected, actual, actualEvents}) => [
+      Expected(`Error(${render(expected)})`),
+      Actual(
+        switch actual {
+        | Some(v) => `Error(${render(v)})`
+        | None => `Ok(${renderMany(actualEvents)})`
+        },
+      ),
+    ]
+  | StateMismatch({key, expected, actual}) => [
+      Key(key),
+      Expected(renderOption(expected)),
+      Actual(renderOption(actual)),
+    ]
+  | NoEventExpected({actual}) => [ExpectedNoEvents, Actual(renderMany(actual))]
+  | TodoMismatch({expected, actual}) =>
+    let fmt = (arr: array<(string, JSON.t)>) =>
+      "[" ++ arr->Array.map(((id, v)) => `(${id}, ${render(v)})`)->Array.join(", ") ++ "]"
+    [Expected(fmt(expected)), Actual(fmt(actual))]
+  | AppendConditionMismatch({expected, actual}) => [
+      Expected(render(expected)),
+      Actual(render(actual)),
+    ]
+  | TranslateError({expected, actual}) => [
+      Expected(expected),
+      Actual(actual->Option.getOr("(none)")),
+    ]
+  | QueryRowsMismatch({expected, actual}) => [Expected(renderMany(expected)), Actual(renderMany(actual))]
+  | PublishedActionsMismatch({expected, actual}) => [
+      Expected(renderMany(expected)),
+      Actual(renderMany(actual)),
+    ]
+  | Throw({error, stack}) => [Error(error), Stack(stack)]
+  }
+  {kind: Outcome.kindName(m), fields}
+}

package/src/MismatchRender.res.mjs

@@ -0,0 +1,127 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+function normalize(m) {
+  let fields;
+  switch (m.TAG) {
+    case "ErrorMismatch" :
+      let actual = m.actual;
+      fields = [
+        {
+          TAG: "Expected",
+          _0: `Error(` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `)`
+        },
+        {
+          TAG: "Actual",
+          _0: actual !== undefined ? `Error(` + RenderRescript$ReventlessGwt.render(undefined, actual) + `)` : `Ok(` + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + `)`
+        }
+      ];
+      break;
+    case "StateMismatch" :
+      fields = [
+        {
+          TAG: "Key",
+          _0: m.key
+        },
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.renderOption(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderOption(m.actual)
+        }
+      ];
+      break;
+    case "NoEventExpected" :
+      fields = [
+        "ExpectedNoEvents",
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.actual)
+        }
+      ];
+      break;
+    case "TodoMismatch" :
+      let fmt = arr => "[" + arr.map(param => `(` + param[0] + `, ` + RenderRescript$ReventlessGwt.render(undefined, param[1]) + `)`).join(", ") + "]";
+      fields = [
+        {
+          TAG: "Expected",
+          _0: fmt(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: fmt(m.actual)
+        }
+      ];
+      break;
+    case "AppendConditionMismatch" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.render(undefined, m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.render(undefined, m.actual)
+        }
+      ];
+      break;
+    case "TranslateError" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: m.expected
+        },
+        {
+          TAG: "Actual",
+          _0: Stdlib_Option.getOr(m.actual, "(none)")
+        }
+      ];
+      break;
+    case "Throw" :
+      fields = [
+        {
+          TAG: "Error",
+          _0: m.error
+        },
+        {
+          TAG: "Stack",
+          _0: m.stack
+        }
+      ];
+      break;
+    default:
+      fields = [
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.actual)
+        }
+      ];
+  }
+  return {
+    kind: Outcome$ReventlessGwt.kindName(m),
+    fields: fields
+  };
+}
+
+let render = RenderRescript$ReventlessGwt.render;
+
+let renderMany = RenderRescript$ReventlessGwt.renderMany;
+
+let renderOption = RenderRescript$ReventlessGwt.renderOption;
+
+export {
+  render,
+  renderMany,
+  renderOption,
+  normalize,
+}
+/* No side effect */

package/src/Outcome.res

@@ -95,67 +95,3 @@ let format = (m: mismatch) =>
       )}`
   | Throw({error, stack}) => `Throw: ${error}\n${stack}`
   }
-
-// Structured JSON payload per §3.3 of the analysis.
-// Closed schema — consumers switch on the `kind` discriminator.
-// Stage 7 enriches with `rendered` strings and `fieldDiff`.
-let toJson = (m: mismatch): JSON.t => {
-  let obj = Dict.make()
-  obj->Dict.set("kind", JSON.Encode.string(kindName(m)))
-  let jsonArr = arr => JSON.Encode.array(arr)
-  let optJson = o => o->Option.getOr(JSON.Encode.null)
-  switch m {
-  | EventsMismatch({expected, actual}) => {
-      obj->Dict.set("expected", jsonArr(expected))
-      obj->Dict.set("actual", jsonArr(actual))
-    }
-  | ErrorMismatch({expected, actual, actualEvents}) => {
-      obj->Dict.set("expected", expected)
-      obj->Dict.set("actual", optJson(actual))
-      obj->Dict.set("actualEvents", jsonArr(actualEvents))
-    }
-  | StateMismatch({key, expected, actual}) => {
-      obj->Dict.set("key", JSON.Encode.string(key))
-      obj->Dict.set("expected", optJson(expected))
-      obj->Dict.set("actual", optJson(actual))
-    }
-  | NoEventExpected({actual}) => obj->Dict.set("actual", jsonArr(actual))
-  | TodoMismatch({expected, actual}) => {
-      let pairArr = pairs =>
-        pairs
-        ->Array.map(((id, v)) => {
-          let d = Dict.make()
-          d->Dict.set("id", JSON.Encode.string(id))
-          d->Dict.set("value", v)
-          JSON.Encode.object(d)
-        })
-        ->jsonArr
-      obj->Dict.set("expected", pairArr(expected))
-      obj->Dict.set("actual", pairArr(actual))
-    }
-  | AppendConditionMismatch({expected, actual}) => {
-      obj->Dict.set("expected", expected)
-      obj->Dict.set("actual", actual)
-    }
-  | TranslateError({expected, actual}) => {
-      obj->Dict.set("expected", JSON.Encode.string(expected))
-      obj->Dict.set(
-        "actual",
-        actual->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
-      )
-    }
-  | QueryRowsMismatch({expected, actual}) => {
-      obj->Dict.set("expected", jsonArr(expected))
-      obj->Dict.set("actual", jsonArr(actual))
-    }
-  | PublishedActionsMismatch({expected, actual}) => {
-      obj->Dict.set("expected", jsonArr(expected))
-      obj->Dict.set("actual", jsonArr(actual))
-    }
-  | Throw({error, stack}) => {
-      obj->Dict.set("error", JSON.Encode.string(error))
-      obj->Dict.set("stack", JSON.Encode.string(stack))
-    }
-  }
-  JSON.Encode.object(obj)
-}

package/src/Outcome.res.mjs

@@ -76,52 +76,6 @@ function format(m) {
   }
 }
 
-function toJson(m) {
-  let obj = {};
-  obj["kind"] = kindName(m);
-  switch (m.TAG) {
-    case "ErrorMismatch" :
-      obj["expected"] = m.expected;
-      obj["actual"] = Stdlib_Option.getOr(m.actual, null);
-      obj["actualEvents"] = m.actualEvents;
-      break;
-    case "StateMismatch" :
-      obj["key"] = m.key;
-      obj["expected"] = Stdlib_Option.getOr(m.expected, null);
-      obj["actual"] = Stdlib_Option.getOr(m.actual, null);
-      break;
-    case "NoEventExpected" :
-      obj["actual"] = m.actual;
-      break;
-    case "TodoMismatch" :
-      let pairArr = pairs => pairs.map(param => {
-        let d = {};
-        d["id"] = param[0];
-        d["value"] = param[1];
-        return d;
-      });
-      obj["expected"] = pairArr(m.expected);
-      obj["actual"] = pairArr(m.actual);
-      break;
-    case "TranslateError" :
-      obj["expected"] = m.expected;
-      obj["actual"] = Stdlib_Option.mapOr(m.actual, null, prim => prim);
-      break;
-    case "EventsMismatch" :
-    case "AppendConditionMismatch" :
-    case "QueryRowsMismatch" :
-    case "PublishedActionsMismatch" :
-      obj["expected"] = m.expected;
-      obj["actual"] = m.actual;
-      break;
-    case "Throw" :
-      obj["error"] = m.error;
-      obj["stack"] = m.stack;
-      break;
-  }
-  return obj;
-}
-
 let pass = {
   TAG: "Ok",
   _0: undefined
@@ -135,6 +89,5 @@ export {
   stringifyOptJson,
   stringifyJsonArray,
   format,
-  toJson,
 }
 /* No side effect */

package/src/PlatformScan.res

@@ -105,16 +105,20 @@ let inspectDir = (dir: string): option<platformPkg> => {
 // declaration order preserved). Prunes node_modules/lib/.git like Discovery.
 let rec walk = async (dir: string, acc: array<platformPkg>): array<platformPkg> => {
   switch inspectDir(dir) {
-  | Some(pkg) => acc->Array.push(pkg) // a platform package — record, don't descend into its src
-  | None => ()
-  }
-  let entries = try await _readdir(dir, {withFileTypes: true}) catch {
-  | _ => []
-  }
-  for i in 0 to entries->Array.length - 1 {
-    let entry = entries->Array.getUnsafe(i)
-    if entry._isDirectory() && !Array.includes(ignoreNames, entry.name) {
-      let _ = await walk(join(dir, entry.name), acc)
+  // A platform package — record it and stop: descending into its own subtree
+  // (src/, generated code, nested workspace copies) can only waste I/O or turn
+  // up spurious inner matches. This is what the "don't descend" comment always
+  // intended; the recursion below used to run regardless.
+  | Some(pkg) => acc->Array.push(pkg)
+  | None =>
+    let entries = try await _readdir(dir, {withFileTypes: true}) catch {
+    | _ => []
+    }
+    for i in 0 to entries->Array.length - 1 {
+      let entry = entries->Array.getUnsafe(i)
+      if entry._isDirectory() && !Array.includes(ignoreNames, entry.name) {
+        let _ = await walk(join(dir, entry.name), acc)
+      }
     }
   }
   acc