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

package/tests/CliRunEntryTest.res

@@ -0,0 +1,57 @@
+// Regression tests for the CLI runner's per-test deadline (A2) and the
+// Collector's skip-depth reset (A4). Before A2 a hung test body wedged the whole
+// run — `runEntry` awaited it with no deadline. Before A4 a throwing `xdescribe`
+// left `skipDepth` > 0, silently skipping every subsequently loaded file; the
+// reset lives in `Collector.activate`.
+
+open JestGlobals
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+
+let hangingEntry = (~timeout): Collector.entry => {
+  id: "hangs",
+  name: "hangs forever",
+  describePath: [],
+  slice: None,
+  // A body that never resolves — the pathological hung test.
+  body: () => Promise.make((_resolve, _reject) => ()),
+  status: Collector.Runnable,
+  location: None,
+  timeout,
+}
+
+describe("Cli.runEntry deadline", () => {
+  testPromise("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli.runEntry(hangingEntry(~timeout=Some(50)))
+    expect(r.status)->toEqual(RunnerTypes.Fail)
+    switch r.mismatch {
+    | Some(Outcome.Throw({error})) => expect(error->String.includes("timed out"))->toEqual(true)
+    | _ => JsError.throwWithMessage("expected a timeout Throw mismatch")
+    }
+  })
+
+  testPromise("a body that resolves within the deadline passes", async () => {
+    let entry: Collector.entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: [],
+      slice: None,
+      body: () => Promise.resolve(Outcome.pass),
+      status: Collector.Runnable,
+      location: None,
+      timeout: Some(1000),
+    }
+    let r = await Cli.runEntry(entry)
+    expect(r.status)->toEqual(RunnerTypes.Pass)
+  })
+})
+
+describe("Collector.activate", () => {
+  testSync("resets a leaked skipDepth to zero", () => {
+    // Simulate the leak a throwing xdescribe body would leave behind.
+    Collector.skipDepth := 3
+    Collector.activate()
+    expect(Collector.skipDepth.contents)->toEqual(0)
+    Collector.deactivate()
+  })
+})

package/tests/CliRunEntryTest.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Cli$ReventlessGwt from "../src/Cli.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "../src/Collector.res.mjs";
+
+function hangingEntry(timeout) {
+  return {
+    id: "hangs",
+    name: "hangs forever",
+    describePath: [],
+    slice: undefined,
+    body: () => new Promise((_resolve, _reject) => {}),
+    status: "Runnable",
+    location: undefined,
+    timeout: timeout
+  };
+}
+
+globalThis.describe("Cli.runEntry deadline", () => {
+  globalThis.test("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli$ReventlessGwt.runEntry(hangingEntry(50));
+    globalThis.expect(r.status).toEqual("Fail");
+    let match = r.mismatch;
+    if (match === undefined) {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    if (match.TAG !== "Throw") {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    globalThis.expect(match.error.includes("timed out")).toEqual(true);
+  });
+  globalThis.test("a body that resolves within the deadline passes", async () => {
+    let entry_describePath = [];
+    let entry_body = () => Promise.resolve(Outcome$ReventlessGwt.pass);
+    let entry_timeout = 1000;
+    let entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: entry_describePath,
+      slice: undefined,
+      body: entry_body,
+      status: "Runnable",
+      location: undefined,
+      timeout: entry_timeout
+    };
+    let r = await Cli$ReventlessGwt.runEntry(entry);
+    globalThis.expect(r.status).toEqual("Pass");
+  });
+});
+
+globalThis.describe("Collector.activate", () => {
+  globalThis.test("resets a leaked skipDepth to zero", () => {
+    Collector$ReventlessGwt.skipDepth.contents = 3;
+    Collector$ReventlessGwt.activate();
+    globalThis.expect(Collector$ReventlessGwt.skipDepth.contents).toEqual(0);
+    Collector$ReventlessGwt.deactivate();
+  });
+});
+
+export {
+  hangingEntry,
+}
+/*  Not a pure module */

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)
+    )
+  })
+})