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

package/src/Discovery.res

@@ -43,36 +43,37 @@ let isGwtTestFile = (name: string) =>
   String.endsWith(name, "GwtTest.res.mjs") ||
   String.endsWith(name, "Gwt.res.mjs")
 
-let rec walk = async (dir: string, acc: array<string>): array<string> => {
+// 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) {
-    acc
+    ()
   } else {
-  let found = ref(acc)
-  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() {
-        let nested = await walk(full, [])
-        found := Array.concat(found.contents, nested)
-      } else if entry._isFile() && isGwtTestFile(entry.name) {
-        found := Array.concat(found.contents, [full])
+    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)
+        }
       }
     }
   }
-  found.contents
-  }
 }
 
 // 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 = ref([])
+  let found = []
   for i in 0 to roots->Array.length - 1 {
     let root = roots->Array.getUnsafe(i)
     let absolute = isAbsolute(root) ? root : resolve(root)
@@ -83,16 +84,15 @@ let discover = async (roots: array<string>): array<string> => {
     | _ => false
     }
     if isDir {
-      let collected = await walk(absolute, [])
-      found := Array.concat(found.contents, collected)
+      await walk(absolute, found)
     } else if isGwtTestFile(absolute) {
-      found := Array.concat(found.contents, [absolute])
+      found->Array.push(absolute)
     }
   }
   // Deduplicate (if roots overlap).
   let seen = Dict.make()
   let unique = []
