@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.250

package/tests/components/dcb/DcbEventLogStreamTest.res

@@ -14,90 +14,117 @@ describe("DcbEventLog.readStream (in-memory adapter)", () => {
   })
 
   describe("basic streaming", () => {
-    testPromise("readStream for tag with no matching events returns empty stream", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let count = await ops.readStream(~query=tagQuery("no-such-id"))
+    testPromise(
+      "readStream for tag with no matching events returns empty stream",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let count = await ops.readStream(~query=tagQuery("no-such-id"))
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      expect(count)->toBe(0)
-    })
+        expect(count)->toBe(0)
+      },
+    )
 
-    testPromise("readStream emits all events matching a tag query", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await dispatch(addItemJson("stream-1", "Widget"), "stream-1")
-      let count = await ops.readStream(~query=tagQuery("stream-1"))
+    testPromise(
+      "readStream emits all events matching a tag query",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await dispatch(addItemJson("stream-1", "Widget"), "stream-1")
+        let count = await ops.readStream(~query=tagQuery("stream-1"))
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      expect(count)->toBe(1)
-    })
+        expect(count)->toBe(1)
+      },
+    )
 
-    testPromise("readStream for distinct IDs returns independent streams", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await dispatch(addItemJson("stream-A", "Alpha"), "stream-A")
-      let _ = await dispatch(addItemJson("stream-B", "Beta"), "stream-B")
-      let countA = await ops.readStream(~query=tagQuery("stream-A"))
+    testPromise(
+      "readStream for distinct IDs returns independent streams",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await dispatch(addItemJson("stream-A", "Alpha"), "stream-A")
+        let _ = await dispatch(addItemJson("stream-B", "Beta"), "stream-B")
+        let countA = await ops.readStream(~query=tagQuery("stream-A"))
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      let countB = await ops.readStream(~query=tagQuery("stream-B"))
+        let countB = await ops.readStream(~query=tagQuery("stream-B"))
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      expect(countA)->toBe(1)
-      expect(countB)->toBe(1)
-    })
+        expect(countA)->toBe(1)
+        expect(countB)->toBe(1)
+      },
+    )
 
-    testPromise("take(1) limits stream without loading all", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await dispatch(addItemJson("stream-C1", "C1"), "stream-C1")
-      let _ = await dispatch(addItemJson("stream-C2", "C2"), "stream-C2")
-      // Broad query: all ItemAdded events regardless of tag value
-      let result = await ops.readStream(~query=typeQuery("ItemAdded"))
+    testPromise(
+      "take(1) limits stream without loading all",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await dispatch(addItemJson("stream-C1", "C1"), "stream-C1")
+        let _ = await dispatch(addItemJson("stream-C2", "C2"), "stream-C2")
+        // Broad query: all ItemAdded events regardless of tag value
+        let result = await ops.readStream(~query=typeQuery("ItemAdded"))
         ->Stream.take(1)
         ->Stream.runCollect
         ->Effect.runPromise
-      expect(result->Array.length)->toBe(1)
-    })
+        expect(result->Array.length)->toBe(1)
+      },
+    )
   })
 
   describe("fold patterns — (state, headPosition) used in StateChangeSlice_Callback", () => {
-    testPromise("runFold extracts last headPosition for append condition", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await dispatch(addItemJson("fold-1", "FoldItem"), "fold-1")
-      let (_, headPosition) = await ops.readStream(~query=tagQuery("fold-1"))
+    testPromise(
+      "runFold extracts last headPosition for append condition",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await dispatch(addItemJson("fold-1", "FoldItem"), "fold-1")
+        let (_, headPosition) = await ops.readStream(~query=tagQuery("fold-1"))
         ->Stream.runFold(((), None), ((_dm, _pos), se) => ((), Some(se.position)))
         ->Effect.runPromise
-      expect(Option.isSome(headPosition))->toBe(true)
-    })
+        expect(Option.isSome(headPosition))->toBe(true)
+      },
+    )
 
-    testPromise("runFold on empty stream returns initial accumulator", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let (_, headPosition) = await ops.readStream(~query=tagQuery("no-such-id-fold"))
+    testPromise(
+      "runFold on empty stream returns initial accumulator",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let (_, headPosition) = await ops.readStream(~query=tagQuery("no-such-id-fold"))
         ->Stream.runFold((false, None), ((_dm, _pos), se) => (true, Some(se.position)))
         ->Effect.runPromise
-      expect(headPosition)->toEqual(None)
-    })
+        expect(headPosition)->toEqual(None)
+      },
+    )
   })
 
