@reventlessdev/reventless-local 3.0.0-alpha.316 → 3.0.0-alpha.318

package/tests/adapter/LocalTapLinesTest.res.mjs

@@ -0,0 +1,242 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Nodenet from "node:net";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as LogRedaction$Reventless from "@reventlessdev/reventless-spec/src/util/LogRedaction.res.mjs";
+import * as ViewChange$ReventlessCore from "@reventlessdev/reventless-core/src/ViewChange.res.mjs";
+import * as LocalLogFeed$ReventlessLocal from "../../src/adapter/LocalLogFeed.res.mjs";
+import * as LocalEventTap$ReventlessLocal from "../../src/adapter/LocalEventTap.res.mjs";
+import * as LocalTapLines$ReventlessLocal from "../../src/adapter/LocalTapLines.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+
+function sleep(ms) {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+async function until(msOpt, cond) {
+  let ms = msOpt !== undefined ? msOpt : 2000;
+  let waited = 0;
+  while (!cond() && waited < ms) {
+    await sleep(5);
+    waited = waited + 5 | 0;
+  };
+  return cond();
+}
+
+function connect(port) {
+  return new Promise((resolve, param) => {
+    let c = {
+      contents: undefined
+    };
+    let socket = Nodenet.createConnection(port, "127.0.0.1", () => Stdlib_Option.forEach(c.contents, client => resolve(client)));
+    socket.setEncoding("utf8");
+    socket.on("error", param => {});
+    let client = {
+      socket: socket,
+      received: ""
+    };
+    socket.on("data", chunk => {
+      client.received = client.received + chunk;
+    });
+    c.contents = client;
+  });
+}
+
+function linesOf(c, kind) {
+  return Stdlib_Array.filterMap(c.received.split("\n"), l => {
+    let d;
+    try {
+      d = Stdlib_JSON.Decode.object(JSON.parse(l));
+    } catch (exn) {
+      return;
+    }
+    if (d !== undefined && Primitive_object.equal(d["kind"], kind)) {
+      Stdlib_Dict.$$delete(d, "ts");
+      return d;
+    }
+  });
+}
+
+let rowSchema = Sury.$schema(s => ({
+  name: s.m(Sury.string),
+  token: s.m(Sensitive$Reventless.string)
+}));
+
+async function connectTap() {
+  LocalEventTap$ReventlessLocal.resetForTests();
+  LocalLogFeed$ReventlessLocal.resetForTests();
+  LocalTapLines$ReventlessLocal.resetForTests();
+  LocalLogFeed$ReventlessLocal.install({});
+  LocalTapLines$ReventlessLocal.install();
+  let port = await new Promise((resolve, param) => LocalEventTap$ReventlessLocal.start({}, resolve, undefined));
+  let tap = await connect(port);
+  await until(undefined, () => LocalEventTap$ReventlessLocal.hasReaders());
+  return tap;
+}
+
+async function disconnect(tap) {
+  tap.socket.destroy();
+  LocalTapLines$ReventlessLocal.resetForTests();
+  await LocalEventTap$ReventlessLocal.stopForTests();
+  return LocalLogFeed$ReventlessLocal.resetForTests();
+}
+
+globalThis.describe("LocalTapLines", () => {
+  globalThis.test("an accepted and a rejected command each appear once on the tap", async () => {
+    let tap = await connectTap();
+    CommandTopic_Helpers$ReventlessCore.reportAccepted("Order", "flow-1", "m-1", {
+      entityId: "o-1",
+      eventCount: 2
+    });
+    CommandTopic_Helpers$ReventlessCore.reportRejected("Order", "DomainRejection", "flow-1", "m-2", {
+      errorCode: "AlreadyExists",
+      errorDetail: `{"name":"Widget"}`
+    });
+    await until(undefined, () => linesOf(tap, "commandOutcome").length >= 2);
+    await sleep(20);
+    globalThis.expect(linesOf(tap, "commandOutcome")).toEqual([
+      Object.fromEntries([
+        [
+          "kind",
+          "commandOutcome"
+        ],
+        [
+          "component",
+          "Order"
+        ],
+        [
+          "msgId",
+          "m-1"
+        ],
+        [
+          "correlationId",
+          "flow-1"
+        ],
+        [
+          "outcome",
+          "accepted"
+        ],
+        [
+          "entityId",
+          "o-1"
+        ],
+        [
+          "eventCount",
+          2
+        ]
+      ]),
+      Object.fromEntries([
+        [
+          "kind",
+          "commandOutcome"
+        ],
+        [
+          "component",
+          "Order"
+        ],
+        [
+          "msgId",
+          "m-2"
+        ],
+        [
+          "correlationId",
+          "flow-1"
+        ],
+        [
+          "outcome",
+          "rejected"
+        ],
+        [
+          "errorCode",
+          "AlreadyExists"
+        ],
+        [
+          "cause",
+          "DOMAIN"
+        ]
+      ])
+    ]);
+    globalThis.expect(tap.received.includes("@@RVLESS_EVT@@")).toBe(false);
+    let kept = LocalLogFeed$ReventlessLocal.recentRecords({
+      level: "Warn"
+    }, undefined).filter(r => r.message === "command rejected");
+    globalThis.expect(kept.map(r => [
+      r.comp,
+      r.annotations["msgId"]
+    ])).toEqual([[
+        "CommandTopic(Order)",
+        "m-2"
+      ]]);
+    globalThis.expect(Stdlib_Option.getOr(Stdlib_Option.map(kept[0].detail, j => JSON.stringify(j)), "")).toBe(`{"component":"Order","errorCode":"AlreadyExists","cause":"DOMAIN","errorDetail":{"name":"Widget"}}`);
+    return await disconnect(tap);
+  });
+  globalThis.test("an infrastructure failure is kept as an error", async () => {
+    let tap = await connectTap();
+    CommandTopic_Helpers$ReventlessCore.reportRejected("Order", "InfrastructureFailure", undefined, "m-3", {
+      errorCode: "AppendFailed",
+      errorDetail: "store down"
+    });
+    let kept = LocalLogFeed$ReventlessLocal.recentRecords({
+      level: "Error"
+    }, undefined).filter(r => r.message === "command rejected");
+    globalThis.expect(kept.length).toBe(1);
+    return await disconnect(tap);
+  });
+  globalThis.test("a view change is sent with its values redacted", async () => {
+    let tap = await connectTap();
+    let onChange = ViewChange$ReventlessCore.reporter("ReadModel(Accounts)", "Accounts", r => Util_Sury$Reventless.toJson(r, rowSchema));
+    onChange({
+      key: "a-1",
+      kind: "Changed",
+      before: {
+        name: "Ada",
+        token: "old-secret"
+      },
+      after: {
+        name: "Ada L.",
+        token: "new-secret"
+      },
+      sources: [{
+          msgId: "m-1",
+          correlationId: "flow-1",
+          entityId: "a-1",
+          entityType: "Account"
+        }]
+    });
+    await until(undefined, () => linesOf(tap, "viewChange").length >= 1);
+    let lines = linesOf(tap, "viewChange");
+    globalThis.expect(lines.length).toBe(1);
+    let line = JSON.stringify(lines[0]);
+    globalThis.expect(line.includes("secret")).toBe(false);
+    globalThis.expect(line.includes(LogRedaction$Reventless.placeholder)).toBe(true);
+    globalThis.expect(line.includes(`"name":"Ada L."`)).toBe(true);
+    globalThis.expect(line.startsWith(`{"kind":"viewChange","view":"Accounts","key":"a-1","change":"changed","fields":["name","token"],"sources":[{"msgId":"m-1","correlationId":"flow-1","entityId":"a-1","entityType":"Account"}],"correlationId":"flow-1","before":`)).toBe(true);
+    return await disconnect(tap);
+  });
+});
+
+let Outcome;
+
+let ViewChange;
+
+export {
+  Outcome,
+  ViewChange,
+  sleep,
+  until,
+  connect,
+  linesOf,
+  rowSchema,
+  connectTap,
+  disconnect,
+}
+/* rowSchema Not a pure module */

package/tests/adapter/PlatformSubscriptionsTest.res

@@ -0,0 +1,123 @@
+// The platform API's subscriptions over the WebSocket: checked for the admin
+// group like its queries, with the identity built from the connection; and the
+// two feeds delivered as subscriptions, filtered.
+
+@@warning("-44")
+
+open JestGlobals
+
+module Logger = ReventlessCore.Logger
+
+type outcome = {values: array<JSON.t>, error: Nullable.t<string>}
+
+@module("./GraphQLWsFixtures.mjs")
+external collect: (string, string, dict<string>, int, int, unit => unit) => promise<outcome> =
+  "collect"
+
+let sleep = (ms: int): promise<unit> =>
+  Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), ms)
+  })
+
+// A port of its own, away from the platform's defaults.
+let port = 47_000 + Float.toInt(Math.random() *. 2000.)
+let url = `ws://127.0.0.1:${port->Int.toString}/graphql`
+
+let asAdmin = Dict.fromArray([("X-User", "admin")])
+let asUser = Dict.make()
+
+let field = (json: JSON.t, key: string): option<string> =>
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(key))
+  ->Option.flatMap(JSON.Decode.string)
+
+describe("the platform API's subscriptions", () => {
+  beforeAllAsync(async () => {
+    LocalLogFeed.resetForTests()
+    LocalLogFeed.install(~env=Dict.make())
+    LocalEventTap.resetForTests()
+    PlatformGraphQL_Server.reset()
+    LocalPlatformObserve.registerGraphQL(PlatformGraphQL_Server.asInterface)
+    // One of the kind the platform registered before: a plain topic field.
+    PlatformGraphQL_Server.registerSubscriptions(
+      ~sdlFields=["  onTestChange: String"],
+      ~resolvers=Dict.fromArray([
+        ("onTestChange", LocalGraphQL_SubscriptionResolvers.makeFieldResolver("onTestChange")),
+      ]),
+    )
+    PlatformGraphQL_Server.start(~port, ~contextFactory=Auth_GraphqlContext.buildAuthContext, ())
+    await sleep(100)
+  })
+  afterAll(() => {
+    PlatformGraphQL_Server.stop()
+    PlatformGraphQL_Server.reset()
+    LocalLogFeed.resetForTests()
+    LocalEventTap.resetForTests()
+  })
+
+  test("are refused to a caller without the admin group", async () => {
+    let refused = async query => {
+      let o = await collect(url, query, asUser, 1, 2000, () => ())
+      o.values->Array.length == 0 && o.error->Nullable.toOption->Option.isSome
+    }
+    expect(await refused("subscription { Platform_LogAppended }"))->toBe(true)
+    expect(await refused("subscription { Platform_EventAppended }"))->toBe(true)
+    expect(await refused("subscription { onTestChange }"))->toBe(true)
+  })
+
+  test("deliver the log feed to an admin, filtered, the recent records first", async () => {
+    Logger.emit(~level=Info, ~comp="Projection", ~plugin="Ordering", "quiet")
+    Logger.emit(~level=Warn, ~comp="Projection", ~plugin="Ordering", "loud")
+    Logger.emit(~level=Error, ~comp="Projection", ~plugin="Catalog", "elsewhere")
+    let o = await collect(
+      url,
+      `subscription { Platform_LogAppended(filter: {plugins: ["Ordering"], level: WARN}) }`,
+      asAdmin,
+      2,
+      3000,
+      () => {
+        let _ = setTimeout(
+          () => {
+            Logger.emit(~level=Info, ~comp="Projection", ~plugin="Ordering", "quiet again")
+            Logger.emit(~level=Error, ~comp="Projection", ~plugin="Ordering", "live")
+          },
+          100,
+        )
+      },
+    )
+    expect(o.error->Nullable.toOption)->toEqual(None)
+    expect(o.values->Array.map(v => v->field("message")))->toEqual([Some("loud"), Some("live")])
+  })
+
+  test("deliver the event tap to an admin, filtered", async () => {
+    let ticker = ref(None)
+    let o = await collect(
+      url,
+      `subscription { Platform_EventAppended(filter: {eventTypes: ["Placed"]}) }`,
+      asAdmin,
+      2,
+      3000,
+      () =>
+        ticker :=
+          Some(
+            setInterval(
+              () => {
+                LocalEventTap.publish({
+                  line: `@@RVLESS_EVT@@ {"event":"domainEvent","name":"shipped"}`,
+                  facets: {eventType: "Shipped"},
+                })
+                LocalEventTap.publish({
+                  line: `@@RVLESS_EVT@@ {"event":"domainEvent","name":"placed"}`,
+                  facets: {eventType: "Placed"},
+                })
+              },
+              20,
+            ),
+          ),
+    )
+    ticker.contents->Option.forEach(clearInterval)
+    expect(o.error->Nullable.toOption)->toEqual(None)
+    expect(o.values->Array.map(v => v->field("name")))->toEqual([Some("placed"), Some("placed")])
+  })
+})