-  found.contents->Array.forEach(path =>
+  found->Array.forEach(path =>
     switch seen->Dict.get(path) {
     | Some(_) => ()
     | None => {

package/src/Discovery.res.mjs

@@ -39,22 +39,19 @@ async function walk(dir, acc) {
     entries = [];
   }
   if (isPruned(entries)) {
-    return acc;
+    return;
   }
-  let found = acc;
   for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
     let entry = entries[i];
     if (!ignoreNames.includes(entry.name)) {
       let full = Nodepath.join(dir, entry.name);
       if (entry.isDirectory()) {
-        let nested = await walk(full, []);
-        found = found.concat(nested);
+        await walk(full, acc);
       } else if (entry.isFile() && isGwtTestFile(entry.name)) {
-        found = found.concat([full]);
+        acc.push(full);
       }
     }
   }
-  return found;
 }
 
 async function discover(roots) {
@@ -70,10 +67,9 @@ async function discover(roots) {
       isDir = false;
     }
     if (isDir) {
-      let collected = await walk(absolute, []);
-      found = found.concat(collected);
+      await walk(absolute, found);
     } else if (isGwtTestFile(absolute)) {
-      found = found.concat([absolute]);
+      found.push(absolute);
     }
   }
   let seen = {};

package/src/Filter.res

@@ -29,8 +29,17 @@ let xtest = (~slice as _: option<string>=?, name: string, _body: unit => Outcome
 let xdescribe = (label: string, body: unit => unit) =>
   if Collector.isActive() {
     Collector.skipDepth := Collector.skipDepth.contents + 1
-    Collector.pushDescribe(label, body)
-    Collector.skipDepth := Collector.skipDepth.contents - 1
+    // Decrement on both the normal and the throwing path (ReScript has no
+    // `finally`): a body that raises must not leak the incremented depth and
+    // skip every following sibling/file.
+    try {
+      Collector.pushDescribe(label, body)
+      Collector.skipDepth := Collector.skipDepth.contents - 1
+    } catch {
+    | e =>
+      Collector.skipDepth := Collector.skipDepth.contents - 1
+      throw(e)
+    }
   } else {
     jestXDescribe(label, body)
   }

package/src/Filter.res.mjs

@@ -14,7 +14,7 @@ function only() {
 function xtest(param, name, _body) {
   if (Collector$ReventlessGwt.isActive()) {
     Collector$ReventlessGwt.markSkipNext();
-    return Collector$ReventlessGwt.push(undefined, undefined, name, () => Promise.resolve(Outcome$ReventlessGwt.pass));
+    return Collector$ReventlessGwt.push(undefined, undefined, undefined, name, () => Promise.resolve(Outcome$ReventlessGwt.pass));
   } else {
     globalThis.xtest(name, () => {});
     return;
@@ -24,10 +24,17 @@ function xtest(param, name, _body) {
 function xdescribe(label, body) {
   if (Collector$ReventlessGwt.isActive()) {
     Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents + 1 | 0;
-    Collector$ReventlessGwt.pushDescribe(label, body);
-    Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+    try {
+      Collector$ReventlessGwt.pushDescribe(label, body);
+      Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+      return;
+    } catch (e) {
+      Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+      throw e;
+    }
   } else {
     globalThis.xdescribe(label, body);
+    return;
   }
 }
 

package/src/FormatterHuman.res

@@ -41,51 +41,22 @@ let formatLocation = (loc: option<Collector.location>) =>
   | Some(l) => `${l.file}:${Int.toString(l.line)}`
   }
 
-let renderMismatch = (m: Outcome.mismatch) =>
-  switch m {
-  | EventsMismatch({expected, actual}) => {
-      let exp = RenderRescript.renderMany(expected)
-      let act = RenderRescript.renderMany(actual)
-      `  expected: ${exp}\n  actual:   ${act}`
-    }
-  | ErrorMismatch({expected, actual, actualEvents}) => {
-      let exp = `Error(${RenderRescript.render(expected)})`
-      let act = switch actual {
-      | Some(v) => `Error(${RenderRescript.render(v)})`
-      | None => `Ok(${RenderRescript.renderMany(actualEvents)})`
-      }
-      `  expected: ${exp}\n  actual:   ${act}`
-    }
-  | StateMismatch({key, expected, actual}) =>
-    `  key:      "${key}"\n  expected: ${RenderRescript.renderOption(
-        expected,
-      )}\n  actual:   ${RenderRescript.renderOption(actual)}`
-  | NoEventExpected({actual}) =>
-    `  expected no events\n  actual:   ${RenderRescript.renderMany(actual)}`
-  | TodoMismatch({expected, actual}) => {
-      let fmt = (arr: array<(string, JSON.t)>) =>
-        arr
-        ->Array.map(((id, v)) => `(${id}, ${RenderRescript.render(v)})`)
-        ->Array.join(", ")
-      `  expected: [${fmt(expected)}]\n  actual:   [${fmt(actual)}]`
-    }
-  | AppendConditionMismatch({expected, actual}) =>
-    `  expected: ${RenderRescript.render(expected)}\n  actual:   ${RenderRescript.render(
-        actual,
-      )}`
-  | TranslateError({expected, actual}) =>
-    `  expected: ${expected}\n  actual:   ${actual->Option.getOr("(none)")}`
-  | QueryRowsMismatch({expected, actual}) =>
-    `  expected: ${RenderRescript.renderMany(expected)}\n  actual:   ${RenderRescript.renderMany(
-        actual,
-      )}`
-  | PublishedActionsMismatch({expected, actual}) =>
-    `  expected: ${RenderRescript.renderMany(expected)}\n  actual:   ${RenderRescript.renderMany(
-        actual,
-      )}`
-  | Throw({error, stack}) => `  error: ${error}\n${stack}`
+// Frames one normalized field as a terminal line. Labels are padded so values
+// align at column 12 (`key:`, `expected:`, `actual:`); `error:` is its own
+// shorter form and the `Throw` stack is dumped raw beneath it.
+let renderField = (f: MismatchRender.field) =>
+  switch f {
+  | Expected(v) => `  expected: ${v}`
+  | Actual(v) => `  actual:   ${v}`
+  | Key(k) => `  key:      "${k}"`
+  | ExpectedNoEvents => "  expected no events"
+  | Error(e) => `  error: ${e}`
+  | Stack(s) => s
   }
 
+let renderMismatch = (m: Outcome.mismatch) =>
+  MismatchRender.normalize(m).fields->Array.map(renderField)->Array.join("\n")
+
 let emitTest = (t: RunnerTypes.testResult) => {
   let path = t.describePath->Array.join(" > ")
   let full = path == "" ? t.name : `${path} > ${t.name}`

package/src/FormatterHuman.res.mjs

@@ -4,7 +4,7 @@ import * as Nodepath from "node:path";
 import Picocolors from "picocolors";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Hint$ReventlessGwt from "./Hint.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);
@@ -29,36 +29,28 @@ function formatLocation(loc) {
   }
 }
 
-function renderMismatch(m) {
-  switch (m.TAG) {
-    case "EventsMismatch" :
-      let exp = RenderRescript$ReventlessGwt.renderMany(m.expected);
-      let act = RenderRescript$ReventlessGwt.renderMany(m.actual);
-      return `  expected: ` + exp + `\n  actual:   ` + act;
-    case "ErrorMismatch" :
-      let actual = m.actual;
-      let exp$1 = `Error(` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `)`;
-      let act$1 = actual !== undefined ? `Error(` + RenderRescript$ReventlessGwt.render(undefined, actual) + `)` : `Ok(` + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + `)`;
-      return `  expected: ` + exp$1 + `\n  actual:   ` + act$1;
-    case "StateMismatch" :
-      return `  key:      "` + m.key + `"\n  expected: ` + RenderRescript$ReventlessGwt.renderOption(m.expected) + `\n  actual:   ` + RenderRescript$ReventlessGwt.renderOption(m.actual);
-    case "NoEventExpected" :
-      return `  expected no events\n  actual:   ` + RenderRescript$ReventlessGwt.renderMany(m.actual);
-    case "TodoMismatch" :
-      let fmt = arr => arr.map(param => `(` + param[0] + `, ` + RenderRescript$ReventlessGwt.render(undefined, param[1]) + `)`).join(", ");
-      return `  expected: [` + fmt(m.expected) + `]\n  actual:   [` + fmt(m.actual) + `]`;
-    case "AppendConditionMismatch" :
-      return `  expected: ` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `\n  actual:   ` + RenderRescript$ReventlessGwt.render(undefined, m.actual);
-    case "TranslateError" :
-      return `  expected: ` + m.expected + `\n  actual:   ` + Stdlib_Option.getOr(m.actual, "(none)");
-    case "QueryRowsMismatch" :
-    case "PublishedActionsMismatch" :
-      return `  expected: ` + RenderRescript$ReventlessGwt.renderMany(m.expected) + `\n  actual:   ` + RenderRescript$ReventlessGwt.renderMany(m.actual);
-    case "Throw" :
-      return `  error: ` + m.error + `\n` + m.stack;
+function renderField(f) {
+  if (typeof f !== "object") {
+    return "  expected no events";
+  }
+  switch (f.TAG) {
+    case "Expected" :
+      return `  expected: ` + f._0;
+    case "Actual" :
+      return `  actual:   ` + f._0;
+    case "Key" :
+      return `  key:      "` + f._0 + `"`;
+    case "Error" :
+      return `  error: ` + f._0;
+    case "Stack" :
+      return f._0;
   }
 }
 
+function renderMismatch(m) {
+  return MismatchRender$ReventlessGwt.normalize(m).fields.map(renderField).join("\n");
+}
+
 function emitTest(t) {
   let path = t.describePath.join(" > ");
   let full = path === "" ? t.name : path + ` > ` + t.name;
@@ -113,6 +105,7 @@ export {
   writeLine,
   formatFilePath,
   formatLocation,
+  renderField,
   renderMismatch,
   emitTest,
   emitFile,

package/src/FormatterJson.res

@@ -5,7 +5,10 @@
 
 // 1.1.0 — additive: `PublishedActionsMismatch` mismatch kind for the
 // Delegate_GWT / cross-plugin Flow_GWT boundary steps.
-let schemaVersion = "1.1.0"
+// The default the emitted envelope carries; the `--schema-version` CLI flag
+// overrides it (threaded through `emit` / `streamRunStart`) so a consumer can
+// pin the schema version its AI prompt was built against.
+let defaultSchemaVersion = "1.1.0"
 
 @val external processStdout: {"write": string => unit} = "process.stdout"
 let write = (s: string) => processStdout["write"](s)
@@ -184,7 +187,11 @@ let summaryJson = (s: RunnerTypes.summary): JSON.t => {
   JSON.Encode.object(d)
 }
 
-let envelope = (r: RunnerTypes.runResult, ~toolVersion: string): JSON.t => {
+let envelope = (
+  r: RunnerTypes.runResult,
+  ~toolVersion: string,
+  ~schemaVersion: string,
+): JSON.t => {
   let d = Dict.make()
   d->Dict.set("schemaVersion", JSON.Encode.string(schemaVersion))
   d->Dict.set("tool", JSON.Encode.string("reventless-gwt"))
@@ -196,11 +203,11 @@ let envelope = (r: RunnerTypes.runResult, ~toolVersion: string): JSON.t => {
   JSON.Encode.object(d)
 }
 
-let emit = (r: RunnerTypes.runResult, ~toolVersion: string) =>
-  write(JSON.stringify(envelope(r, ~toolVersion), ~space=2) ++ "\n")
+let emit = (r: RunnerTypes.runResult, ~toolVersion: string, ~schemaVersion=defaultSchemaVersion) =>
+  write(JSON.stringify(envelope(r, ~toolVersion, ~schemaVersion), ~space=2) ++ "\n")
 
 // Streaming variant — NDJSON events.
-let streamRunStart = (~toolVersion: string, ~startedAt: string) => {
+let streamRunStart = (~toolVersion: string, ~startedAt: string, ~schemaVersion=defaultSchemaVersion) => {
   let d = Dict.make()
   d->Dict.set("type", JSON.Encode.string("runStarted"))
   d->Dict.set("schemaVersion", JSON.Encode.string(schemaVersion))

package/src/FormatterJson.res.mjs

@@ -7,7 +7,7 @@ import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as RunnerTypes$ReventlessGwt from "./RunnerTypes.res.mjs";
 import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
 
-let schemaVersion = "1.1.0";
+let defaultSchemaVersion = "1.1.0";
 
 function write(s) {
   process.stdout.write(s);
@@ -214,7 +214,7 @@ function summaryJson(s) {
   return d;
 }
 
-function envelope(r, toolVersion) {
+function envelope(r, toolVersion, schemaVersion) {
   let d = {};
   d["schemaVersion"] = schemaVersion;
   d["tool"] = "reventless-gwt";
@@ -226,11 +226,13 @@ function envelope(r, toolVersion) {
   return d;
 }
 
-function emit(r, toolVersion) {
-  process.stdout.write(JSON.stringify(envelope(r, toolVersion), undefined, 2) + "\n");
+function emit(r, toolVersion, schemaVersionOpt) {
+  let schemaVersion = schemaVersionOpt !== undefined ? schemaVersionOpt : defaultSchemaVersion;
+  process.stdout.write(JSON.stringify(envelope(r, toolVersion, schemaVersion), undefined, 2) + "\n");
 }
 
-function streamRunStart(toolVersion, startedAt) {
+function streamRunStart(toolVersion, startedAt, schemaVersionOpt) {
+  let schemaVersion = schemaVersionOpt !== undefined ? schemaVersionOpt : defaultSchemaVersion;
   let d = {};
   d["type"] = "runStarted";
   d["schemaVersion"] = schemaVersion;
@@ -299,7 +301,7 @@ function streamRunEnd(r) {
 }
 
 export {
-  schemaVersion,
+  defaultSchemaVersion,
   write,
   writeLine,
   renderValue,

package/src/FormatterTap.res

@@ -18,59 +18,20 @@ let yamlLine = (~indent=2, key: string, value: string) =>
   String.repeat(" ", indent) ++ key ++ ": " ++ value
 
 let renderMismatchYaml = (m: Outcome.mismatch) => {
-  let lines = []
-  lines->Array.push(yamlLine("kind", yamlString(Outcome.kindName(m))))
-  switch m {
-  | EventsMismatch({expected, actual}) => {
-      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderMany(expected))))
-      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
+  let n = MismatchRender.normalize(m)
+  let lines = [yamlLine("kind", yamlString(n.kind))]
+  // `ExpectedNoEvents` is a Human-only literal (TAP simply omits `expected`);
+  // every other field maps to one yaml `key: "escaped-value"` line.
+  n.fields->Array.forEach(f =>
+    switch f {
+    | Expected(v) => lines->Array.push(yamlLine("expected", yamlString(v)))
+    | Actual(v) => lines->Array.push(yamlLine("actual", yamlString(v)))
+    | Key(k) => lines->Array.push(yamlLine("key", yamlString(k)))
+    | Error(e) => lines->Array.push(yamlLine("error", yamlString(e)))
+    | Stack(s) => lines->Array.push(yamlLine("stack", yamlString(s)))
+    | ExpectedNoEvents => ()
     }
-  | ErrorMismatch({expected, actual, actualEvents}) => {
-      lines->Array.push(
-        yamlLine("expected", yamlString("Error(" ++ RenderRescript.render(expected) ++ ")")),
-      )
-      let actualStr = switch actual {
-      | Some(v) => "Error(" ++ RenderRescript.render(v) ++ ")"
-      | None => "Ok(" ++ RenderRescript.renderMany(actualEvents) ++ ")"
-      }
-      lines->Array.push(yamlLine("actual", yamlString(actualStr)))
-    }
-  | StateMismatch({key, expected, actual}) => {
-      lines->Array.push(yamlLine("key", yamlString(key)))
-      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderOption(expected))))
-      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderOption(actual))))
-    }
-  | NoEventExpected({actual}) =>
-    lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
-  | TodoMismatch({expected, actual}) => {
-      let fmt = arr =>
-        arr
-        ->Array.map(((id, v)) => "(" ++ id ++ ", " ++ RenderRescript.render(v) ++ ")")
-        ->Array.join(", ")
-      lines->Array.push(yamlLine("expected", yamlString("[" ++ fmt(expected) ++ "]")))
-      lines->Array.push(yamlLine("actual", yamlString("[" ++ fmt(actual) ++ "]")))
-    }
-  | AppendConditionMismatch({expected, actual}) => {
-      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.render(expected))))
-      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.render(actual))))
-    }
-  | TranslateError({expected, actual}) => {
-      lines->Array.push(yamlLine("expected", yamlString(expected)))
-      lines->Array.push(yamlLine("actual", yamlString(actual->Option.getOr("(none)"))))
-    }
-  | QueryRowsMismatch({expected, actual}) => {
-      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderMany(expected))))
-      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
-    }
-  | PublishedActionsMismatch({expected, actual}) => {
-      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderMany(expected))))
-      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
-    }
-  | Throw({error, stack}) => {
-      lines->Array.push(yamlLine("error", yamlString(error)))
-      lines->Array.push(yamlLine("stack", yamlString(stack)))
-    }
-  }
+  )
   lines->Array.join("\n")
 }
 

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,