-  describe("StateChangeSlice regression — second command sees first event via stream fold", () => {
-    testPromise("second AddItem with same ID is rejected (state sees existing event)", async () => {
-      // First command succeeds → ItemAdded event stored
-      // Second command: readStream folds all events → state = true (exists)
-      // decide(true, AddItem) → Error(ItemAlreadyExists) → no new events
-      let id = "dup-test-stream"
-      let _ = await dispatch(addItemJson(id, "First"), id)
-      let countBefore = capturedEventCount.contents
-      let _ = await dispatch(addItemJson(id, "Duplicate"), id)
-      // Duplicate command must not publish a second event
-      expect(capturedEventCount.contents)->toBe(countBefore)
-    })
+  describe(
+    "StateChangeSlice regression — second command sees first event via stream fold",
+    () => {
+      testPromise(
+        "second AddItem with same ID is rejected (state sees existing event)",
+        async () => {
+          // First command succeeds → ItemAdded event stored
+          // Second command: readStream folds all events → state = true (exists)
+          // decide(true, AddItem) → Error(ItemAlreadyExists) → no new events
+          let id = "dup-test-stream"
+          let _ = await dispatch(addItemJson(id, "First"), id)
+          let countBefore = capturedEventCount.contents
+          let _ = await dispatch(addItemJson(id, "Duplicate"), id)
+          // Duplicate command must not publish a second event
+          expect(capturedEventCount.contents)->toBe(countBefore)
+        },
+      )
 
-    testPromise("second AddItem with different ID succeeds", async () => {
-      let id1 = "distinct-1"
-      let id2 = "distinct-2"
-      let _ = await dispatch(addItemJson(id1, "First"), id1)
-      let countAfterFirst = capturedEventCount.contents
-      let _ = await dispatch(addItemJson(id2, "Second"), id2)
-      // New ID should publish an event
-      expect(capturedEventCount.contents)->toBe(countAfterFirst + 1)
-    })
-  })
+      testPromise(
+        "second AddItem with different ID succeeds",
+        async () => {
+          let id1 = "distinct-1"
+          let id2 = "distinct-2"
+          let _ = await dispatch(addItemJson(id1, "First"), id1)
+          let countAfterFirst = capturedEventCount.contents
+          let _ = await dispatch(addItemJson(id2, "Second"), id2)
+          // New ID should publish an event
+          expect(capturedEventCount.contents)->toBe(countAfterFirst + 1)
+        },
+      )
+    },
+  )
 })

package/tests/components/dcb/DcbFixtures.res

@@ -78,7 +78,10 @@ let _ = TestRunner.setup()
 // ─────────────────────────────────────────────────────────────
 
 module ItemEventLogMaker = DcbEventLog_Builder.Make(Bus)
-let eventLog = ItemEventLogMaker.make(~name="ItemEventLog", ~partitionTag=Reventless.DcbTag.Simple({key: "id"}))
+let eventLog = ItemEventLogMaker.make(
+  ~name="ItemEventLog",
+  ~partitionTag=Reventless.DcbTag.Simple({key: "id"}),
+)
 
 // ─────────────────────────────────────────────────────────────
 // Build StateChangeSlice

package/tests/components/dcb/DcbTest.res

