@reventlessdev/reventless-core 3.0.0-alpha.208 → 3.0.0-alpha.210

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.210 (2026-08-04)
+
+### Bug Fixes
+
+* **core:** tag a slice's published command with its target, not itself ([bb2b063](https://github.com/ReventlessDev/reventless-core/commit/bb2b063f914e45fb8efcba28e0b691713cf93d8a))
+### Features
+
+* **outbound:** hand translate its geocoder instead of making it fetch one ([fb18312](https://github.com/ReventlessDev/reventless-core/commit/fb1831216b37c9562868c46e1a09054e69418c67))
+
+
+# 3.0.0-alpha.209 (2026-08-03)
+
+### Bug Fixes
+
+* **aws:** give slice command publishes a queue they can actually reach ([42fdb55](https://github.com/ReventlessDev/reventless-core/commit/42fdb55b751a197d586c49e3615ce12ffea42046))
+### Features
+
+* **dcb:** route an outbound slice's command to the aggregate it targets ([897b37b](https://github.com/ReventlessDev/reventless-core/commit/897b37b46a4e856567646dfdc2f0652e81cf7388))
+
+
 # 3.0.0-alpha.208 (2026-08-03)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.208",
+  "version": "3.0.0-alpha.210",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.1",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.1",
     "@reventlessdev/rescript-node": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.1",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.99"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.125",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.100"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin.res.mjs

@@ -78,7 +78,7 @@ function Make(RuntimeEnvironment) {
         A.Spec.eventSchema
       ]);
       Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
-      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, aggregateProducedEvents, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
+      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, aggregateProducedEvents, undefined, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
       let slicePublishJsons = dcbResult.dcbPublishJsons;
       if (slicePublishJsons !== undefined) {
         stateChangeSlices.forEach(Sc => {

package/src/components/Aggregate/Aggregate_Builder.res

@@ -66,7 +66,17 @@ module Make = (
     }
   }
 
-  let createCommandTopic = (eventLog: SpecificEventLog.component, name, opts, ~memorySize, ~timeout) =>
+  let createCommandTopic = (eventLog: SpecificEventLog.component, name, opts, ~memorySize, ~timeout) => {
+    // Created outside the apply below, so the topic — and with it the channel's
+    // queue — exists while plugin construction is still synchronous. An outbound
+    // slice targeting this aggregate resolves its publish queue in a finalizer
+    // that runs before any Output settles; a queue created inside the apply is
+    // invisible there. Only the handler needs the event log's operations.
+    let commandTopic = SpecificCommandTopic.make(
+      ~name,
+      ~owner={kind: ComponentType.Aggregate, name: Spec.name},
+      ~opts,
+    )
     eventLog
     ->Component.operations
     ->Pulumi.Output.apply(eventLogOps => {
@@ -79,11 +89,6 @@ module Make = (
           let eventLog = eventLogOps
         },
       )
-      let commandTopic = SpecificCommandTopic.make(
-        ~name,
-        ~owner={kind: ComponentType.Aggregate, name: Spec.name},
-        ~opts,
-      )
       let handler = SpecificCommandTopic.makeHandler(
         ~commandTopic,
         ~commandsHandler=AggregateCallback.handleCommands,
@@ -98,6 +103,7 @@ module Make = (
       )
       commandTopic
     })
+  }
 
   let createCommandGenerator = (
     commandTopic: Pulumi.Output.t<SpecificCommandTopic.component>,

package/src/components/Aggregate/Aggregate_Builder.res.mjs

@@ -30,25 +30,27 @@ function Make(Spec) {
       Id: Spec.Id,
       commandSchema: Spec.commandSchema
     })(SpecificEventCollector)(EventMappings)(AggregateRuntimeBuilder);
-    let createCommandTopic = (eventLog, name, opts, memorySize, timeout) => Component$ReventlessCore.operations(eventLog).apply(eventLogOps => {
-      let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Behavior)({
-        Spec: Spec,
-        EventLog: SpecificEventLog,
-        eventLog: eventLogOps
-      });
+    let createCommandTopic = (eventLog, name, opts, memorySize, timeout) => {
       let commandTopic = SpecificCommandTopic.make(name, {
         kind: "Aggregate",
         name: Spec.name
       }, opts);
-      let handler = SpecificCommandTopic.makeHandler(commandTopic, AggregateCallback.handleCommands);
-      let eventLog$1 = Component$ReventlessCore.outputs(eventLog);
-      let resources = [
-        eventLog$1.resources,
-        eventLog$1.eventTopic.resources
-      ].flat();
-      AggregateRuntimeBuilder.forCommandTopic(handler, none => SpecificCommandTopic.connect(none, resources, commandTopic), memorySize, timeout, commandTopic);
-      return commandTopic;
-    });
+      return Component$ReventlessCore.operations(eventLog).apply(eventLogOps => {
+        let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Behavior)({
+          Spec: Spec,
+          EventLog: SpecificEventLog,
+          eventLog: eventLogOps
+        });
+        let handler = SpecificCommandTopic.makeHandler(commandTopic, AggregateCallback.handleCommands);
+        let eventLog$1 = Component$ReventlessCore.outputs(eventLog);
+        let resources = [
+          eventLog$1.resources,
+          eventLog$1.eventTopic.resources
+        ].flat();
+        AggregateRuntimeBuilder.forCommandTopic(handler, none => SpecificCommandTopic.connect(none, resources, commandTopic), memorySize, timeout, commandTopic);
+        return commandTopic;
+      });
+    };
     let createCommandGenerator = (commandTopic, api, name, opts, memorySize, timeout) => Output$Pulumi.flatMap(commandTopic, commandTopic => Component$ReventlessCore.operations(commandTopic).apply(param => {
       let publishJsonsAndWait = param.publishJsonsAndWait;
       let publishJsons = param.publishJsons;

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -86,8 +86,12 @@ module Make = (
   // only carries `item` data), so causation across the automation hop is
   // lost — emitted commands are roots of a fresh correlation chain. If we
   // later thread source meta through todoItems, switch to deriveMeta.
-  let makeMeta = (): Reventless.Message.meta =>
-    Message.generateMeta(~service=`AutomationSlice:${Spec.name}`)
+  // `service` names the command's TARGET, matching the API path
+  // (`CommandGenerator_Callback` passes `~serviceName=AggregateSpec.name`). An
+  // aggregate derives its event meta from the command's, and ReadModel /
+  // AutomationSlice callbacks dispatch mappings on `meta.service` — so naming
+  // the slice here makes the target's own events unmatchable, silently.
+  let makeMeta = (): Reventless.Message.meta => Message.generateMeta(~service=Spec.targetName)
 
   // Per-source erased dispatch — pre-compile decoders once at module init.
   type dispatch = {

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -33,7 +33,7 @@ let todoRowSchema = S.schema(s => ({
 function Make(Spec) {
   return Automation => {
     let todoItems = {};
-    let makeMeta = () => Message$ReventlessCore.generateMeta(`AutomationSlice:` + Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let makeMeta = () => Message$ReventlessCore.generateMeta(Spec.targetName, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
     let dispatches = Automation.mappings.map(M => {
       let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
       let handle = (json, ctx) => {

package/src/components/Dcb/Dcb_Builder.res

@@ -94,6 +94,17 @@ module Make = (
     // also drives DCB GSI creation: an aggregate's events live on its own
     // EventLog and must not mint indexes on the DCB table.
     ~aggregateProducedEvents: array<(string, S.t<unknown>)>=[],
+    // Per-aggregate command publishers, keyed by Aggregate `Spec.name`. An
+    // OutboundTranslationSlice naming one in `targetName` publishes its command
+    // through that aggregate's CommandTopic instead of this plugin's DCB topic —
+    // the two are handled by different Lambdas, so sending an aggregate command
+    // to the DCB queue delivers it somewhere nothing handles it.
+    //
+    // Populated before this runs (`createAggregatesWithoutEventMappers`), so the
+    // publisher is in hand by the time a slice is built. DCB StateChangeSlice
+    // publishers are registered *after* and are deliberately absent: a slice
+    // targeting one wants the DCB topic, which is the fallback.
+    ~publishToAggregates: dict<Pulumi.Output.t<CommandTopic.publishJsons>>=Dict.make(),
     ~stateChangeSlices: array<module(StateChangeSlice.T)>,
     ~stateViewSlices: array<module(StateViewSlice.T)>,
     ~automationSlices: array<module(AutomationSlice.T)>,
@@ -629,12 +640,21 @@ module Make = (
         let outboundTranslationSlicesOutputs =
           outboundTranslationSlices
           ->Array.map((module(OTS: OutboundTranslationSlice.T)) => {
+            // Where this slice's inbound command goes. `targetName` naming an
+            // Aggregate routes to that aggregate's CommandTopic; anything else —
+            // a DCB slice, or no target at all — keeps the plugin's DCB topic,
+            // which is what every slice wanted before aggregates were reachable.
+            let targetPublishJsons =
+              OTS.Spec.targetName
+              ->Option.flatMap(target => publishToAggregates->Dict.get(target))
+              ->Option.getOr(publishJsons)
+
             let ots = OTS.make(
               ~dcbEventLog,
               // Same dict the AutomationSlices get, so an outbound slice can
               // name an Aggregate source by its Spec.name.
               ~allEventTopics,
-              ~publishJsons,
+              ~publishJsons=targetPublishJsons,
               ~runtime=?componentRuntime->Dict.get(OTS.Spec.name),
               ~opts,
             )

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -83,13 +83,14 @@ let emptyResult = {
 
 function Make(DcbEventLogStorage) {
   return DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (RuntimeBuilder => (HooksConfig => {
-    let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, aggregateProducedEventsOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
+    let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, aggregateProducedEventsOpt, publishToAggregatesOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
       let apiNamePrefix = apiNamePrefixOpt !== undefined ? apiNamePrefixOpt : name;
       let onAdminApi = onAdminApiOpt !== undefined ? onAdminApiOpt : false;
       let environment = environmentOpt !== undefined ? environmentOpt : "";
       let platformName = platformNameOpt !== undefined ? platformNameOpt : "";
       let aggregateEventTopics = aggregateEventTopicsOpt !== undefined ? aggregateEventTopicsOpt : ({});
       let aggregateProducedEvents = aggregateProducedEventsOpt !== undefined ? aggregateProducedEventsOpt : [];
+      let publishToAggregates = publishToAggregatesOpt !== undefined ? publishToAggregatesOpt : ({});
       let systemCallableComponents = systemCallableComponentsOpt !== undefined ? systemCallableComponentsOpt : [];
       let componentRuntime = componentRuntimeOpt !== undefined ? componentRuntimeOpt : ({});
       let hasDcb = stateChangeSlices.length !== 0;
@@ -330,7 +331,8 @@ function Make(DcbEventLogStorage) {
         ];
       }));
       let outboundTranslationSlicesOutputs = Object.fromEntries(outboundTranslationSlices.map(OTS => {
-        let ots = OTS.make(dcbEventLog, allEventTopics, publishJsons, componentRuntime[OTS.Spec.name], opts);
+        let targetPublishJsons = Stdlib_Option.getOr(Stdlib_Option.flatMap(OTS.Spec.targetName, target => publishToAggregates[target]), publishJsons);
+        let ots = OTS.make(dcbEventLog, allEventTopics, targetPublishJsons, componentRuntime[OTS.Spec.name], opts);
         return [
           OTS.Spec.name,
           Component$ReventlessCore.outputs(ots)

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res

@@ -102,8 +102,9 @@ module Make = (
   // no upstream Reventless meta to derive from, so emitted commands are roots
   // of a fresh correlation chain. `traceparent` populated from an inbound HTTP
   // header would need to be threaded in here by the API/ingress adapter.
-  let makeMeta = (): Reventless.Message.meta =>
-    Message.generateMeta(~service=`InboundTranslationSlice:${Spec.name}`)
+  // `service` names the command's TARGET, as on the API path — see the note in
+  // `AutomationSlice_Callback`. The target's events are dispatched on it.
+  let makeMeta = (): Reventless.Message.meta => Message.generateMeta(~service=Spec.targetName)
 
   let receive = async (
     publishJsons: ReventlessInfra.CommandTopic.publishJsons,

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs

@@ -69,7 +69,7 @@ function takeAuditRow(auditLog, requestId) {
 function Make(Spec) {
   return Translation => {
     let auditLog = {};
-    let makeMeta = () => Message$ReventlessCore.generateMeta(`InboundTranslationSlice:` + Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let makeMeta = () => Message$ReventlessCore.generateMeta(Spec.targetName, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
     let receive = async (publishJsons, inputJson) => {
       let requestId = Uuid.v4();
       let input;

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res

@@ -17,6 +17,17 @@ module Make = (
     let api: unit => QueryDbStorage.api
     let apiRole: unit => QueryDbStorage.role
   },
+  // What the platform provisioned, for `translate` to reach. A thunk like
+  // `Api.api` rather than a value, so a platform can resolve it when the runtime
+  // exists rather than when this functor is applied.
+  //
+  // A functor parameter, not a mutable slot: the platform that omits it does not
+  // compile, which is the property D9 chose injection for. This supplies the
+  // in-process path; the Lambda entry point supplies its own, because there the
+  // callback is driven by a bundled shell rather than by this builder.
+  Capabilities: {
+    let capabilities: unit => Reventless.Capabilities.t
+  },
 ) => {
   let finish = EventCollectorRuntimeBuilder.finish
   module Make = (
@@ -187,7 +198,7 @@ module Make = (
                   // same topic, awaiting would self-deadlock the bus — same
                   // shape as AutomationSlice. Detach it; errors are logged.
                   let _ =
-                    Callback.phase2(publishJsonsFn)
+                    Callback.phase2(publishJsonsFn, ~capabilities=Capabilities.capabilities())
                     ->Promise.then(() => syncToQueryDb(queryDbOps))
                     ->Promise.catch(exn => {
                       let errMsg =
@@ -223,7 +234,8 @@ module Make = (
         ->Pulumi.Output.apply(((ecOps, publishJsonsFn)) => {
           let ops: OutboundTranslationSlice.operations = {
             enqueueEvent: ecOps.enqueueEvent,
-            translatePending: async () => await Callback.phase2(publishJsonsFn),
+            translatePending: async () =>
+              await Callback.phase2(publishJsonsFn, ~capabilities=Capabilities.capabilities()),
           }
           ops
         }),

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res.mjs

@@ -29,7 +29,7 @@ import * as OutboundTranslationSlice$ReventlessCore from "./OutboundTranslationS
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "./OutboundTranslationSlice_Callback.res.mjs";
 
 function Make(RuntimeEnvironment) {
-  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => {
+  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => (Capabilities => {
     let Make = Spec => (Translation => {
       let Callback = OutboundTranslationSlice_Callback$ReventlessCore.Make(Spec)(Translation);
       let queryDbName = Spec.name + "Todo";
@@ -108,7 +108,7 @@ function Make(RuntimeEnvironment) {
             })), events => Stream$1.fromIterable(events))), eventsArr => Effect.promise(async () => {
               Callback.phase1(eventsArr);
               await syncToQueryDb(queryDbOps);
-              Stdlib_Promise.$$catch(Callback.phase2(publishJsonsFn).then(() => syncToQueryDb(queryDbOps)), exn => {
+              Stdlib_Promise.$$catch(Callback.phase2(publishJsonsFn, Capabilities.capabilities()).then(() => syncToQueryDb(queryDbOps)), exn => {
                 let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
                 Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `detached phase 2 error: ` + errMsg));
                 return Promise.resolve();
@@ -126,7 +126,7 @@ function Make(RuntimeEnvironment) {
             let publishJsonsFn = param[1];
             return {
               enqueueEvent: param[0].enqueueEvent,
-              translatePending: async () => await Callback.phase2(publishJsonsFn)
+              translatePending: async () => await Callback.phase2(publishJsonsFn, Capabilities.capabilities())
             };
           }));
           let aggregatedResources = Object.values(eventTopics).flatMap(t => t.resources);
@@ -149,7 +149,7 @@ function Make(RuntimeEnvironment) {
       finish: EventCollectorRuntimeBuilder.finish,
       Make: Make
     };
-  }))));
+  })))));
 }
 
 export {

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -39,8 +39,16 @@ runtime, as `undefined` destructured from a tuple that was never a tuple.
 */
 type phase1<'event> = array<(string, 'event)> => unit
 
-/** Phase 2: translate all pending items, optionally publishing commands. */
-type phase2 = ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+/** Phase 2: translate all pending items, optionally publishing commands.
+
+    `~capabilities` is supplied by whoever drives the callback — the in-process
+    builder or the Lambda entry point — because that is the layer that knows what
+    the platform provisioned. It arrives here rather than at `Make` so the
+    functor stays a pure function of the Spec, appliable before a runtime exists. */
+type phase2 = (
+  ReventlessInfra.CommandTopic.publishJsons,
+  ~capabilities: Reventless.Capabilities.t,
+) => promise<unit>
 
 /** The whole protocol as a value — what a driver holding a built callback needs,
     with no knowledge of the Spec it was built from. */
@@ -81,8 +89,20 @@ module Make = (
   // meta is not threaded from phase1 → phase2 today, so causation across the
   // translation hop is not preserved. If sources later carry meta into todoItems,
   // switch to Message.deriveMeta.
+  //
+  // `service` names the command's TARGET, matching what the API path does
+  // (`CommandGenerator_Callback` passes `~serviceName=AggregateSpec.name`). It is
+  // load-bearing rather than descriptive: an aggregate derives its event's meta
+  // from the command's, and ReadModel/AutomationSlice callbacks dispatch mappings
+  // on `meta.service`. Naming the slice here instead makes the aggregate emit an
+  // event no mapping for that aggregate matches — projected as zero actions, with
+  // no error. Falls back to the slice's own name only when there is no target, in
+  // which case the command goes to the plugin's DCB topic and nothing dispatches
+  // on it.
   let makeMeta = (): Reventless.Message.meta =>
-    Message.generateMeta(~service=`OutboundTranslationSlice:${Spec.name}`)
+    Message.generateMeta(
+      ~service=Spec.targetName->Option.getOr(`OutboundTranslationSlice:${Spec.name}`),
+    )
 
   let phase1 = (events: array<(string, Spec.consumedEvent)>) => {
     events->Array.forEach(((sourceId, event)) => {
@@ -103,7 +123,10 @@ module Make = (
     })
   }
 
-  let phase2 = async (publishJsons: ReventlessInfra.CommandTopic.publishJsons) => {
+  let phase2 = async (
+    publishJsons: ReventlessInfra.CommandTopic.publishJsons,
+    ~capabilities: Reventless.Capabilities.t,
+  ) => {
     let pending =
       todoItems
       ->Dict.toArray
@@ -131,7 +154,7 @@ module Make = (
       | Some(item) =>
         todoItems->Dict.set(id, {...row, status: Processing, processedAt: now()})
 
-        let result = try await Translation.translate(id, item) catch {
+        let result = try await Translation.translate(id, item, ~capabilities) catch {
         | exn =>
           let msg =
             exn

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs

@@ -32,7 +32,7 @@ let todoRowSchema = S.schema(s => ({
 function Make(Spec) {
   return Translation => {
     let todoItems = {};
-    let makeMeta = () => Message$ReventlessCore.generateMeta(`OutboundTranslationSlice:` + Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let makeMeta = () => Message$ReventlessCore.generateMeta(Stdlib_Option.getOr(Spec.targetName, `OutboundTranslationSlice:` + Spec.name), undefined, undefined, undefined, undefined, undefined, undefined, undefined);
     let phase1 = events => {
       events.forEach(param => {
         Translation.collect(param[1], param[0]).forEach(param => {
@@ -53,7 +53,7 @@ function Make(Spec) {
         });
       });
     };
-    let phase2 = async publishJsons => {
+    let phase2 = async (publishJsons, capabilities) => {
       let pending = Object.entries(todoItems).filter(param => {
         let row = param[1];
         if (row.status === "Pending") {
@@ -86,7 +86,7 @@ function Make(Spec) {
         todoItems[id] = newrecord;
         let result;
         try {
-          result = await Translation.translate(id, Primitive_option.valFromOption(item));
+          result = await Translation.translate(id, Primitive_option.valFromOption(item), capabilities);
         } catch (raw_exn$1) {
           let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
           let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown error");

package/src/plugin/component/Plugin_Builder.res

@@ -168,6 +168,9 @@ module Make = (
       ~platformName=Spec.platformName,
       ~aggregateEventTopics,
       ~aggregateProducedEvents,
+      // Carries the aggregate publishers registered just above, so an outbound
+      // slice can route its command to the aggregate it names.
+      ~publishToAggregates,
       ~stateChangeSlices,
       ~stateViewSlices,
       ~automationSlices,

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -156,7 +156,7 @@ function Make(Spec) {
         let DcbBuilder = Dcb_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher)(DcbCommandTopicChannel)(DcbCommandTopicChannelAsync)(PluginRuntimeBuilder)({
           hooks: Spec.hooks
         });
-        let dcbResult = DcbBuilder.construct(extra$1, childName, undefined, undefined, Spec.environment, Spec.platformName, aggregateEventTopics, aggregateProducedEvents, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponents, componentRuntime, pluginStructure, opts);
+        let dcbResult = DcbBuilder.construct(extra$1, childName, undefined, undefined, Spec.environment, Spec.platformName, aggregateEventTopics, aggregateProducedEvents, Plugin_Helpers$ReventlessCore.publishToAggregates, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponents, componentRuntime, pluginStructure, opts);
         let mutationEntriesFromAggregates = aggregates.flatMap(M => {
           let commandSchema = M.Spec.commandSchema;
           if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {