@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

package/tests/components/automationslice/AutomationSliceCallbackTest.res.mjs

@@ -3,6 +3,8 @@
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as AutomationSliceFixtures$ReventlessLocal from "./AutomationSliceFixtures.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
@@ -280,6 +282,85 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(publishedCommands2.contents.length).toBe(0);
     });
   });
+  globalThis.describe("the flow", () => {
+    let withMeta = (json, msgId, correlationId) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return json;
+      }
+      let meta_service = AutomationSliceFixtures$ReventlessLocal.ShipOrderSource.name;
+      let meta_user = "user-7";
+      let meta_traceparent = "00-trace-span-01";
+      let meta = {
+        service: meta_service,
+        time: "2026-01-01T00:00:00Z",
+        user: meta_user,
+        msgId: msgId,
+        correlationId: correlationId,
+        traceparent: meta_traceparent
+      };
+      json["meta"] = Util_Sury$Reventless.toJson(meta, Message$Reventless.metaSchema);
+      return json;
+    };
+    globalThis.test("the command derives its meta from the event that created the row", async () => {
+      let json = withMeta(AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+        TAG: "OrderPlaced",
+        orderId: "ord-1",
+        address: "123 Main St"
+      }), "evt-1", "flow-1");
+      await Callback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
+      globalThis.expect(Callback.todoItems["ord-1"].source).toEqual({
+        msgId: "evt-1",
+        correlationId: "flow-1",
+        user: "user-7",
+        traceparent: "00-trace-span-01"
+      });
+      let published = {
+        contents: []
+      };
+      await Callback.phase2(async cmds => {
+        published.contents = cmds;
+      });
+      let meta = published.contents[0].meta;
+      globalThis.expect(meta.correlationId).toBe("flow-1");
+      globalThis.expect(meta.causationId).toEqual("evt-1");
+      globalThis.expect(meta.user).toEqual("user-7");
+      globalThis.expect(meta.traceparent).toEqual("00-trace-span-01");
+      globalThis.expect(meta.service).toBe(AutomationSliceFixtures$ReventlessLocal.ShipOrderSpec.targetName);
+      globalThis.expect(meta.msgId !== "evt-1").toBe(true);
+    });
+    globalThis.test("a stored row without a source decodes and starts a new flow", async () => {
+      let stored = JSON.parse(`{"item":{"orderId":"ord-9","address":"x"},"status":"Pending","createdAt":"2026-01-01T00:00:00Z","retryCount":0}`);
+      let row = Util_Sury$Reventless.fromJson(stored, AutomationSlice_Callback$ReventlessCore.todoRowSchema);
+      globalThis.expect(row.source).toEqual(undefined);
+      Callback.todoItems["ord-9"] = row;
+      let published = {
+        contents: []
+      };
+      await Callback.phase2(async cmds => {
+        published.contents = cmds;
+      });
+      let meta = published.contents[0].meta;
+      globalThis.expect(meta.causationId).toEqual(undefined);
+      globalThis.expect(meta.correlationId).toBe(meta.msgId);
+    });
+    globalThis.test("a row with a source round-trips through its schema", () => {
+      let row_item = {};
+      let row_source = {
+        msgId: "evt-1",
+        correlationId: "flow-1"
+      };
+      let row = {
+        item: row_item,
+        status: "Pending",
+        createdAt: "2026-01-01T00:00:00Z",
+        retryCount: 0,
+        source: row_source
+      };
+      let json = Util_Sury$Reventless.toJson(row, AutomationSlice_Callback$ReventlessCore.todoRowSchema);
+      globalThis.expect(JSON.stringify(json).includes(`"source":{"msgId":"evt-1"`)).toBe(true);
+      globalThis.expect(Util_Sury$Reventless.fromJson(json, AutomationSlice_Callback$ReventlessCore.todoRowSchema)).toEqual(row);
+    });
+  });
 });
 
 export {

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res

@@ -191,7 +191,11 @@ let dcbEventLog = DcbLogMaker.make(
 // CommandTopic without the runtime wiring overhead.)
 // ─────────────────────────────────────────────────────────────
 
+// Every command sent, in order, so a test can read the metas they carried.
+let sentCommands: ref<array<Reventless.Message.commandJson>> = ref([])
+
 let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmdJsons => {
+  sentCommands := sentCommands.contents->Array.concat(cmdJsons)
   let _ = await cmdJsons
   ->Array.map(async cmdJson => {
     let typeName = switch cmdJson.commandJson {
@@ -292,3 +296,16 @@ let readEventTypes = async (orderId: string) => {
   )
   result.events->Array.map(e => e.eventType)
 }
+
+let readEvents = async (orderId: string) => {
+  let logOps = await dcbEventLog->DcbLogMaker.operations->TestRunner.resolve
+  let result = await logOps.read(
+    ~query=[{tags: [{Reventless.DcbTag.key: "orderId", value: orderId}]}],
+  )
+  result.events
+}
+
+let pause = (ms: int): promise<unit> =>
+  Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), ms)
+  })

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res.mjs

@@ -323,7 +323,12 @@ let dcbEventLog = DcbLogMaker.make("TestLog", undefined, {
   }
 }, undefined);
 