@@ -17,8 +17,9 @@ describe("DcbEventLog E2E", () => {
 
   testPromise("AddItem command publishes 1 event to event topic", async () => {
     let cmd =
-      AddItemSpec.AddItem({id: "item-1", name: "Widget"})
-      ->ReventlessCore.Message.encode(AddItemSpec.commandSchema)
+      AddItemSpec.AddItem({id: "item-1", name: "Widget"})->ReventlessCore.Message.encode(
+        AddItemSpec.commandSchema,
+      )
     await dispatch(cmd, "item-1")
     expect(capturedEventCount.contents)->toBe(1)
   })
@@ -26,16 +27,18 @@ describe("DcbEventLog E2E", () => {
   testPromise("duplicate AddItem produces 0 events (ItemAlreadyExists)", async () => {
     // item-1 was already created in the previous test — same aggregate state persists
     let cmd =
-      AddItemSpec.AddItem({id: "item-1", name: "Widget"})
-      ->ReventlessCore.Message.encode(AddItemSpec.commandSchema)
+      AddItemSpec.AddItem({id: "item-1", name: "Widget"})->ReventlessCore.Message.encode(
+        AddItemSpec.commandSchema,
+      )
     await dispatch(cmd, "item-1")
     expect(capturedEventCount.contents)->toBe(0)
   })
 
   testPromise("AddItem for new id produces 1 event", async () => {
     let cmd =
-      AddItemSpec.AddItem({id: "item-2", name: "Gadget"})
-      ->ReventlessCore.Message.encode(AddItemSpec.commandSchema)
+      AddItemSpec.AddItem({id: "item-2", name: "Gadget"})->ReventlessCore.Message.encode(
+        AddItemSpec.commandSchema,
+      )
     await dispatch(cmd, "item-2")
     expect(capturedEventCount.contents)->toBe(1)
   })

package/tests/components/eventcollector/EventCollectorFixtures.res

@@ -39,4 +39,3 @@ module EventCollectorMaker = ReventlessCore.EventCollector_Builder.Make(
 )
 
 let eventCollector = EventCollectorMaker.make(~name="TestEC", ~eventTopics=allEventTopics, ~opts={})
-

package/tests/components/eventcollector/EventCollectorTest.res

@@ -27,9 +27,12 @@ describe("EventCollector (in-memory)", () => {
     // The EventCollector itself doesn't expose a direct handler in our test setup —
     // verify the bus subscription mechanism works
     let received: ref<int> = ref(0)
-    Bus.subscribeToEvents(topicName, async (_, _, _) => {
-      received := received.contents + 1
-    })
+    Bus.subscribeToEvents(
+      topicName,
+      async (_, _, _) => {
+        received := received.contents + 1
+      },
+    )
     let testEvent = JSON.Encode.object(Dict.fromArray([("type", JSON.Encode.string("TestEvent"))]))
     await Bus.publishEvent(topicName, "test", testMeta, testEvent)
     expect(received.contents)->toBe(1)

package/tests/components/eventlog/EventLogAppendStreamTest.res

@@ -14,80 +14,100 @@ describe("EventLog.appendStream (in-memory adapter)", () => {
   let _ = beforeEach(() => reset())
 
   describe("basic append", () => {
-    testPromise("appendStream writes all events to storage", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let stream = [
-        ItemEventLogSpec.ItemCreated({name: "e1"}),
-        ItemEventLogSpec.ItemCreated({name: "e2"}),
-        ItemEventLogSpec.ItemCreated({name: "e3"}),
-      ]->Stream.fromIterable
-      let _ = await ops.appendStream(0, "as-basic-1", stream)->Effect.runPromise
-      let replayed = await ops.replay("as-basic-1")
-      expect(replayed->Array.length)->toBe(3)
-    })
+    testPromise(
+      "appendStream writes all events to storage",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let stream =
+          [
+            ItemEventLogSpec.ItemCreated({name: "e1"}),
+            ItemEventLogSpec.ItemCreated({name: "e2"}),
+            ItemEventLogSpec.ItemCreated({name: "e3"}),
+          ]->Stream.fromIterable
+        let _ = await ops.appendStream(0, "as-basic-1", stream)->Effect.runPromise
+        let replayed = await ops.replay("as-basic-1")
+        expect(replayed->Array.length)->toBe(3)
+      },
+    )
 
-    testPromise("appendStream on empty stream writes nothing", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.appendStream(0, "as-empty-1", Stream.empty)->Effect.runPromise
-      let replayed = await ops.replay("as-empty-1")
-      expect(replayed->Array.length)->toBe(0)
-    })
+    testPromise(
+      "appendStream on empty stream writes nothing",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.appendStream(0, "as-empty-1", Stream.empty)->Effect.runPromise
+        let replayed = await ops.replay("as-empty-1")
+        expect(replayed->Array.length)->toBe(0)
+      },
+    )
 
-    testPromise("appendStream preserves event order", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let stream = [
-        ItemEventLogSpec.ItemCreated({name: "first"}),
-        ItemEventLogSpec.ItemDeleted({id: "second"}),
-      ]->Stream.fromIterable
-      let _ = await ops.appendStream(0, "as-order-1", stream)->Effect.runPromise
-      let replayed = await ops.replayStream("as-order-1")->Stream.runCollect->Effect.runPromise
-      let first = replayed->Array.getUnsafe(0)
-      expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "first"}))
-    })
+    testPromise(
+      "appendStream preserves event order",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let stream =
+          [
+            ItemEventLogSpec.ItemCreated({name: "first"}),
+            ItemEventLogSpec.ItemDeleted({id: "second"}),
+          ]->Stream.fromIterable
+        let _ = await ops.appendStream(0, "as-order-1", stream)->Effect.runPromise
+        let replayed = await ops.replayStream("as-order-1")->Stream.runCollect->Effect.runPromise
+        let first = replayed->Array.getUnsafe(0)
+        expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "first"}))
+      },
+    )
 