package/tests/adapter/PlatformSubscriptionsTest.res.mjs

@@ -0,0 +1,132 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as GraphQLWsFixturesMjs from "./GraphQLWsFixtures.mjs";
+import * as LocalLogFeed$ReventlessLocal from "../../src/adapter/LocalLogFeed.res.mjs";
+import * as LocalEventTap$ReventlessLocal from "../../src/adapter/LocalEventTap.res.mjs";
+import * as Auth_GraphqlContext$ReventlessLocal from "../../src/adapter/Auth/Auth_GraphqlContext.res.mjs";
+import * as LocalPlatformObserve$ReventlessLocal from "../../src/adapter/LocalPlatformObserve.res.mjs";
+import * as PlatformGraphQL_Server$ReventlessLocal from "../../src/adapter/PlatformGraphQL_Server.res.mjs";
+import * as LocalGraphQL_SubscriptionResolvers$ReventlessLocal from "../../src/adapter/Api/LocalGraphQL_SubscriptionResolvers.res.mjs";
+
+function collect(prim0, prim1, prim2, prim3, prim4, prim5) {
+  return GraphQLWsFixturesMjs.collect(prim0, prim1, prim2, prim3, prim4, prim5);
+}
+
+function sleep(ms) {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+let port = 47000 + (Math.random() * 2000 | 0) | 0;
+
+let url = `ws://127.0.0.1:` + port.toString() + `/graphql`;
+
+let asAdmin = Object.fromEntries([[
+    "X-User",
+    "admin"
+  ]]);
+
+let asUser = {};
+
+function field(json, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.string);
+}
+
+globalThis.describe("the platform API's subscriptions", () => {
+  globalThis.beforeAll(async () => {
+    LocalLogFeed$ReventlessLocal.resetForTests();
+    LocalLogFeed$ReventlessLocal.install({});
+    LocalEventTap$ReventlessLocal.resetForTests();
+    PlatformGraphQL_Server$ReventlessLocal.reset();
+    LocalPlatformObserve$ReventlessLocal.registerGraphQL(PlatformGraphQL_Server$ReventlessLocal.asInterface);
+    PlatformGraphQL_Server$ReventlessLocal.registerSubscriptions(["  onTestChange: String"], Object.fromEntries([[
+        "onTestChange",
+        LocalGraphQL_SubscriptionResolvers$ReventlessLocal.makeFieldResolver("onTestChange")
+      ]]));
+    PlatformGraphQL_Server$ReventlessLocal.start(port, Auth_GraphqlContext$ReventlessLocal.buildAuthContext, undefined);
+    return await sleep(100);
+  });
+  globalThis.afterAll(() => {
+    PlatformGraphQL_Server$ReventlessLocal.stop();
+    PlatformGraphQL_Server$ReventlessLocal.reset();
+    LocalLogFeed$ReventlessLocal.resetForTests();
+    LocalEventTap$ReventlessLocal.resetForTests();
+  });
+  globalThis.test("are refused to a caller without the admin group", async () => {
+    let refused = async query => {
+      let o = await collect(url, query, asUser, 1, 2000, () => {});
+      if (o.values.length === 0) {
+        return Stdlib_Option.isSome(Primitive_option.fromNullable(o.error));
+      } else {
+        return false;
+      }
+    };
+    globalThis.expect(await refused("subscription { Platform_LogAppended }")).toBe(true);
+    globalThis.expect(await refused("subscription { Platform_EventAppended }")).toBe(true);
+    globalThis.expect(await refused("subscription { onTestChange }")).toBe(true);
+  });
+  globalThis.test("deliver the log feed to an admin, filtered, the recent records first", async () => {
+    Logger$ReventlessCore.emit("Info", "Projection", "Ordering", undefined, undefined, "quiet");
+    Logger$ReventlessCore.emit("Warn", "Projection", "Ordering", undefined, undefined, "loud");
+    Logger$ReventlessCore.emit("Error", "Projection", "Catalog", undefined, undefined, "elsewhere");
+    let o = await collect(url, `subscription { Platform_LogAppended(filter: {plugins: ["Ordering"], level: WARN}) }`, asAdmin, 2, 3000, () => {
+      setTimeout(() => {
+        Logger$ReventlessCore.emit("Info", "Projection", "Ordering", undefined, undefined, "quiet again");
+        Logger$ReventlessCore.emit("Error", "Projection", "Ordering", undefined, undefined, "live");
+      }, 100);
+    });
+    globalThis.expect(Primitive_option.fromNullable(o.error)).toEqual(undefined);
+    globalThis.expect(o.values.map(v => field(v, "message"))).toEqual([
+      "loud",
+      "live"
+    ]);
+  });
+  globalThis.test("deliver the event tap to an admin, filtered", async () => {
+    let ticker = {
+      contents: undefined
+    };
+    let o = await collect(url, `subscription { Platform_EventAppended(filter: {eventTypes: ["Placed"]}) }`, asAdmin, 2, 3000, () => {
+      ticker.contents = Primitive_option.some(setInterval(() => {
+        LocalEventTap$ReventlessLocal.publish({
+          line: `@@RVLESS_EVT@@ {"event":"domainEvent","name":"shipped"}`,
+          facets: {
+            eventType: "Shipped"
+          }
+        });
+        LocalEventTap$ReventlessLocal.publish({
+          line: `@@RVLESS_EVT@@ {"event":"domainEvent","name":"placed"}`,
+          facets: {
+            eventType: "Placed"
+          }
+        });
+      }, 20));
+    });
+    Stdlib_Option.forEach(ticker.contents, prim => {
+      clearInterval(prim);
+    });
+    globalThis.expect(Primitive_option.fromNullable(o.error)).toEqual(undefined);
+    globalThis.expect(o.values.map(v => field(v, "name"))).toEqual([
+      "placed",
+      "placed"
+    ]);
+  });
+});
+
+let Logger;
+
+export {
+  Logger,
+  collect,
+  sleep,
+  port,
+  url,
+  asAdmin,
+  asUser,
+  field,
+}
+/* port Not a pure module */