+let sentCommands = {
+  contents: []
+};
+
 async function publishJsons(cmdJsons) {
+  sentCommands.contents = sentCommands.contents.concat(cmdJsons);
   await Promise.all(cmdJsons.map(async cmdJson => {
     let dict = cmdJson.commandJson;
     let typeName;
@@ -459,6 +464,22 @@ async function readEventTypes(orderId) {
   return result.events.map(e => e.eventType);
 }
 
+async function readEvents(orderId) {
+  let logOps = await TestRunner$ReventlessLocal.resolve(DcbLogMaker.operations(dcbEventLog));
+  return (await logOps.read([{
+      tags: [{
+          key: "orderId",
+          value: orderId
+        }]
+    }], undefined)).events;
+}
+
+function pause(ms) {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
 export {
   PlaceSpec,
   PlaceDecision,
@@ -471,6 +492,7 @@ export {
   Bus,
   DcbLogMaker,
   dcbEventLog,
+  sentCommands,
   publishJsons,
   publishJsonsOutput,
   PlaceMaker,
@@ -486,5 +508,7 @@ export {
   placeCmdJson,
   withTimeout,
   readEventTypes,
+  readEvents,
+  pause,
 }
 /* moduleUrl Not a pure module */

package/tests/components/automationslice/AutomationSliceSelfDeadlockTest.res

@@ -44,4 +44,34 @@ describe("AutomationSlice self-deadlock regression:", () => {
     expect(eventTypes->Array.includes("Placed"))->toBe(true)
     expect(eventTypes->Array.includes("Shipped"))->toBe(true)
   })
+
+  // The automation's command continues the flow of the event that created its
+  // row: one correlation id from the first command to the last event, and each
+  // message caused by the one before it.
+  testPromise("the automation's command and its events stay in the event's flow", async () => {
+    sentCommands := []
+    let _ = await withTimeout(publishJsons([placeCmdJson("order-2")]), ~ms=1500)
+    let shipped = async () =>
+      (await readEvents("order-2"))->Array.find(e => e.eventType == "Shipped")
+    let waited = ref(0)
+    while (await shipped())->Option.isNone && waited.contents < 100 {
+      await pause(10)
+      waited := waited.contents + 1
+    }
+
+    let events = await readEvents("order-2")
+    let placed = events->Array.find(e => e.eventType == "Placed")->Option.getOrThrow
+    let shipped = events->Array.find(e => e.eventType == "Shipped")->Option.getOrThrow
+    let ship =
+      sentCommands.contents
+      ->Array.find(c => c.id == "order-2" && c.meta.msgId != TestFixtures.testMeta.msgId)
+      ->Option.getOrThrow
+
+    expect(placed.meta.correlationId)->toBe(TestFixtures.testMeta.correlationId)
+    expect(ship.meta.correlationId)->toBe(TestFixtures.testMeta.correlationId)
+    expect(shipped.meta.correlationId)->toBe(TestFixtures.testMeta.correlationId)
+    expect(ship.meta.causationId)->toEqual(Some(placed.meta.msgId))
+    expect(shipped.meta.causationId)->toEqual(Some(ship.meta.msgId))
+    expect(ship.meta.user)->toEqual(TestFixtures.testMeta.user)
+  })
 })

package/tests/components/automationslice/AutomationSliceSelfDeadlockTest.res.mjs

@@ -1,7 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
 import * as AutomationSliceSelfDeadlockFixtures$ReventlessLocal from "./AutomationSliceSelfDeadlockFixtures.res.mjs";
 
 globalThis.describe("AutomationSlice self-deadlock regression:", () => {
@@ -26,6 +28,32 @@ globalThis.describe("AutomationSlice self-deadlock regression:", () => {
     globalThis.expect(eventTypes.includes("Placed")).toBe(true);
     globalThis.expect(eventTypes.includes("Shipped")).toBe(true);
   });
+  globalThis.test("the automation's command and its events stay in the event's flow", async () => {
+    AutomationSliceSelfDeadlockFixtures$ReventlessLocal.sentCommands.contents = [];
+    await AutomationSliceSelfDeadlockFixtures$ReventlessLocal.withTimeout(AutomationSliceSelfDeadlockFixtures$ReventlessLocal.publishJsons([AutomationSliceSelfDeadlockFixtures$ReventlessLocal.placeCmdJson("order-2")]), 1500);
+    let shipped = async () => (await AutomationSliceSelfDeadlockFixtures$ReventlessLocal.readEvents("order-2")).find(e => e.eventType === "Shipped");
+    let waited = 0;
+    while (Stdlib_Option.isNone(await shipped()) && waited < 100) {
+      await AutomationSliceSelfDeadlockFixtures$ReventlessLocal.pause(10);
+      waited = waited + 1 | 0;
+    };
+    let events = await AutomationSliceSelfDeadlockFixtures$ReventlessLocal.readEvents("order-2");
+    let placed = Stdlib_Option.getOrThrow(events.find(e => e.eventType === "Placed"), undefined);
+    let shipped$1 = Stdlib_Option.getOrThrow(events.find(e => e.eventType === "Shipped"), undefined);
+    let ship = Stdlib_Option.getOrThrow(AutomationSliceSelfDeadlockFixtures$ReventlessLocal.sentCommands.contents.find(c => {
+      if (c.id === "order-2") {
+        return c.meta.msgId !== TestFixtures$ReventlessLocal.testMeta.msgId;
+      } else {
+        return false;
+      }
+    }), undefined);
+    globalThis.expect(placed.meta.correlationId).toBe(TestFixtures$ReventlessLocal.testMeta.correlationId);
+    globalThis.expect(ship.meta.correlationId).toBe(TestFixtures$ReventlessLocal.testMeta.correlationId);
+    globalThis.expect(shipped$1.meta.correlationId).toBe(TestFixtures$ReventlessLocal.testMeta.correlationId);
+    globalThis.expect(ship.meta.causationId).toEqual(placed.meta.msgId);
+    globalThis.expect(shipped$1.meta.causationId).toEqual(ship.meta.msgId);
+    globalThis.expect(ship.meta.user).toEqual(TestFixtures$ReventlessLocal.testMeta.user);
+  });
 });
 
 /*  Not a pure module */

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res

@@ -472,4 +472,62 @@ describe("OutboundTranslationSlice Callback", () => {
       },
     )
   })
+
+  // A row keeps the event that created it, so the command sent back continues
+  // the event's flow; without a meta, or for a row stored before, it starts one.
+  describe("the flow", () => {
+    let eventMeta: Reventless.Message.meta = {
+      service: "Payments",
+      time: "2026-01-01T00:00:00Z",
+      user: "user-7",
+      msgId: "evt-1",
+      correlationId: "flow-1",
+    }
+    let publishInto = (published: ref<array<Reventless.Message.commandJson>>) =>
+      async cmds => published := published.contents->Array.concat(cmds)
+
+    testPromise(
+      "the command sent back derives its meta from the event",
+      async () => {
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~metas=[Some(eventMeta)],
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        let published = ref([])
+        await CommandBackCallback.phase2(
+          publishInto(published),
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        let meta = (published.contents->Array.getUnsafe(0)).meta
+        expect(meta.correlationId)->toBe("flow-1")
+        expect(meta.causationId)->toEqual(Some("evt-1"))
+        expect(meta.user)->toEqual(Some("user-7"))
+        expect(meta.service)->toBe("ConfirmPayment")
+      },
+    )
+
+    testPromise(
+      "without a meta, or from a stored row without a source, it starts a new flow",
+      async () => {
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        let stored =
+          JSON.parseOrThrow(`{"item":{"orderId":"ord-2","amount":5},"status":"Pending","createdAt":"2026-01-01T00:00:00Z","retryCount":0}`)->Reventless.Util_Sury.fromJson(
+            todoRowSchema,
+          )
+        expect(stored.source)->toEqual(None)
+        CommandBackCallback.todoItems->Dict.set("ord-2", stored)
+        let published = ref([])
+        await CommandBackCallback.phase2(
+          publishInto(published),
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        expect(published.contents->Array.length)->toBe(2)
+        published.contents->Array.forEach(c => expect(c.meta.causationId)->toEqual(None))
+      },
+    )
+  })
 })

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res.mjs

@@ -3,6 +3,7 @@
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as OutboundTranslationSliceFixtures$ReventlessLocal from "./OutboundTranslationSliceFixtures.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
@@ -90,7 +91,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             email: "test@example.com"
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let items = FireForgetCallback.todoItems;
       globalThis.expect(Object.entries(items).length).toBe(1);
       let row = items["ord-1"];
@@ -107,7 +108,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             email: "test@example.com"
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       await FireForgetCallback.phase1([[
           "evt",
           {
@@ -115,7 +116,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             email: "other@example.com"
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       globalThis.expect(Object.entries(FireForgetCallback.todoItems).length).toBe(1);
     });
     globalThis.test("multiple different events create multiple items", async () => {
@@ -136,7 +137,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             email: "b@example.com"
           }
         ]
-      ], Capabilities$Reventless.none);
+      ], undefined, Capabilities$Reventless.none);
       globalThis.expect(Object.entries(FireForgetCallback.todoItems).length).toBe(2);
     });
   });