-    testPromise("appendStream after array append continues from correct sequenceNr", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(
-        0,
-        "as-seq-1",
-        [makeEvent'("as-seq-1", ItemEventLogSpec.ItemCreated({name: "initial"}))],
-      )
-      let stream = [ItemEventLogSpec.ItemCreated({name: "streamed"})]->Stream.fromIterable
-      let _ = await ops.appendStream(1, "as-seq-1", stream)->Effect.runPromise
-      let replayed = await ops.replay("as-seq-1")
-      expect(replayed->Array.length)->toBe(2)
-    })
+    testPromise(
+      "appendStream after array append continues from correct sequenceNr",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "as-seq-1",
+          [makeEvent'("as-seq-1", ItemEventLogSpec.ItemCreated({name: "initial"}))],
+        )
+        let stream = [ItemEventLogSpec.ItemCreated({name: "streamed"})]->Stream.fromIterable
+        let _ = await ops.appendStream(1, "as-seq-1", stream)->Effect.runPromise
+        let replayed = await ops.replay("as-seq-1")
+        expect(replayed->Array.length)->toBe(2)
+      },
+    )
   })
 
   describe("replayStream → appendStream pipeline", () => {
-    testPromise("can copy events from one aggregate to another via streams", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(
-        0,
-        "as-src-1",
-        [
-          makeEvent'("as-src-1", ItemEventLogSpec.ItemCreated({name: "a"})),
-          makeEvent'("as-src-1", ItemEventLogSpec.ItemDeleted({id: "b"})),
-        ],
-      )
-      let sourceStream = ops.replayStream("as-src-1")
-      let _ = await ops.appendStream(0, "as-dst-1", sourceStream)->Effect.runPromise
-      let destEvents = await ops.replay("as-dst-1")
-      expect(destEvents->Array.length)->toBe(2)
-    })
+    testPromise(
+      "can copy events from one aggregate to another via streams",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "as-src-1",
+          [
+            makeEvent'("as-src-1", ItemEventLogSpec.ItemCreated({name: "a"})),
+            makeEvent'("as-src-1", ItemEventLogSpec.ItemDeleted({id: "b"})),
+          ],
+        )
+        let sourceStream = ops.replayStream("as-src-1")
+        let _ = await ops.appendStream(0, "as-dst-1", sourceStream)->Effect.runPromise
+        let destEvents = await ops.replay("as-dst-1")
+        expect(destEvents->Array.length)->toBe(2)
+      },
+    )
 
-    testPromise("copied events round-trip through decode correctly", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(
-        0,
-        "as-src-2",
-        [makeEvent'("as-src-2", ItemEventLogSpec.ItemCreated({name: "copied"}))],
-      )
-      let sourceStream = ops.replayStream("as-src-2")
-      let _ = await ops.appendStream(0, "as-dst-2", sourceStream)->Effect.runPromise
-      let destEvents = await ops.replayStream("as-dst-2")->Stream.runCollect->Effect.runPromise
-      let first = destEvents->Array.getUnsafe(0)
-      expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "copied"}))
-    })
+    testPromise(
+      "copied events round-trip through decode correctly",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "as-src-2",
+          [makeEvent'("as-src-2", ItemEventLogSpec.ItemCreated({name: "copied"}))],
+        )
+        let sourceStream = ops.replayStream("as-src-2")
+        let _ = await ops.appendStream(0, "as-dst-2", sourceStream)->Effect.runPromise
+        let destEvents = await ops.replayStream("as-dst-2")->Stream.runCollect->Effect.runPromise
+        let first = destEvents->Array.getUnsafe(0)
+        expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "copied"}))
+      },
+    )
   })
 })

package/tests/components/eventlog/EventLogConflictTest.res

