@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res

@@ -0,0 +1,213 @@
+// Plan 04 fixtures — AutomationSlice with two sources (Aggregate + DCB).
+// Verifies mixed-source dispatch: both sources feed the same slice's TODO list,
+// each going through its own per-source `collect`/`resolve`, and `process`
+// produces commands for the target.
+
+open TestFixtures
+open Reventless
+
+// ─────────────────────────────────────────────────────────────
+// Source 1: simulated Aggregate — emits OrderShipped events
+// ─────────────────────────────────────────────────────────────
+
+module OrderAggregateSource = {
+  module Id = Id.String
+  let name = "OrderAggregateEventTopic"
+  @schema
+  type event =
+    | OrderShipped({orderId: string, productId: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Source 2: simulated DCB EventLog — emits StockReserved events
+// ─────────────────────────────────────────────────────────────
+
+module InventoryDcbSource = {
+  module Id = Id.String
+  let name = "InventoryDcbEventLog"
+  @schema
+  type event =
+    | StockReserved({orderId: string, productId: string})
+    | StockReleased({orderId: string, productId: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// AutomationSlice spec — joins both sources by composite key
+// ─────────────────────────────────────────────────────────────
+
+module AutoFulfillSpec = {
+  let name = "AutoFulfill"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type todoItem = {
+    orderId: string,
+    productId: string,
+    fromAggregate: bool, // tracks which source produced this item
+  }
+
+  @schema
+  type command = MarkFulfilled({
+    orderId: @s.matches(DcbTag.string) string,
+    productId: @s.matches(DcbTag.string) string,
+  })
+
+  let maxRetries = 3
+  let heartbeatInterval = 60
+  let targetName = "MarkFulfilled"
+}
+
+// Forward-declared per-source mappings live below; the merged `Automation`
+// module type also exposes `mappings` + `module type Mapping`, which we
+// populate after `FromOrderAggregate` / `FromInventoryDcb` are in scope.
+
+// ─────────────────────────────────────────────────────────────
+// Mapping 1: Aggregate source → todoItem (with `fromAggregate=true`)
+// ─────────────────────────────────────────────────────────────
+
+module FromOrderAggregate = AutomationSlice.Mapping.Make(
+  OrderAggregateSource,
+  AutoFulfillSpec,
+  {
+    let collect = (event: OrderAggregateSource.event, _ctx) =>
+      switch event {
+      | OrderShipped({orderId, productId}) => [
+          (
+            orderId ++ ":" ++ productId,
+            ({orderId, productId, fromAggregate: true}: AutoFulfillSpec.todoItem),
+          ),
+        ]
+      }
+    let resolve = (_event: OrderAggregateSource.event) => None
+  },
+)
+
+// ─────────────────────────────────────────────────────────────
+// Mapping 2: DCB source → todoItem (with `fromAggregate=false`)
+//   Also resolves on StockReleased — releases roll back any pending TODO.
+// ─────────────────────────────────────────────────────────────
+
+module FromInventoryDcb = AutomationSlice.Mapping.Make(
+  InventoryDcbSource,
+  AutoFulfillSpec,
+  {
+    let collect = (event: InventoryDcbSource.event, _ctx) =>
+      switch event {
+      | StockReserved({orderId, productId}) => [
+          (
+            orderId ++ ":" ++ productId,
+            ({orderId, productId, fromAggregate: false}: AutoFulfillSpec.todoItem),
+          ),
+        ]
+      | StockReleased(_) => []
+      }
+    let resolve = (event: InventoryDcbSource.event) =>
+      switch event {
+      | StockReleased({orderId, productId}) => Some(orderId ++ ":" ++ productId)
+      | StockReserved(_) => None
+      }
+  },
+)
+
+// ─────────────────────────────────────────────────────────────
+// Mappings collection
+// ─────────────────────────────────────────────────────────────
+
+module AutoFulfillAutomation: AutomationSlice.Automation
+  with module Spec := AutoFulfillSpec = {
+  let process = (id, item: AutoFulfillSpec.todoItem) =>
+    Some((id, AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId})))
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = AutomationSlice.Mappings.Make(AutoFulfillSpec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(FromOrderAggregate), module(FromInventoryDcb)]
+}
+
+// ─────────────────────────────────────────────────────────────
+// allEventTopics — two entries, one per source (matches mapping sourceNames)
+// ─────────────────────────────────────────────────────────────
+
+let aggregateResource: ReventlessInfra.Adapter.resource = ReventlessInfra.Adapter.make(
+  ~name=OrderAggregateSource.name->Pulumi.Output.make,
+  ~id=OrderAggregateSource.name->Pulumi.Output.make,
+  ~urn=OrderAggregateSource.name->Pulumi.Output.make,
+  ~service="memory:InMemory"->Pulumi.Output.make,
+)
+
+let dcbResource: ReventlessInfra.Adapter.resource = ReventlessInfra.Adapter.make(
+  ~name=InventoryDcbSource.name->Pulumi.Output.make,
+  ~id=InventoryDcbSource.name->Pulumi.Output.make,
+  ~urn=InventoryDcbSource.name->Pulumi.Output.make,
+  ~service="memory:InMemory"->Pulumi.Output.make,
+)
+
+let allEventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
+  (OrderAggregateSource.name, {ReventlessInfra.EventTopic.resources: [aggregateResource]}),
+  (InventoryDcbSource.name, {ReventlessInfra.EventTopic.resources: [dcbResource]}),
+])
+
+// ─────────────────────────────────────────────────────────────
+// Isolated bus + Pulumi mock mode
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build AutomationSlice
+// ─────────────────────────────────────────────────────────────
+
+module AutomationSliceMaker = AutomationSlice_Builder.Make(Bus)
+module AutoFulfill = AutomationSliceMaker.Make(
+  AutoFulfillSpec,
+  AutoFulfillAutomation,
+)
+
+// Mirrors the context that `Plugin_Builder` constructs for local deployments
+// (environment from `LocalPluginSpec.environment`, platformName "local").
+let testContext: Reventless.AutomationSlice.context = {
+  environment: "local",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: AutoFulfillSpec.name,
+}
+
+// publishJsons — capture commands instead of round-tripping through a CommandTopic.
+let publishedCommands: ref<array<Reventless.Message.commandJson>> = ref([])
+let mockPublishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+  publishedCommands := publishedCommands.contents->Array.concat(cmds)
+}
+
+let slice = AutoFulfill.make(
+  ~allEventTopics,
+  ~publishJsons=mockPublishJsons->Pulumi.Output.make,
+  ~context=testContext,
+)
+
+// ─────────────────────────────────────────────────────────────
+// Test helpers
+// ─────────────────────────────────────────────────────────────
+
+let publishAggregateEvent = async (id, event: OrderAggregateSource.event) => {
+  let meta = makeTestMeta(~service=OrderAggregateSource.name)
+  let eventJson = JSON.Encode.object(
+    Dict.fromArray([
+      ("id", id->JSON.Encode.string),
+      ("meta", meta->S.reverseConvertToJsonOrThrow(Message.metaSchema)),
+      ("event", event->S.reverseConvertToJsonOrThrow(OrderAggregateSource.eventSchema)),
+    ]),
+  )
+  await Bus.publishEvent(OrderAggregateSource.name, "test", meta, eventJson)
+}
+
+let publishDcbEvent = async (id, event: InventoryDcbSource.event) => {
+  let meta = makeTestMeta(~service=InventoryDcbSource.name)
+  let eventJson = JSON.Encode.object(
+    Dict.fromArray([
+      ("id", id->JSON.Encode.string),
+      ("meta", meta->S.reverseConvertToJsonOrThrow(Message.metaSchema)),
+      ("event", event->S.reverseConvertToJsonOrThrow(InventoryDcbSource.eventSchema)),
+    ]),
+  )
+  await Bus.publishEvent(InventoryDcbSource.name, "test", meta, eventJson)
+}

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

@@ -0,0 +1,268 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as AutomationSlice_Builder$ReventlessLocal from "../../../src/components/AutomationSlice_Builder.res.mjs";
+
+let name = "OrderAggregateEventTopic";
+
+let eventSchema = S.schema(s => ({
+  TAG: "OrderShipped",
+  orderId: s.m(S.string),
+  productId: s.m(S.string)
+}));
+
+let OrderAggregateSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let name$1 = "InventoryDcbEventLog";
+
+let eventSchema$1 = S.union([
+  S.schema(s => ({
+    TAG: "StockReserved",
+    orderId: s.m(S.string),
+    productId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "StockReleased",
+    orderId: s.m(S.string),
+    productId: s.m(S.string)
+  }))
+]);
+
+let InventoryDcbSource = {
+  Id: undefined,
+  name: name$1,
+  eventSchema: eventSchema$1
+};
+
+let name$2 = "AutoFulfill";
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  productId: s.m(S.string),
+  fromAggregate: s.m(S.bool)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "MarkFulfilled",
+  orderId: s.m(DcbTag$Reventless.string),
+  productId: s.m(DcbTag$Reventless.string)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let AutoFulfillSpec = {
+  name: name$2,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "MarkFulfilled",
+  commandAuthorization: commandAuthorization
+};
+
+function collect(event, _ctx) {
+  let productId = event.productId;
+  let orderId = event.orderId;
+  return [[
+      orderId + ":" + productId,
+      {
+        orderId: orderId,
+        productId: productId,
+        fromAggregate: true
+      }
+    ]];
+}
+
+function resolve(_event) {
+  
+}
+
+let FromOrderAggregate = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(AutoFulfillSpec)({
+  collect: collect,
+  resolve: resolve
+});
+
+function collect$1(event, _ctx) {
+  if (event.TAG !== "StockReserved") {
+    return [];
+  }
+  let productId = event.productId;
+  let orderId = event.orderId;
+  return [[
+      orderId + ":" + productId,
+      {
+        orderId: orderId,
+        productId: productId,
+        fromAggregate: false
+      }
+    ]];
+}
+
+function resolve$1(event) {
+  if (event.TAG === "StockReserved") {
+    return;
+  } else {
+    return event.orderId + ":" + event.productId;
+  }
+}
+
+let FromInventoryDcb = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name$1,
+  eventSchema: eventSchema$1
+})(AutoFulfillSpec)({
+  collect: collect$1,
+  resolve: resolve$1
+});
+
+function process(id, item) {
+  return [
+    id,
+    {
+      TAG: "MarkFulfilled",
+      orderId: item.orderId,
+      productId: item.productId
+    }
+  ];
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(AutoFulfillSpec);
+
+let mappings = [
+  FromOrderAggregate,
+  FromInventoryDcb
+];
+
+let AutoFulfillAutomation = {
+  process: process,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let aggregateResource = Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output(name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let dcbResource = Adapter$ReventlessInfra.make(Pulumi.output(name$1), Pulumi.output(name$1), Pulumi.output(name$1), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let allEventTopics = Object.fromEntries([
+  [
+    name,
+    {
+      resources: [aggregateResource]
+    }
+  ],
+  [
+    name$1,
+    {
+      resources: [dcbResource]
+    }
+  ]
+]);
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let AutoFulfill = AutomationSliceMaker.Make(AutoFulfillSpec)(AutoFulfillAutomation);
+
+let testContext = {
+  environment: "local",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: name$2
+};
+
+let publishedCommands = {
+  contents: []
+};
+
+async function mockPublishJsons(cmds) {
+  publishedCommands.contents = publishedCommands.contents.concat(cmds);
+}
+
+let slice = AutoFulfill.make(allEventTopics, Pulumi.output(mockPublishJsons), testContext, undefined);
+
+async function publishAggregateEvent(id, event) {
+  let meta = TestFixtures$ReventlessLocal.makeTestMeta(name);
+  let eventJson = Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      S.reverseConvertToJsonOrThrow(event, eventSchema)
+    ]
+  ]);
+  return await Bus.publishEvent(name, "test", meta, eventJson);
+}
+
+async function publishDcbEvent(id, event) {
+  let meta = TestFixtures$ReventlessLocal.makeTestMeta(name$1);
+  let eventJson = Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      S.reverseConvertToJsonOrThrow(event, eventSchema$1)
+    ]
+  ]);
+  return await Bus.publishEvent(name$1, "test", meta, eventJson);
+}
+
+export {
+  OrderAggregateSource,
+  InventoryDcbSource,
+  AutoFulfillSpec,
+  FromOrderAggregate,
+  FromInventoryDcb,
+  AutoFulfillAutomation,
+  aggregateResource,
+  dcbResource,
+  allEventTopics,
+  Bus,
+  AutomationSliceMaker,
+  AutoFulfill,
+  testContext,
+  publishedCommands,
+  mockPublishJsons,
+  slice,
+  publishAggregateEvent,
+  publishDcbEvent,
+}
+/* eventSchema Not a pure module */