@@ -149,7 +150,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             email: "test@example.com"
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -181,7 +182,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -203,7 +204,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -226,7 +227,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
@@ -245,7 +246,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       let row1 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
@@ -283,7 +284,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Failed");
@@ -315,7 +316,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       let newrecord = {...row};
       newrecord.retryCount = 2;
@@ -336,7 +337,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let publish = async _cmds => {};
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
@@ -352,7 +353,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).maxRetries).toEqual(OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.maxRetries);
     });
     globalThis.test("a slice that answers onExhausted has its command published", async () => {
@@ -374,7 +375,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let published = {
         contents: []
       };
@@ -407,7 +408,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let publish = async _cmds => {};
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
@@ -425,7 +426,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let published = {
         contents: []
       };
@@ -456,7 +457,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let failOnAbandonment = async _cmds => Stdlib_JsError.throwWithMessage("topic unavailable");
       await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
       await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
@@ -479,7 +480,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             orderId: "ord-1",
             amount: 50.0
           }
-        ]], Capabilities$Reventless.none);
+        ]], undefined, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       let newrecord = {...row};
       newrecord.retryCount = 2;
@@ -535,7 +536,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             amount: 75.0
           }
         ]
-      ], Capabilities$Reventless.none);
+      ], undefined, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -550,6 +551,57 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       globalThis.expect(publishedCommands.contents.length).toBe(1);
     });
   });