package/tests/components/automationslice/AutomationSliceCallbackTest.res

@@ -333,4 +333,84 @@ describe("AutomationSlice Callback (mixed-source)", () => {
       },
     )
   })
+
+  // A row keeps the event that created it, so the command sent for it continues
+  // the event's flow; a row stored before rows kept one still runs.
+  describe("the flow", () => {
+    let withMeta = (json: JSON.t, ~msgId, ~correlationId) =>
+      switch json {
+      | Object(d) =>
+        let meta: Reventless.Message.meta = {
+          service: ShipOrderSource.name,
+          time: "2026-01-01T00:00:00Z",
+          user: "user-7",
+          msgId,
+          correlationId,
+          traceparent: "00-trace-span-01",
+        }
+        d->Dict.set("meta", meta->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema))
+        JSON.Object(d)
+      | other => other
+      }
+
+    testPromise(
+      "the command derives its meta from the event that created the row",
+      async () => {
+        let json =
+          encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))->withMeta(
+            ~msgId="evt-1",
+            ~correlationId="flow-1",
+          )
+        await Callback.phase1([json], testContext, ~capabilities=Reventless.Capabilities.none)
+        expect((Callback.todoItems->Dict.getUnsafe("ord-1")).source)->toEqual(
+          Some({
+            ReventlessCore.Message.msgId: "evt-1",
+            correlationId: "flow-1",
+            user: "user-7",
+            traceparent: "00-trace-span-01",
+          }),
+        )
+        let published = ref([])
+        await Callback.phase2(async cmds => published := cmds)
+        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.traceparent)->toEqual(Some("00-trace-span-01"))
+        expect(meta.service)->toBe(ShipOrderSpec.targetName)
+        expect(meta.msgId != "evt-1")->toBe(true)
+      },
+    )
+
+    testPromise(
+      "a stored row without a source decodes and starts a new flow",
+      async () => {
+        let stored = JSON.parseOrThrow(`{"item":{"orderId":"ord-9","address":"x"},"status":"Pending","createdAt":"2026-01-01T00:00:00Z","retryCount":0}`)
+        let row = stored->Reventless.Util_Sury.fromJson(todoRowSchema)
+        expect(row.source)->toEqual(None)
+        Callback.todoItems->Dict.set("ord-9", row)
+        let published = ref([])
+        await Callback.phase2(async cmds => published := cmds)
+        let meta = (published.contents->Array.getUnsafe(0)).meta
+        expect(meta.causationId)->toEqual(None)
+        expect(meta.correlationId)->toBe(meta.msgId)
+      },
+    )
+
+    testSync(
+      "a row with a source round-trips through its schema",
+      () => {
+        let row: todoRow = {
+          item: JSON.Encode.object(Dict.make()),
+          status: Pending,
+          createdAt: "2026-01-01T00:00:00Z",
+          retryCount: 0,
+          source: {ReventlessCore.Message.msgId: "evt-1", correlationId: "flow-1"},
+        }
+        let json = row->Reventless.Util_Sury.toJson(todoRowSchema)
+        expect(json->JSON.stringify->String.includes(`"source":{"msgId":"evt-1"`))->toBe(true)
+        expect(json->Reventless.Util_Sury.fromJson(todoRowSchema))->toEqual(row)
+      },
+    )
+  })
 })

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 {