@@ -75,10 +75,14 @@ describe("EventLog — conflict detection (in-memory)", () => {
 
   testPromise("batch append with correct sequenceNr stores all events", async () => {
     let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-    let result = await ops.append(0, "conflict-5", [
-      makeEvent'("conflict-5", ItemEventLogSpec.ItemCreated({name: "e1"})),
-      makeEvent'("conflict-5", ItemEventLogSpec.ItemDeleted({id: "e2"})),
-    ])
+    let result = await ops.append(
+      0,
+      "conflict-5",
+      [
+        makeEvent'("conflict-5", ItemEventLogSpec.ItemCreated({name: "e1"})),
+        makeEvent'("conflict-5", ItemEventLogSpec.ItemDeleted({id: "e2"})),
+      ],
+    )
     expect(Result.isOk(result))->toBe(true)
     let replayed = await ops.replay("conflict-5")
     expect(replayed->Array.length)->toBe(2)

package/tests/components/eventlog/EventLogFixtures.res

@@ -11,7 +11,7 @@ module ItemEventLogSpec = {
   let name = "TestItemEventLog"
 
   @schema
-  type event = | ItemCreated({name: string}) | ItemDeleted({id: string})
+  type event = ItemCreated({name: string}) | ItemDeleted({id: string})
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -41,11 +41,11 @@ module EventLogMaker = ReventlessCore.EventLog_Builder.Make(
 
 let eventLog = EventLogMaker.make(~name="TestItemEventLog")
 
-let makeEvent' = (id, event) => ({
+let makeEvent' = (id, event): Reventless.Message.event'<string, ItemEventLogSpec.event> => {
   Reventless.Message.id,
   meta: testMeta,
   event,
-}: Reventless.Message.event'<string, ItemEventLogSpec.event>)
+}
 
 let reset = () => {
   capturedTopicEventCount := 0

package/tests/components/eventlog/EventLogProvisioningSeamTest.res

@@ -30,7 +30,9 @@ module Recorder: ReventlessCore.EventLogProvisioning.Backend = {
     })
 }
 
-ReventlessCore.EventLogProvisioning.use(module(Recorder: ReventlessCore.EventLogProvisioning.Backend))
+ReventlessCore.EventLogProvisioning.use(
+  module(Recorder: ReventlessCore.EventLogProvisioning.Backend),
+)
 
 module Bus = LocalBus.Make()
 
@@ -42,7 +44,7 @@ module SeamItemSpec = {
   let name = "SeamItemEventLog"
 
   @schema
-  type event = | SeamItemCreated({name: string})
+  type event = SeamItemCreated({name: string})
 }
 
 module ClassicMaker = ReventlessCore.EventLog_Builder.Make(
@@ -53,7 +55,10 @@ module ClassicMaker = ReventlessCore.EventLog_Builder.Make(
 
 // The plugin builder publishes this context around a plugin's construct; entering
 // it here is what a real plugin build does, so the seam should carry the names.
-let previousContext = ReventlessCore.ResourceAttribution.enter(~platform="seam-platform", ~plugin="SeamPlugin")
+let previousContext = ReventlessCore.ResourceAttribution.enter(
+  ~platform="seam-platform",
+  ~plugin="SeamPlugin",
+)
 
 let classicLog = ClassicMaker.make(
   ~name="SeamItem",
@@ -63,10 +68,7 @@ let classicLog = ClassicMaker.make(
 // ── DCB log ──────────────────────────────────────────────────
 module DcbMaker = DcbEventLog_Builder.Make(Bus)
 
-let dcbLog = DcbMaker.make(
-  ~name="SeamCatalog",
-  ~partitionTag=Reventless.DcbTag.Simple({key: "id"}),
-)
+let dcbLog = DcbMaker.make(~name="SeamCatalog", ~partitionTag=Reventless.DcbTag.Simple({key: "id"}))
 
 ReventlessCore.ResourceAttribution.restore(previousContext)
 
@@ -80,16 +82,27 @@ describe("EventLogProvisioning seam, driven by the real builders", () => {
 
   testSync("carries the owning element: the aggregate for classic, the plugin for DCB", () => {
     expect(provisioned->Array.map(r => r.owner))->toEqual([
-      Some(({kind: ReventlessCore.ComponentType.Aggregate, name: "SeamItem"}: ReventlessCore.ResourceAttribution.owner)),
-      Some(({kind: ReventlessCore.ComponentType.Plugin, name: "SeamCatalog"}: ReventlessCore.ResourceAttribution.owner)),
+      Some(
+        (
+          {
+            kind: ReventlessCore.ComponentType.Aggregate,
+            name: "SeamItem",
+          }: ReventlessCore.ResourceAttribution.owner
+        ),
+      ),
+      Some(
+        (
+          {
+            kind: ReventlessCore.ComponentType.Plugin,
+            name: "SeamCatalog",
+          }: ReventlessCore.ResourceAttribution.owner
+        ),
+      ),
     ])
   })
 
   testSync("carries the ambient plugin attribution the builder published", () => {
-    expect(provisioned->Array.map(r => r.plugin))->toEqual([
-      Some("SeamPlugin"),
-      Some("SeamPlugin"),
-    ])
+    expect(provisioned->Array.map(r => r.plugin))->toEqual([Some("SeamPlugin"), Some("SeamPlugin")])
   })
 
   testSync("carries the adapter's resources — empty for in-memory storage", () => {