+  globalThis.describe("the flow", () => {
+    let publishInto = published => (async cmds => {
+      published.contents = published.contents.concat(cmds);
+    });
+    globalThis.test("the command sent back derives its meta from the event", async () => {
+      await CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]], [{
+          service: "Payments",
+          time: "2026-01-01T00:00:00Z",
+          user: "user-7",
+          msgId: "evt-1",
+          correlationId: "flow-1"
+        }], Capabilities$Reventless.none);
+      let published = {
+        contents: []
+      };
+      await CommandBackCallback.phase2(publishInto(published), Capabilities$Reventless.none);
+      let meta = published.contents[0].meta;
+      globalThis.expect(meta.correlationId).toBe("flow-1");
+      globalThis.expect(meta.causationId).toEqual("evt-1");
+      globalThis.expect(meta.user).toEqual("user-7");
+      globalThis.expect(meta.service).toBe("ConfirmPayment");
+    });
+    globalThis.test("without a meta, or from a stored row without a source, it starts a new flow", async () => {
+      await CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]], undefined, Capabilities$Reventless.none);
+      let stored = Util_Sury$Reventless.fromJson(JSON.parse(`{"item":{"orderId":"ord-2","amount":5},"status":"Pending","createdAt":"2026-01-01T00:00:00Z","retryCount":0}`), OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema);
+      globalThis.expect(stored.source).toEqual(undefined);
+      CommandBackCallback.todoItems["ord-2"] = stored;
+      let published = {
+        contents: []
+      };
+      await CommandBackCallback.phase2(publishInto(published), Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(2);
+      published.contents.forEach(c => {
+        globalThis.expect(c.meta.causationId).toEqual(undefined);
+      });
+    });
+  });
 });
 
 export {

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePiiTest.res.mjs

@@ -225,7 +225,7 @@ globalThis.describe("an outbound work item with personal data", () => {
     await Callback.phase1([[
         "c-1",
         given
-      ]], keyed);
+      ]], undefined, keyed);
     let stored = Stdlib_Option.getOr(JSON.stringify(Object.entries(Callback.todoItems)), "");
     globalThis.expect(stored.includes("ada@example.org")).toBe(false);
     let match = Object.entries(Callback.todoItems);
