@reventlessdev/reventless-gwt 1.0.0-alpha.100

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

package/tests/FormatterGoldenTest.res.mjs

@@ -0,0 +1,162 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as FormatterTap$ReventlessGwt from "../src/FormatterTap.res.mjs";
+import * as FormatterHuman$ReventlessGwt from "../src/FormatterHuman.res.mjs";
+
+let evA = JSON.parse(`{"TAG":"ProductAdded","_0":{"productId":"p1","name":"Widget"}}`);
+
+let evB = JSON.parse(`{"TAG":"ProductRenamed","_0":{"productId":"p1","name":"Gadget"}}`);
+
+let stateActive = JSON.parse(`{"status":"active"}`);
+
+let stateArchived = JSON.parse(`{"status":"archived"}`);
+
+let appendExpected = JSON.parse(`{"query":[]}`);
+
+let appendActual = JSON.parse(`{"query":[{"eventTypes":["ProductAdded"]}]}`);
+
+let goldens = [
+  {
+    name: "EventsMismatch",
+    mismatch: {
+      TAG: "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: {
+      TAG: "ErrorMismatch",
+      expected: "CategoryAlreadyExists",
+      actual: undefined,
+      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: {
+      TAG: "StateMismatch",
+      key: "p1",
+      expected: stateActive,
+      actual: 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: {
+      TAG: "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: {
+      TAG: "TranslateError",
+      expected: "boom",
+      actual: "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: {
+      TAG: "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: {
+      TAG: "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: {
+      TAG: "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: {
+      TAG: "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: {
+      TAG: "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\\\"})]\""
+  }
+];
+
+globalThis.describe("Formatter golden outputs (per-mismatch rendering)", () => {
+  goldens.forEach(g => {
+    globalThis.test(g.name + ` — Outcome.format`, () => {
+      globalThis.expect(Outcome$ReventlessGwt.format(g.mismatch)).toEqual(g.format);
+    });
+    globalThis.test(g.name + ` — FormatterHuman.renderMismatch`, () => {
+      globalThis.expect(FormatterHuman$ReventlessGwt.renderMismatch(g.mismatch)).toEqual(g.human);
+    });
+    globalThis.test(g.name + ` — FormatterTap.renderMismatchYaml`, () => {
+      globalThis.expect(FormatterTap$ReventlessGwt.renderMismatchYaml(g.mismatch)).toEqual(g.tap);
+    });
+  });
+});
+
+export {
+  evA,
+  evB,
+  stateActive,
+  stateArchived,
+  appendExpected,
+  appendActual,
+  goldens,
+}
+/* evA Not a pure module */

package/tests/FormatterVsCodeMessageTest.res

@@ -0,0 +1,41 @@
+// Unit test for FormatterVsCode.messagePayload — the failure payload the
+// VS Code extension renders. Asserts the `kind` discriminator (the mismatch
+// family) is present so a client can gate the apply-expected quick-fix.
+
+open JestGlobals
+
+let failingResult = (~mismatch): RunnerTypes.testResult => {
+  id: "t1",
+  name: "rejects when category already exists",
+  describePath: [],
+  status: RunnerTypes.Fail,
+  durationMs: 1.0,
+  location: None,
+  slice: None,
+  mismatch,
+  skipReason: None,
+}
+
+describe("FormatterVsCode.messagePayload", () => {
+  testPromise("includes the mismatch kind for an EventsMismatch", async () => {
+    let m = FormatterVsCode.messagePayload(
+      failingResult(~mismatch=Some(Outcome.EventsMismatch({expected: [], actual: []}))),
+    )
+    expect(m.kind)->toEqual(Some("EventsMismatch"))
+  })
+
+  testPromise("includes the mismatch kind for an ErrorMismatch", async () => {
+    let m = FormatterVsCode.messagePayload(
+      failingResult(
+        ~mismatch=Some(
+          Outcome.ErrorMismatch({
+            expected: JSON.String("CategoryAlreadyExists"),
+            actual: None,
+            actualEvents: [],
+          }),
+        ),
+      ),
+    )
+    expect(m.kind)->toEqual(Some("ErrorMismatch"))
+  })
+})

package/tests/FormatterVsCodeMessageTest.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FormatterVsCode$ReventlessGwt from "../src/FormatterVsCode.res.mjs";
+
+function failingResult(mismatch) {
+  return {
+    id: "t1",
+    name: "rejects when category already exists",
+    describePath: [],
+    status: "Fail",
+    durationMs: 1.0,
+    location: undefined,
+    slice: undefined,
+    mismatch: mismatch,
+    skipReason: undefined
+  };
+}
+
+globalThis.describe("FormatterVsCode.messagePayload", () => {
+  globalThis.test("includes the mismatch kind for an EventsMismatch", async () => {
+    let m = FormatterVsCode$ReventlessGwt.messagePayload(failingResult({
+      TAG: "EventsMismatch",
+      expected: [],
+      actual: []
+    }));
+    globalThis.expect(m.kind).toEqual("EventsMismatch");
+  });
+  globalThis.test("includes the mismatch kind for an ErrorMismatch", async () => {
+    let m = FormatterVsCode$ReventlessGwt.messagePayload(failingResult({
+      TAG: "ErrorMismatch",
+      expected: "CategoryAlreadyExists",
+      actual: undefined,
+      actualEvents: []
+    }));
+    globalThis.expect(m.kind).toEqual("ErrorMismatch");
+  });
+});
+
+export {
+  failingResult,
+}
+/*  Not a pure module */

package/tests/InboundTranslationGwtTest.res

@@ -0,0 +1,34 @@
+// Worked example for InboundTranslationSlice_GWT — a payment webhook that
+// translates `status` into either a `ConfirmPayment` command or a
+// translation error for unknown statuses.
+
+@@reventless.gwt
+
+module PaymentWebhookSlice = {
+  let name = "PaymentWebhook"
+
+  @schema
+  type externalInput = {paymentId: string, orderId: string, status: string}
+
+  @schema
+  type command = ConfirmPayment({orderId: string, paymentId: string})
+
+  let translate = input =>
+    switch input.status {
+    | "completed" =>
+      Ok([(input.orderId, ConfirmPayment({orderId: input.orderId, paymentId: input.paymentId}))])
+    | _ => Error("Unknown payment status: " ++ input.status)
+    }
+}
+
+describe("PaymentWebhook InboundTranslationSlice", () => {
+  test("completed status emits ConfirmPayment", () =>
+    whenInput({paymentId: "p1", orderId: "o1", status: "completed"})
+    ->thenCommand("o1", ConfirmPayment({orderId: "o1", paymentId: "p1"}))
+  )
+
+  test("unknown status surfaces translate error", () =>
+    whenInput({paymentId: "p1", orderId: "o1", status: "garbage"})
+    ->thenTranslateError("Unknown payment status: garbage")
+  )
+})

package/tests/InboundTranslationGwtTest.res.mjs

@@ -0,0 +1,99 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as InboundTranslation_GWT$ReventlessGwt from "../src/InboundTranslation_GWT.res.mjs";
+
+let externalInputSchema = S.schema(s => ({
+  paymentId: s.m(S.string),
+  orderId: s.m(S.string),
+  status: s.m(S.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "ConfirmPayment",
+  orderId: s.m(S.string),
+  paymentId: s.m(S.string)
+}));
+
+function translate(input) {
+  let match = input.status;
+  if (match === "completed") {
+    return {
+      TAG: "Ok",
+      _0: [[
+          input.orderId,
+          {
+            TAG: "ConfirmPayment",
+            orderId: input.orderId,
+            paymentId: input.paymentId
+          }
+        ]]
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "Unknown payment status: " + input.status
+    };
+  }
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let PaymentWebhookSlice = {
+  name: "PaymentWebhook",
+  externalInputSchema: externalInputSchema,
+  commandSchema: commandSchema,
+  translate: translate,
+  commandAuthorization: commandAuthorization,
+  externalSystem: undefined
+};
+
+let include = InboundTranslation_GWT$ReventlessGwt.Make(PaymentWebhookSlice);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let whenInput = include.whenInput;
+
+let thenCommand = include.thenCommand;
+
+let thenTranslateError = include.thenTranslateError;
+
+describe("PaymentWebhook InboundTranslationSlice", () => {
+  test("completed status emits ConfirmPayment", () => thenCommand(whenInput({
+    paymentId: "p1",
+    orderId: "o1",
+    status: "completed"
+  }), "o1", {
+    TAG: "ConfirmPayment",
+    orderId: "o1",
+    paymentId: "p1"
+  }));
+  test("unknown status surfaces translate error", () => thenTranslateError(whenInput({
+    paymentId: "p1",
+    orderId: "o1",
+    status: "garbage"
+  }), "Unknown payment status: garbage"));
+});
+
+let Spec = include.Spec;
+
+let thenCommands = include.thenCommands;
+
+let thenNoCommand = include.thenNoCommand;
+
+export {
+  PaymentWebhookSlice,
+  Spec,
+  describe,
+  test,
+  whenInput,
+  thenCommands,
+  thenCommand,
+  thenNoCommand,
+  thenTranslateError,
+}
+/* externalInputSchema Not a pure module */

package/tests/LocalHostIntegration.res

@@ -0,0 +1,70 @@
+// Integration test for LocalHost.loadGraph — the cold-load path that instantiates
+// reventless-local's Platform and builds the real example plugins against it.
+//
+// Runs under `node --test` (NOT Jest) on purpose: cold-loading the local platform
+// under Jest's experimental-vm-modules hits the graphql/yoga CJS-in-ESM interop
+// wall documented in tests/SplitApiFixtures.res. Plain node ESM is exactly the
+// runtime the CLI host uses, and where the Phase 4.5 spike proved cold-load works
+// (docs/analysis/reventless-vscode-domain-graph-design.md "Spike result"). It is
+// named without the `Test` suffix so the Jest `testMatch` glob
+// (`tests/**/*Test.res.mjs`) skips it — `pnpm run test:host` runs it via node. The
+// pure helpers (name derivation, discovery) are the Jest test in tests/LocalHostTest.res.
+//
+// Prerequisite: reventless-local + the online-shop-aggregates examples must be
+// compiled (`pnpm run build` at the repo root). Run: `pnpm run test:host`.
+
+@module("node:test") external test: (string, unit => promise<unit>) => unit = "test"
+@module("node:assert/strict") external equal: ('a, 'a) => unit = "equal"
+@module("node:assert/strict") external deepEqual: ('a, 'a) => unit = "deepEqual"
+@module("node:assert/strict") external ok: (bool, ~message: string=?) => unit = "ok"
+
+@module("node:url") external fileURLToPath: string => string = "fileURLToPath"
+@module("node:path") external dirname: string => string = "dirname"
+@module("node:path") @variadic external join: array<string> => string = "join"
+
+let here = dirname(fileURLToPath(%raw(`import.meta.url`)))
+let repoRoot = join([here, "..", "..", ".."]) // reventless-gwt/test → repo root
+let catalogDir = join([repoRoot, "examples", "online-shop-aggregates", "catalog"])
+let orderingDir = join([repoRoot, "examples", "online-shop-aggregates", "ordering"])
+let platformPath = join([repoRoot, "reventless", "reventless-local", "src", "Platform.res.mjs"])
+
+let structureFor = (g: LocalHost.graph, name) =>
+  g.structures->Array.find(((n, _)) => n == name)->Option.map(((_, s)) => s)
+
+test("loadGraph cold-loads structures from the real plugins", async () => {
+  let plugins = LocalHost.discover(~packageDirs=[catalogDir, orderingDir])
+  let g = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+
+  // structures: resolved plain records, plugin-namespaced event types.
+  deepEqual(g.structures->Array.map(((n, _)) => n), ["Catalog", "Ordering"])
+
+  let catalog = structureFor(g, "Catalog")->Option.getOrThrow
+  let category = catalog.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Category")->Option.getOrThrow
+  ok(category.producedEventTypes->Array.includes("Catalog.Added"))
+
+  let ordering = structureFor(g, "Ordering")->Option.getOrThrow
+  let order = ordering.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Order")->Option.getOrThrow
+  ok(order.producedEventTypes->Array.includes("Ordering.Placed"))
+
+  // extensionPoints (producer side): Catalog owns Catalog.Products, fed by the
+  // Product aggregate's internal events — so the EP's sourceEventTypes are a
+  // subset of the producer's producedEventTypes, the link the event graph draws.
+  let catalogEps = catalog.extensionPoints->Option.getOr([])
+  let productsEp =
+    catalogEps->Array.find((e: Reventless.Plugin.extensionPointDef) => e.name == "Catalog.Products")->Option.getOrThrow
+  ok(productsEp.delegateNames->Array.includes("Product"), ~message=productsEp.delegateNames->Array.join(","))
+  ok(
+    productsEp.sourceEventTypes->Array.includes("Catalog.Added"),
+    ~message=productsEp.sourceEventTypes->Array.join(","),
+  )
+  let product = catalog.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Product")->Option.getOrThrow
+  ok(productsEp.sourceEventTypes->Array.every(e => product.producedEventTypes->Array.includes(e)))
+})
+
+test("loadGraph is cold — a second call in the same process succeeds (cache-busting works)", async () => {
+  let plugins = LocalHost.discover(~packageDirs=[catalogDir])
+  let g1 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+  let g2 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+  equal(g1.structures->Array.length, 1)
+  equal(g2.structures->Array.length, 1)
+})

package/tests/LocalHostIntegration.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodeurl from "node:url";
+import * as Nodepath from "node:path";
+import * as Nodetest from "node:test";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Strict from "node:assert/strict";
+import * as LocalHost$ReventlessGwt from "../src/LocalHost.res.mjs";
+
+let here = Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url));
+
+let repoRoot = Nodepath.join(here, "..", "..", "..");
+
+let catalogDir = Nodepath.join(repoRoot, "examples", "online-shop-aggregates", "catalog");
+
+let orderingDir = Nodepath.join(repoRoot, "examples", "online-shop-aggregates", "ordering");
+
+let platformPath = Nodepath.join(repoRoot, "reventless", "reventless-local", "src", "Platform.res.mjs");
+
+function structureFor(g, name) {
+  return Stdlib_Option.map(g.structures.find(param => param[0] === name), param => param[1]);
+}
+
+Nodetest.test("loadGraph cold-loads structures from the real plugins", async () => {
+  let plugins = LocalHost$ReventlessGwt.discover([
+    catalogDir,
+    orderingDir
+  ]);
+  let g = await LocalHost$ReventlessGwt.loadGraph(platformPath, plugins);
+  Strict.deepEqual(g.structures.map(param => param[0]), [
+    "Catalog",
+    "Ordering"
+  ]);
+  let catalog = Stdlib_Option.getOrThrow(structureFor(g, "Catalog"), undefined);
+  let category = Stdlib_Option.getOrThrow(catalog.aggregates.find(a => a.name === "Category"), undefined);
+  Strict.ok(category.producedEventTypes.includes("Catalog.Added"));
+  let ordering = Stdlib_Option.getOrThrow(structureFor(g, "Ordering"), undefined);
+  let order = Stdlib_Option.getOrThrow(ordering.aggregates.find(a => a.name === "Order"), undefined);
+  Strict.ok(order.producedEventTypes.includes("Ordering.Placed"));
+  let catalogEps = Stdlib_Option.getOr(catalog.extensionPoints, []);
+  let productsEp = Stdlib_Option.getOrThrow(catalogEps.find(e => e.name === "Catalog.Products"), undefined);
+  Strict.ok(productsEp.delegateNames.includes("Product"), productsEp.delegateNames.join(","));
+  Strict.ok(productsEp.sourceEventTypes.includes("Catalog.Added"), productsEp.sourceEventTypes.join(","));
+  let product = Stdlib_Option.getOrThrow(catalog.aggregates.find(a => a.name === "Product"), undefined);
+  Strict.ok(productsEp.sourceEventTypes.every(e => product.producedEventTypes.includes(e)));
+});
+
+Nodetest.test("loadGraph is cold — a second call in the same process succeeds (cache-busting works)", async () => {
+  let plugins = LocalHost$ReventlessGwt.discover([catalogDir]);
+  let g1 = await LocalHost$ReventlessGwt.loadGraph(platformPath, plugins);
+  let g2 = await LocalHost$ReventlessGwt.loadGraph(platformPath, plugins);
+  Strict.equal(g1.structures.length, 1);
+  Strict.equal(g2.structures.length, 1);
+});
+
+export {
+  here,
+  repoRoot,
+  catalogDir,
+  orderingDir,
+  platformPath,
+  structureFor,
+}
+/* here Not a pure module */