package/tests/components/automationslice/MixedSourceAutomationSliceTest.res

@@ -0,0 +1,118 @@
+// Plan 04 integration test — AutomationSlice consumes events from two sources
+// (Aggregate + DCB EventLog) and drives a single TODO list to MarkFulfilled
+// commands. Verifies per-source decode dispatch, context plumbing, and that
+// commands surface via publishJsons.
+
+open JestGlobals
+open MixedSourceAutomationSliceFixtures
+
+describe("MixedSource AutomationSlice", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await aggregateResource.name->TestRunner.resolve
+    let _ = await dcbResource.name->TestRunner.resolve
+    // Extra microtask flushes: subscription registration in
+    // LocalEventCollectorChannel.connect is fire-and-forget via
+    // `Effect.runPromise->ignore`, so we need the runtime to drain those
+    // microtasks before publishing events.
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+  })
+
+  let _ = beforeEach(() => {
+    publishedCommands := []
+  })
+
+  testPromise("Aggregate-source event creates a TODO and produces a command", async () => {
+    publishedCommands := []
+    let _ = await publishAggregateEvent(
+      "env-a1",
+      OrderShipped({orderId: "o1", productId: "p1"}),
+    )
+
+    // Trigger phase2 manually since we don't have a heartbeat in this test.
+    let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    await ops.processPending()
+
+    expect(publishedCommands.contents->Array.length)->toBe(1)
+    let cmd = publishedCommands.contents->Array.getUnsafe(0)
+    expect(cmd.id)->toBe("o1:p1")
+  })
+
+  testPromise("DCB-source StockReserved creates a TODO and produces a command", async () => {
+    publishedCommands := []
+    let _ = await publishDcbEvent(
+      "env-d1",
+      StockReserved({orderId: "o2", productId: "p2"}),
+    )
+
+    let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    await ops.processPending()
+
+    expect(publishedCommands.contents->Array.length)->toBe(1)
+    let cmd = publishedCommands.contents->Array.getUnsafe(0)
+    expect(cmd.id)->toBe("o2:p2")
+  })
+
+  testPromise("DCB-source StockReleased after a Processing item is idempotent", async () => {
+    publishedCommands := []
+    // Reserve fires phase1+phase2 (inline) — produces 1 command, item becomes
+    // Processing. StockReleased then resolves the item to Completed —
+    // subsequent processPending calls produce no further commands for it.
+    let _ = await publishDcbEvent(
+      "env-d2",
+      StockReserved({orderId: "o3", productId: "p3"}),
+    )
+    let _ = await publishDcbEvent(
+      "env-d3",
+      StockReleased({orderId: "o3", productId: "p3"}),
+    )
+
+    expect(publishedCommands.contents->Array.length)->toBe(1)
+
+    // Reset and call processPending again — already-Processing/Completed item
+    // shouldn't generate a duplicate.
+    publishedCommands := []
+    let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    await ops.processPending()
+    expect(publishedCommands.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("both sources can drive items into the same TODO list independently", async () => {
+    publishedCommands := []
+    let _ = await publishAggregateEvent(
+      "env-a2",
+      OrderShipped({orderId: "o4", productId: "p4"}),
+    )
+    let _ = await publishDcbEvent(
+      "env-d4",
+      StockReserved({orderId: "o5", productId: "p5"}),
+    )
+
+    let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    await ops.processPending()
+
+    expect(publishedCommands.contents->Array.length)->toBe(2)
+    let ids = publishedCommands.contents->Array.map(c => c.id)
+    expect(ids->Array.includes("o4:p4"))->toBe(true)
+    expect(ids->Array.includes("o5:p5"))->toBe(true)
+  })
+
+  testPromise("first-writer-wins idempotency across mappings sharing an ID", async () => {
+    publishedCommands := []
+    // Both sources produce the same composite ID — second arrival is ignored.
+    let _ = await publishAggregateEvent(
+      "env-a3",
+      OrderShipped({orderId: "o6", productId: "p6"}),
+    )
+    let _ = await publishDcbEvent(
+      "env-d5",
+      StockReserved({orderId: "o6", productId: "p6"}),
+    )
+
+    let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    await ops.processPending()
+
+    expect(publishedCommands.contents->Array.length)->toBe(1)
+  })
+})

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

@@ -0,0 +1,99 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 MixedSourceAutomationSliceFixtures$ReventlessLocal from "./MixedSourceAutomationSliceFixtures.res.mjs";
+
+globalThis.describe("MixedSource AutomationSlice", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(MixedSourceAutomationSliceFixtures$ReventlessLocal.slice));
+    await TestRunner$ReventlessLocal.resolve(MixedSourceAutomationSliceFixtures$ReventlessLocal.aggregateResource.name);
+    await TestRunner$ReventlessLocal.resolve(MixedSourceAutomationSliceFixtures$ReventlessLocal.dcbResource.name);
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+  globalThis.beforeEach(() => {
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+  });
+  globalThis.test("Aggregate-source event creates a TODO and produces a command", async () => {
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishAggregateEvent("env-a1", {
+      TAG: "OrderShipped",
+      orderId: "o1",
+      productId: "p1"
+    });
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(MixedSourceAutomationSliceFixtures$ReventlessLocal.slice));
+    await ops.processPending();
+    globalThis.expect(MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.length).toBe(1);
+    let cmd = MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents[0];
+    globalThis.expect(cmd.id).toBe("o1:p1");
+  });
+  globalThis.test("DCB-source StockReserved creates a TODO and produces a command", async () => {
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishDcbEvent("env-d1", {
+      TAG: "StockReserved",
+      orderId: "o2",
+      productId: "p2"
+    });
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(MixedSourceAutomationSliceFixtures$ReventlessLocal.slice));
+    await ops.processPending();
+    globalThis.expect(MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.length).toBe(1);
+    let cmd = MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents[0];
+    globalThis.expect(cmd.id).toBe("o2:p2");
+  });
+  globalThis.test("DCB-source StockReleased after a Processing item is idempotent", async () => {
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishDcbEvent("env-d2", {
+      TAG: "StockReserved",
+      orderId: "o3",
+      productId: "p3"
+    });
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishDcbEvent("env-d3", {
+      TAG: "StockReleased",
+      orderId: "o3",
+      productId: "p3"
+    });
+    globalThis.expect(MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.length).toBe(1);
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(MixedSourceAutomationSliceFixtures$ReventlessLocal.slice));
+    await ops.processPending();
+    globalThis.expect(MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.length).toBe(0);
+  });
+  globalThis.test("both sources can drive items into the same TODO list independently", async () => {
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishAggregateEvent("env-a2", {
+      TAG: "OrderShipped",
+      orderId: "o4",
+      productId: "p4"
+    });
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishDcbEvent("env-d4", {
+      TAG: "StockReserved",
+      orderId: "o5",
+      productId: "p5"
+    });
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(MixedSourceAutomationSliceFixtures$ReventlessLocal.slice));
+    await ops.processPending();
+    globalThis.expect(MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.length).toBe(2);
+    let ids = MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id);
+    globalThis.expect(ids.includes("o4:p4")).toBe(true);
+    globalThis.expect(ids.includes("o5:p5")).toBe(true);
+  });
+  globalThis.test("first-writer-wins idempotency across mappings sharing an ID", async () => {
+    MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents = [];
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishAggregateEvent("env-a3", {
+      TAG: "OrderShipped",
+      orderId: "o6",
+      productId: "p6"
+    });
+    await MixedSourceAutomationSliceFixtures$ReventlessLocal.publishDcbEvent("env-d5", {
+      TAG: "StockReserved",
+      orderId: "o6",
+      productId: "p6"
+    });
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(MixedSourceAutomationSliceFixtures$ReventlessLocal.slice));
+    await ops.processPending();
+    globalThis.expect(MixedSourceAutomationSliceFixtures$ReventlessLocal.publishedCommands.contents.length).toBe(1);
+  });
+});
+
+/*  Not a pure module */