@@ -241,18 +241,18 @@ globalThis.describe("an outbound work item with personal data", () => {
     await Callback.phase1([[
         "c-1",
         given
-      ]], keyed);
+      ]], undefined, keyed);
     await Callback.phase1([[
         "c-1",
         given
-      ]], keyed);
+      ]], undefined, keyed);
     globalThis.expect(Object.entries(Callback.todoItems).length).toBe(1);
   });
   globalThis.test("is opened before it is translated", async () => {
     await Callback.phase1([[
         "c-1",
         given
-      ]], keyed);
+      ]], undefined, keyed);
     await Callback.phase2(publish, keyed);
     globalThis.expect(sent.contents).toEqual(["ada@example.org"]);
   });
@@ -260,7 +260,7 @@ globalThis.describe("an outbound work item with personal data", () => {
     await Callback.phase1([[
         "c-1",
         given
-      ]], keyed);
+      ]], undefined, keyed);
     erased.contents = true;
     await Callback.phase2(publish, keyed);
     globalThis.expect(sent.contents).toEqual([]);
@@ -270,7 +270,7 @@ globalThis.describe("an outbound work item with personal data", () => {
     await Callback.phase1([[
         "c-1",
         given
-      ]], Capabilities$Reventless.none);
+      ]], undefined, Capabilities$Reventless.none);
     globalThis.expect(Object.entries(Callback.todoItems).map(prim => prim[0])).toEqual(["c-1:ada@example.org"]);
   });
   globalThis.test("is not stored at all where encryption is required and nothing can fingerprint it", async () => {
@@ -278,7 +278,7 @@ globalThis.describe("an outbound work item with personal data", () => {
     await Callback.phase1([[
         "c-1",
         given
-      ]], Capabilities$Reventless.none);
+      ]], undefined, Capabilities$Reventless.none);
     globalThis.expect(Object.entries(Callback.todoItems)).toEqual([]);
   });
 });