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

package/src/PlatformScan.res.mjs

@@ -83,19 +83,20 @@ async function walk(dir, acc) {
   let pkg = inspectDir(dir);
   if (pkg !== undefined) {
     acc.push(pkg);
-  }
-  let entries;
-  try {
-    entries = await Promises.readdir(dir, {
-      withFileTypes: true
-    });
-  } catch (exn) {
-    entries = [];
-  }
-  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
-    let entry = entries[i];
-    if (entry.isDirectory() && !ignoreNames.includes(entry.name)) {
-      await walk(Nodepath.join(dir, entry.name), acc);
+  } else {
+    let entries;
+    try {
+      entries = await Promises.readdir(dir, {
+        withFileTypes: true
+      });
+    } catch (exn) {
+      entries = [];
+    }
+    for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
+      let entry = entries[i];
+      if (entry.isDirectory() && !ignoreNames.includes(entry.name)) {
+        await walk(Nodepath.join(dir, entry.name), acc);
+      }
     }
   }
   return acc;

package/tests/BuildClassifierTest.res

@@ -80,6 +80,45 @@ describe("BuildClassifier", () => {
     expect(fails.contents->Array.length)->toEqual(0)
   })
 
+  testPromise("errors emitted before the first Parsed line still settle to onFail (B3)", async () => {
+    // A crashed toolchain / pnpm resolution failure prints an error block with no
+    // preceding "Parsed …" line. The old `compiling && hasError` guard left this
+    // pinned forever; now `hasError` alone settles it.
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Syntax error: unexpected token")
+    feed("  at Foo.res:3:1")
+    await delay(550)
+    expect(oks.contents)->toEqual(0)
+    expect(fails.contents->Array.length)->toEqual(1)
+    expect((fails.contents->Array.getUnsafe(0))->String.includes("Syntax error"))->toEqual(true)
+  })
+
+  testPromise("a multi-error build keeps error blocks past the old 20-line cap (B3)", async () => {
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => (),
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    feed("We've found a bug for you!")
+    // 30 filler lines push a distinctive later error past the old 20-line window.
+    for i in 1 to 30 {
+      feed("noise line " ++ Int.toString(i))
+    }
+    feed("Found 2 errors")
+    await delay(550)
+    expect(fails.contents->Array.length)->toEqual(1)
+    // The late "Found 2 errors" line survives (dropped under the old cap of 20).
+    expect((fails.contents->Array.getUnsafe(0))->String.includes("Found 2 errors"))->toEqual(true)
+  })
+
   testPromise("strips ANSI colour codes before matching the finish line", async () => {
     let oks = ref(0)
     let feed = BuildClassifier.make({

package/tests/BuildClassifierTest.res.mjs

@@ -109,6 +109,50 @@ globalThis.describe("BuildClassifier", () => {
     globalThis.expect(oks.contents).toEqual(1);
     globalThis.expect(fails.contents.length).toEqual(0);
   });
+  globalThis.test("errors emitted before the first Parsed line still settle to onFail (B3)", async () => {
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Syntax error: unexpected token");
+    feed("  at Foo.res:3:1");
+    await delay(550);
+    globalThis.expect(oks.contents).toEqual(0);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    globalThis.expect(fails.contents[0].includes("Syntax error")).toEqual(true);
+  });
+  globalThis.test("a multi-error build keeps error blocks past the old 20-line cap (B3)", async () => {
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {},
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    feed("We've found a bug for you!");
+    for (let i = 1; i <= 30; ++i) {
+      feed("noise line " + i.toString());
+    }
+    feed("Found 2 errors");
+    await delay(550);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    globalThis.expect(fails.contents[0].includes("Found 2 errors")).toEqual(true);
+  });
   globalThis.test("strips ANSI colour codes before matching the finish line", async () => {
     let oks = {
       contents: 0

package/tests/CliWatchScopeTest.res

@@ -0,0 +1,62 @@
+// Unit tests for the watch re-run scope algebra (B1): a plain edit narrows the
+// re-run to its owning test package, structural/add/full triggers widen to
+// RunAll, and scopes coalesce (RunAll absorbing) while a pass is in flight.
+
+open JestGlobals
+
+describe("Cli.mergeScope", () => {
+  testSync("RunAll absorbs on the left", () =>
+    expect(Cli.mergeScope(RunAll, RunPackages(["/p/a"])))->toEqual(Cli.RunAll)
+  )
+  testSync("RunAll absorbs on the right", () =>
+    expect(Cli.mergeScope(RunPackages(["/p/a"]), RunAll))->toEqual(Cli.RunAll)
+  )
+  testSync("two RunPackages union their dirs, deduplicated", () =>
+    expect(Cli.mergeScope(RunPackages(["/p/a", "/p/b"]), RunPackages(["/p/b", "/p/c"])))->toEqual(
+      Cli.RunPackages(["/p/a", "/p/b", "/p/c"]),
+    )
+  )
+  testSync("RunAll merged with RunAll stays RunAll", () =>
+    expect(Cli.mergeScope(RunAll, RunAll))->toEqual(Cli.RunAll)
+  )
+})
+
+describe("Cli.pathUnderDir", () => {
+  testSync("a file inside the dir is under it", () =>
+    expect(Cli.pathUnderDir("/p/pkgA/tests/FooGwt.res.mjs", "/p/pkgA"))->toEqual(true)
+  )
+  testSync("a sibling with a shared prefix is NOT under it", () =>
+    // /p/pkgABC must not be treated as inside /p/pkgA — the trailing separator
+    // guards against the bare-prefix false positive.
+    expect(Cli.pathUnderDir("/p/pkgABC/tests/FooGwt.res.mjs", "/p/pkgA"))->toEqual(false)
+  )
+  testSync("an unrelated path is not under it", () =>
+    expect(Cli.pathUnderDir("/p/pkgB/tests/BarGwt.res.mjs", "/p/pkgA"))->toEqual(false)
+  )
+  testSync("a trailing-slash dir still matches", () =>
+    expect(Cli.pathUnderDir("/p/pkgA/tests/FooGwt.res.mjs", "/p/pkgA/"))->toEqual(true)
+  )
+})
+
+describe("Cli.scopeSubset", () => {
+  let all = [
+    "/p/pkgA/tests/FooGwt.res.mjs",
+    "/p/pkgA/tests/BarGwt.res.mjs",
+    "/p/pkgB/tests/BazGwt.res.mjs",
+  ]
+  testSync("RunAll returns every path", () =>
+    expect(Cli.scopeSubset(RunAll, all))->toEqual(all)
+  )
+  testSync("RunPackages keeps only files under the given dirs", () =>
+    expect(Cli.scopeSubset(RunPackages(["/p/pkgA"]), all))->toEqual([
+      "/p/pkgA/tests/FooGwt.res.mjs",
+      "/p/pkgA/tests/BarGwt.res.mjs",
+    ])
+  )
+  testSync("RunPackages over multiple dirs unions their files", () =>
+    expect(Cli.scopeSubset(RunPackages(["/p/pkgA", "/p/pkgB"]), all))->toEqual(all)
+  )
+  testSync("RunPackages with no matching dir yields no files", () =>
+    expect(Cli.scopeSubset(RunPackages(["/p/pkgZ"]), all))->toEqual([])
+  )
+})

package/tests/CliWatchScopeTest.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Cli$ReventlessGwt from "../src/Cli.res.mjs";
+
+globalThis.describe("Cli.mergeScope", () => {
+  globalThis.test("RunAll absorbs on the left", () => {
+    globalThis.expect(Cli$ReventlessGwt.mergeScope("RunAll", {
+      TAG: "RunPackages",
+      _0: ["/p/a"]
+    })).toEqual("RunAll");
+  });
+  globalThis.test("RunAll absorbs on the right", () => {
+    globalThis.expect(Cli$ReventlessGwt.mergeScope({
+      TAG: "RunPackages",
+      _0: ["/p/a"]
+    }, "RunAll")).toEqual("RunAll");
+  });
+  globalThis.test("two RunPackages union their dirs, deduplicated", () => {
+    globalThis.expect(Cli$ReventlessGwt.mergeScope({
+      TAG: "RunPackages",
+      _0: [
+        "/p/a",
+        "/p/b"
+      ]
+    }, {
+      TAG: "RunPackages",
+      _0: [
+        "/p/b",
+        "/p/c"
+      ]
+    })).toEqual({
+      TAG: "RunPackages",
+      _0: [
+        "/p/a",
+        "/p/b",
+        "/p/c"
+      ]
+    });
+  });
+  globalThis.test("RunAll merged with RunAll stays RunAll", () => {
+    globalThis.expect(Cli$ReventlessGwt.mergeScope("RunAll", "RunAll")).toEqual("RunAll");
+  });
+});
+
+globalThis.describe("Cli.pathUnderDir", () => {
+  globalThis.test("a file inside the dir is under it", () => {
+    globalThis.expect(Cli$ReventlessGwt.pathUnderDir("/p/pkgA/tests/FooGwt.res.mjs", "/p/pkgA")).toEqual(true);
+  });
+  globalThis.test("a sibling with a shared prefix is NOT under it", () => {
+    globalThis.expect(Cli$ReventlessGwt.pathUnderDir("/p/pkgABC/tests/FooGwt.res.mjs", "/p/pkgA")).toEqual(false);
+  });
+  globalThis.test("an unrelated path is not under it", () => {
+    globalThis.expect(Cli$ReventlessGwt.pathUnderDir("/p/pkgB/tests/BarGwt.res.mjs", "/p/pkgA")).toEqual(false);
+  });
+  globalThis.test("a trailing-slash dir still matches", () => {
+    globalThis.expect(Cli$ReventlessGwt.pathUnderDir("/p/pkgA/tests/FooGwt.res.mjs", "/p/pkgA/")).toEqual(true);
+  });
+});
+
+globalThis.describe("Cli.scopeSubset", () => {
+  let all = [
+    "/p/pkgA/tests/FooGwt.res.mjs",
+    "/p/pkgA/tests/BarGwt.res.mjs",
+    "/p/pkgB/tests/BazGwt.res.mjs"
+  ];
+  globalThis.test("RunAll returns every path", () => {
+    globalThis.expect(Cli$ReventlessGwt.scopeSubset("RunAll", all)).toEqual(all);
+  });
+  globalThis.test("RunPackages keeps only files under the given dirs", () => {
+    globalThis.expect(Cli$ReventlessGwt.scopeSubset({
+      TAG: "RunPackages",
+      _0: ["/p/pkgA"]
+    }, all)).toEqual([
+      "/p/pkgA/tests/FooGwt.res.mjs",
+      "/p/pkgA/tests/BarGwt.res.mjs"
+    ]);
+  });
+  globalThis.test("RunPackages over multiple dirs unions their files", () => {
+    globalThis.expect(Cli$ReventlessGwt.scopeSubset({
+      TAG: "RunPackages",
+      _0: [
+        "/p/pkgA",
+        "/p/pkgB"
+      ]
+    }, all)).toEqual(all);
+  });
+  globalThis.test("RunPackages with no matching dir yields no files", () => {
+    globalThis.expect(Cli$ReventlessGwt.scopeSubset({
+      TAG: "RunPackages",
+      _0: ["/p/pkgZ"]
+    }, all)).toEqual([]);
+  });
+});
+
+/*  Not a pure module */

package/tests/ComponentMetaTest.res

@@ -28,6 +28,21 @@ describe("ComponentMeta.componentOfTestFile", () => {
     let c = ComponentMeta.componentOfTestFile("/repo/x/tests/Helpers/Thing_GWT.res.mjs")
     expect(c)->toEqual(None)
   })
+
+  testPromise("recognises a plural folder spelling with the canonical kind (C2)", async () => {
+    // The generator accepts `Aggregates/`; previously the gwt discovery only knew
+    // the singular `Aggregate/` and silently returned None. Now it derives from
+    // the shared vocabulary and reports the canonical singular kind.
+    let c = ComponentMeta.componentOfTestFile("/repo/x/tests/Order/Aggregates/Order_GWT.res.mjs")
+    expect(c)->toEqual(Some({ComponentMeta.kind: "Aggregate", name: "Order"}))
+  })
+
+  testPromise("recognises a short slice folder spelling (StateChange) too (C2)", async () => {
+    let c = ComponentMeta.componentOfTestFile(
+      "/repo/catalog/tests/Product/StateChange/AddProduct_GWT.res.mjs",
+    )
+    expect(c)->toEqual(Some({ComponentMeta.kind: "StateChangeSlice", name: "AddProduct"}))
+  })
 })
 
 describe("ComponentMeta.componentOfSrcFile", () => {

package/tests/ComponentMetaTest.res.mjs

@@ -28,6 +28,20 @@ globalThis.describe("ComponentMeta.componentOfTestFile", () => {
     let c = ComponentMeta$ReventlessGwt.componentOfTestFile("/repo/x/tests/Helpers/Thing_GWT.res.mjs");
     globalThis.expect(c).toEqual(undefined);
   });
+  globalThis.test("recognises a plural folder spelling with the canonical kind (C2)", async () => {
+    let c = ComponentMeta$ReventlessGwt.componentOfTestFile("/repo/x/tests/Order/Aggregates/Order_GWT.res.mjs");
+    globalThis.expect(c).toEqual({
+      kind: "Aggregate",
+      name: "Order"
+    });
+  });
+  globalThis.test("recognises a short slice folder spelling (StateChange) too (C2)", async () => {
+    let c = ComponentMeta$ReventlessGwt.componentOfTestFile("/repo/catalog/tests/Product/StateChange/AddProduct_GWT.res.mjs");
+    globalThis.expect(c).toEqual({
+      kind: "StateChangeSlice",
+      name: "AddProduct"
+    });
+  });
 });
 
 globalThis.describe("ComponentMeta.componentOfSrcFile", () => {

package/tests/DomainGraphTest.res

@@ -84,9 +84,9 @@ let structure = (
 }
 
 let hasEdge = (g: DomainGraph.graph, from, to, kind) =>
-  g.edges->Array.some(e => e.from == from && e.to == to && e.kind == kind)
+  g.edges->Array.some(e => e.from == from && e.to_ == to && e.kind == kind)
 let edgeLabel = (g: DomainGraph.graph, from, to, kind) =>
-  g.edges->Array.find(e => e.from == from && e.to == to && e.kind == kind)->Option.flatMap(e => e.label)
+  g.edges->Array.find(e => e.from == from && e.to_ == to && e.kind == kind)->Option.flatMap(e => e.label)
 let nodeKind = (g: DomainGraph.graph, id) =>
   g.nodes->Array.find(n => n.id == id)->Option.map(n => n.kind)
 

package/tests/FlowAggregateGwtTest.res

@@ -34,6 +34,7 @@ module CatalogProductBehavior = {
   type state = NotSynced | Synced
 
   let initialState = NotSynced
+  let snapshot = None
 
   let evolve = (_state, event: CatalogProductAggregate.event) =>
     switch event {
@@ -77,6 +78,7 @@ module OrderBehavior = {
   type state = {placed: bool, shipped: bool}
 
   let initialState = {placed: false, shipped: false}
+  let snapshot = None
 
   let evolve = (state, event: OrderAggregate.event) =>
     switch event {

package/tests/FlowAggregateGwtTest.res.mjs

@@ -58,6 +58,7 @@ let moduleUrl = "test://CatalogProductBehavior";
 let CatalogProductBehavior = {
   Spec: undefined,
   initialState: "NotSynced",
+  snapshot: undefined,
   evolve: evolve,
   decide: decide,
   moduleUrl: moduleUrl
@@ -159,6 +160,7 @@ let moduleUrl$1 = "test://OrderBehavior";
 let OrderBehavior = {
   Spec: undefined,
   initialState: initialState,
+  snapshot: undefined,
   evolve: evolve$1,
   decide: decide$1,
   moduleUrl: moduleUrl$1
@@ -169,6 +171,7 @@ let Sync = Flow_GWT$ReventlessGwt.AggregateCommandStep(CatalogProductAggregate)(
   initialState: "NotSynced",
   evolve: evolve,
   decide: decide,
+  snapshot: undefined,
   moduleUrl: moduleUrl
 });
 
@@ -177,6 +180,7 @@ let Place = Flow_GWT$ReventlessGwt.AggregateCommandStep(OrderAggregate)({
   initialState: initialState,
   evolve: evolve$1,
   decide: decide$1,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1
 });
 

package/tests/FormatterGoldenTest.res

@@ -0,0 +1,125 @@
+// Golden-output tests pinning the per-mismatch rendering of the three
+// string-emitting formatters:
+//   - `Outcome.format`               (used by the JUnit `<failure>` body)
+//   - `FormatterHuman.renderMismatch` (terminal output)
+//   - `FormatterTap.renderMismatchYaml` (TAP YAML diagnostic block)
+//
+// These three functions are exactly what the deferred `Outcome.mismatch`
+// normalization (plan C4) will unify. Pinning their current output byte-for-byte
+// lets that refactor prove it preserved Human/TAP rendering — and makes the
+// deliberate JUnit change (it currently renders via raw `Outcome.format`, unlike
+// the RenderRescript-based Human/TAP) explicit and reviewable rather than silent.
+//
+// The fixtures cover all 10 mismatch kinds — the full structural variety the
+// normalization must preserve: array expected/actual (Events/QueryRows/
+// PublishedActions), the Error()/Ok() wrapping with a `None` actual
+// (ErrorMismatch), the `key` extra + option rendering (StateMismatch), a
+// single-sided actual (NoEventExpected), plain-string (non-JSON) sides
+// (TranslateError), the `(id, value)` pair rendering (TodoMismatch), a nested
+// JSON value (AppendConditionMismatch), and the `Throw` stack special case.
+
+open JestGlobals
+
+let evA = JSON.parseOrThrow(`{"TAG":"ProductAdded","_0":{"productId":"p1","name":"Widget"}}`)
+let evB = JSON.parseOrThrow(`{"TAG":"ProductRenamed","_0":{"productId":"p1","name":"Gadget"}}`)
+let stateActive = JSON.parseOrThrow(`{"status":"active"}`)
+let stateArchived = JSON.parseOrThrow(`{"status":"archived"}`)
+let appendExpected = JSON.parseOrThrow(`{"query":[]}`)
+let appendActual = JSON.parseOrThrow(`{"query":[{"eventTypes":["ProductAdded"]}]}`)
+
+type golden = {
+  name: string,
+  mismatch: Outcome.mismatch,
+  format: string,
+  human: string,
+  tap: string,
+}
+
+let goldens: array<golden> = [
+  {
+    name: "EventsMismatch",
+    mismatch: EventsMismatch({expected: [evA], actual: [evB]}),
+    format: "EventsMismatch:\n  expected: [{\n  \"TAG\": \"ProductAdded\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Widget\"\n  }\n}]\n  actual:   [{\n  \"TAG\": \"ProductRenamed\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Gadget\"\n  }\n}]",
+    human: "  expected: [ProductAdded({productId: \"p1\", name: \"Widget\"})]\n  actual:   [ProductRenamed({productId: \"p1\", name: \"Gadget\"})]",
+    tap: "  kind: \"EventsMismatch\"\n  expected: \"[ProductAdded({productId: \\\"p1\\\", name: \\\"Widget\\\"})]\"\n  actual: \"[ProductRenamed({productId: \\\"p1\\\", name: \\\"Gadget\\\"})]\"",
+  },
+  {
+    name: "ErrorMismatch",
+    mismatch: ErrorMismatch({
+      expected: JSON.String("CategoryAlreadyExists"),
+      actual: None,
+      actualEvents: [evA],
+    }),
+    format: "ErrorMismatch:\n  expected error: \"CategoryAlreadyExists\"\n  actual error:   (none)\n  actual events:  [{\n  \"TAG\": \"ProductAdded\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Widget\"\n  }\n}]",
+    human: "  expected: Error(\"CategoryAlreadyExists\")\n  actual:   Ok([ProductAdded({productId: \"p1\", name: \"Widget\"})])",
+    tap: "  kind: \"ErrorMismatch\"\n  expected: \"Error(\\\"CategoryAlreadyExists\\\")\"\n  actual: \"Ok([ProductAdded({productId: \\\"p1\\\", name: \\\"Widget\\\"})])\"",
+  },
+  {
+    name: "StateMismatch",
+    mismatch: StateMismatch({key: "p1", expected: Some(stateActive), actual: Some(stateArchived)}),
+    format: "StateMismatch (key: p1):\n  expected: {\n  \"status\": \"active\"\n}\n  actual:   {\n  \"status\": \"archived\"\n}",
+    human: "  key:      \"p1\"\n  expected: {status: \"active\"}\n  actual:   {status: \"archived\"}",
+    tap: "  kind: \"StateMismatch\"\n  key: \"p1\"\n  expected: \"{status: \\\"active\\\"}\"\n  actual: \"{status: \\\"archived\\\"}\"",
+  },
+  {
+    name: "NoEventExpected",
+    mismatch: NoEventExpected({actual: [evA]}),
+    format: "NoEventExpected: expected no events, got:\n  [{\n  \"TAG\": \"ProductAdded\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Widget\"\n  }\n}]",
+    human: "  expected no events\n  actual:   [ProductAdded({productId: \"p1\", name: \"Widget\"})]",
+    tap: "  kind: \"NoEventExpected\"\n  actual: \"[ProductAdded({productId: \\\"p1\\\", name: \\\"Widget\\\"})]\"",
+  },
+  {
+    name: "TranslateError",
+    mismatch: TranslateError({expected: "boom", actual: Some("kaboom")}),
+    format: "TranslateError:\n  expected: boom\n  actual:   kaboom",
+    human: "  expected: boom\n  actual:   kaboom",
+    tap: "  kind: \"TranslateError\"\n  expected: \"boom\"\n  actual: \"kaboom\"",
+  },
+  {
+    name: "Throw",
+    mismatch: Throw({error: "unexpected", stack: "at foo"}),
+    format: "Throw: unexpected\nat foo",
+    human: "  error: unexpected\nat foo",
+    tap: "  kind: \"Throw\"\n  error: \"unexpected\"\n  stack: \"at foo\"",
+  },
+  {
+    name: "TodoMismatch",
+    mismatch: TodoMismatch({expected: [("case-1", evA)], actual: [("case-2", evB)]}),
+    format: "TodoMismatch:\n  expected: [(case-1, {\n  \"TAG\": \"ProductAdded\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Widget\"\n  }\n})]\n  actual:   [(case-2, {\n  \"TAG\": \"ProductRenamed\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Gadget\"\n  }\n})]",
+    human: "  expected: [(case-1, ProductAdded({productId: \"p1\", name: \"Widget\"}))]\n  actual:   [(case-2, ProductRenamed({productId: \"p1\", name: \"Gadget\"}))]",
+    tap: "  kind: \"TodoMismatch\"\n  expected: \"[(case-1, ProductAdded({productId: \\\"p1\\\", name: \\\"Widget\\\"}))]\"\n  actual: \"[(case-2, ProductRenamed({productId: \\\"p1\\\", name: \\\"Gadget\\\"}))]\"",
+  },
+  {
+    name: "AppendConditionMismatch",
+    mismatch: AppendConditionMismatch({expected: appendExpected, actual: appendActual}),
+    format: "AppendConditionMismatch:\n  expected: {\n  \"query\": []\n}\n  actual:   {\n  \"query\": [\n    {\n      \"eventTypes\": [\n        \"ProductAdded\"\n      ]\n    }\n  ]\n}",
+    human: "  expected: {query: []}\n  actual:   {query: [{eventTypes: [\"ProductAdded\"]}]}",
+    tap: "  kind: \"AppendConditionMismatch\"\n  expected: \"{query: []}\"\n  actual: \"{query: [{eventTypes: [\\\"ProductAdded\\\"]}]}\"",
+  },
+  {
+    name: "QueryRowsMismatch",
+    mismatch: QueryRowsMismatch({expected: [evA], actual: [evB]}),
+    format: "QueryRowsMismatch:\n  expected: [{\n  \"TAG\": \"ProductAdded\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Widget\"\n  }\n}]\n  actual:   [{\n  \"TAG\": \"ProductRenamed\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Gadget\"\n  }\n}]",
+    human: "  expected: [ProductAdded({productId: \"p1\", name: \"Widget\"})]\n  actual:   [ProductRenamed({productId: \"p1\", name: \"Gadget\"})]",
+    tap: "  kind: \"QueryRowsMismatch\"\n  expected: \"[ProductAdded({productId: \\\"p1\\\", name: \\\"Widget\\\"})]\"\n  actual: \"[ProductRenamed({productId: \\\"p1\\\", name: \\\"Gadget\\\"})]\"",
+  },
+  {
+    name: "PublishedActionsMismatch",
+    mismatch: PublishedActionsMismatch({expected: [evA], actual: [evB]}),
+    format: "PublishedActionsMismatch:\n  expected: [{\n  \"TAG\": \"ProductAdded\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Widget\"\n  }\n}]\n  actual:   [{\n  \"TAG\": \"ProductRenamed\",\n  \"_0\": {\n    \"productId\": \"p1\",\n    \"name\": \"Gadget\"\n  }\n}]",
+    human: "  expected: [ProductAdded({productId: \"p1\", name: \"Widget\"})]\n  actual:   [ProductRenamed({productId: \"p1\", name: \"Gadget\"})]",
+    tap: "  kind: \"PublishedActionsMismatch\"\n  expected: \"[ProductAdded({productId: \\\"p1\\\", name: \\\"Widget\\\"})]\"\n  actual: \"[ProductRenamed({productId: \\\"p1\\\", name: \\\"Gadget\\\"})]\"",
+  },
+]
+
+describe("Formatter golden outputs (per-mismatch rendering)", () => {
+  goldens->Array.forEach(g => {
+    testSync(`${g.name} — Outcome.format`, () => expect(Outcome.format(g.mismatch))->toEqual(g.format))
+    testSync(`${g.name} — FormatterHuman.renderMismatch`, () =>
+      expect(FormatterHuman.renderMismatch(g.mismatch))->toEqual(g.human)
+    )
+    testSync(`${g.name} — FormatterTap.renderMismatchYaml`, () =>
+      expect(FormatterTap.renderMismatchYaml(g.mismatch))->toEqual(g.tap)
+    )
+  })
+})