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

package/src/ComponentMeta.res

@@ -5,42 +5,16 @@
 
 type component = {kind: string, name: string}
 
-// Folder names that denote a component kind. A file counts as a component when
-// its immediate parent folder is one of these.
-let kindFolders = [
-  "Aggregate",
-  "StateChangeSlice",
-  "StateViewSlice",
-  "StateViewSliceStream",
-  "ReadModel",
-  "ReadModelStream",
-  "AutomationSlice",
-  "InboundTranslationSlice",
-  "OutboundTranslationSlice",
-  "Extension",
-  "ExtensionPoint",
-  "Task",
-]
-
-let isKindFolder = (segment: string) => kindFolders->Array.includes(segment)
-
-// Body-file suffixes stripped to recover the spec stem (longest first so
-// `_ExtensionPointMapping` is removed before `_ExtensionPoint`). Spec and body
-// files in one folder collapse to the same component name.
-let bodySuffixes = [
-  "_ExtensionPointMapping",
-  "_ExtensionPoint",
-  "_Extension",
-  "_Projections",
-  "_Projection",
-  "_Mappings",
-  "_Behavior",
-  "_Automation",
-  "_Translation",
-]
+// The folder→kind vocabulary and body-file suffixes are the single source in
+// `Reventless.ComponentKind` (shared with the plugin generator). Deriving from it
+// means the gwt discovery recognises exactly the folder spellings the generator
+// classifies — including the plural / short forms this file used to miss.
+module Kind = Reventless.ComponentKind
 
+// Strip a body-file suffix (longest first) to recover the spec stem, so spec and
+// body files in one folder collapse to the same component name.
 let stripBody = (stem: string) =>
-  switch bodySuffixes->Array.find(suf => String.endsWith(stem, suf)) {
+  switch Kind.bodySuffixes->Array.find(suf => String.endsWith(stem, suf)) {
   | Some(suf) => String.slice(stem, ~start=0, ~end=String.length(stem) - String.length(suf))
   | None => stem
   }
@@ -87,18 +61,17 @@ let stem = (filename: string) =>
   }
 
 // {kind, name} for a discovered GWT test file, or None if it isn't inside a
-// recognised kind folder.
+// recognised kind folder. `kind` is the canonical folder name, so a plural
+// folder (`Aggregates/`) reports the same kind as its singular form.
 let componentOfTestFile = (path: string): option<component> =>
-  switch parentFolder(path) {
-  | Some(folder) if isKindFolder(folder) =>
-    Some({kind: folder, name: path->basename->stem->stripGwt->stripBody})
-  | _ => None
+  switch parentFolder(path)->Option.flatMap(Kind.folderToKind) {
+  | Some(kind) => Some({kind: Kind.folderName(kind), name: path->basename->stem->stripGwt->stripBody})
+  | None => None
   }
 
 // {kind, name} for a src/ component file (spec or body), or None.
 let componentOfSrcFile = (path: string): option<component> =>
-  switch parentFolder(path) {
-  | Some(folder) if isKindFolder(folder) =>
-    Some({kind: folder, name: path->basename->stem->stripBody})
-  | _ => None
+  switch parentFolder(path)->Option.flatMap(Kind.folderToKind) {
+  | Some(kind) => Some({kind: Kind.folderName(kind), name: path->basename->stem->stripBody})
+  | None => None
   }

package/src/ComponentMeta.res.mjs

@@ -1,40 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-
-let kindFolders = [
-  "Aggregate",
-  "StateChangeSlice",
-  "StateViewSlice",
-  "StateViewSliceStream",
-  "ReadModel",
-  "ReadModelStream",
-  "AutomationSlice",
-  "InboundTranslationSlice",
-  "OutboundTranslationSlice",
-  "Extension",
-  "ExtensionPoint",
-  "Task"
-];
-
-function isKindFolder(segment) {
-  return kindFolders.includes(segment);
-}
-
-let bodySuffixes = [
-  "_ExtensionPointMapping",
-  "_ExtensionPoint",
-  "_Extension",
-  "_Projections",
-  "_Projection",
-  "_Mappings",
-  "_Behavior",
-  "_Automation",
-  "_Translation"
-];
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ComponentKind$Reventless from "@reventlessdev/reventless-spec/src/components/ComponentKind.res.mjs";
 
 function stripBody(stem) {
-  let suf = bodySuffixes.find(suf => stem.endsWith(suf));
+  let suf = ComponentKind$Reventless.bodySuffixes.find(suf => stem.endsWith(suf));
   if (suf !== undefined) {
     return stem.slice(0, stem.length - suf.length | 0);
   } else {
@@ -86,29 +57,29 @@ function stem(filename) {
 }
 
 function componentOfTestFile(path) {
-  let folder = parentFolder(path);
-  if (folder !== undefined && kindFolders.includes(folder)) {
+  let kind = Stdlib_Option.flatMap(parentFolder(path), ComponentKind$Reventless.folderToKind);
+  if (kind !== undefined) {
     return {
-      kind: folder,
+      kind: ComponentKind$Reventless.folderName(kind),
       name: stripBody(stripGwt(stem(basename(path))))
     };
   }
 }
 
 function componentOfSrcFile(path) {
-  let folder = parentFolder(path);
-  if (folder !== undefined && kindFolders.includes(folder)) {
+  let kind = Stdlib_Option.flatMap(parentFolder(path), ComponentKind$Reventless.folderToKind);
+  if (kind !== undefined) {
     return {
-      kind: folder,
+      kind: ComponentKind$Reventless.folderName(kind),
       name: stripBody(stem(basename(path)))
     };
   }
 }
 
+let Kind;
+
 export {
-  kindFolders,
-  isKindFolder,
-  bodySuffixes,
+  Kind,
   stripBody,
   stripGwt,
   basename,

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/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")
 }