@reventlessdev/reventless-aws 3.0.0-alpha.259 → 3.0.0-alpha.261

package/src/adapter/Geocoder/Geocoder_AwsLocation_Ops.res.mjs

@@ -2,6 +2,7 @@
 
 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 Location$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/Location.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ClientLocation from "@aws-sdk/client-location";
 
@@ -42,7 +43,18 @@ async function handler(event) {
   try {
     let indexName = Stdlib_Option.getOr(getEnv("PLACE_INDEX_NAME"), "");
     let q = Stdlib_Option.getOr(readQueryParam(event), "");
-    if (indexName === "" || q === "") {
+    if (indexName === "") {
+      console.error("Geocoder: PLACE_INDEX_NAME is unset");
+      return {
+        statusCode: 502,
+        headers: Object.fromEntries([[
+            "content-type",
+            "application/json"
+          ]]),
+        body: "[]"
+      };
+    }
+    if (q === "") {
       return {
         statusCode: 200,
         headers: Object.fromEntries([[
@@ -52,8 +64,7 @@ async function handler(event) {
         body: "[]"
       };
     }
-    let client = new ClientLocation.LocationClient();
-    let resp = await client.send(new ClientLocation.SearchPlaceIndexForTextCommand({
+    let resp = await Location$AwsSdk.SearchPlaceIndexForTextCommand.send(new ClientLocation.SearchPlaceIndexForTextCommand({
       IndexName: indexName,
       Text: q,
       MaxResults: 5
@@ -73,6 +84,7 @@ async function handler(event) {
       }
       let lng = pt[0];
       let lat = pt[1];
+      let rel = r.Relevance;
       return Object.fromEntries([
         [
           "label",
@@ -86,7 +98,10 @@ async function handler(event) {
           "lng",
           lng
         ]
-      ]);
+      ].concat(rel !== undefined ? [[
+            "relevance",
+            rel
+          ]] : []));
     });
     return {
       statusCode: 200,
@@ -100,7 +115,7 @@ async function handler(event) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     console.error("Geocoder: search failed", exn);
     return {
-      statusCode: 200,
+      statusCode: 502,
       headers: Object.fromEntries([[
           "content-type",
           "application/json"
@@ -110,10 +125,13 @@ async function handler(event) {
   }
 }
 
+let Search;
+
 export {
+  Search,
   getEnv,
   jsonHeaders,
   readQueryParam,
   handler,
 }
-/* @aws-sdk/client-location Not a pure module */
+/* Location-AwsSdk Not a pure module */

package/src/adapter/Runtime/AutomationSliceEntryPoint.mjs

@@ -45,7 +45,19 @@ async function buildAllHandlers() {
           specModule.name,
           automationSliceCallbackMake(specModule)(bodyModule)
         );
-    StreamOps.addToRegistry(handlers, entry.sourceUrn, registered);
+    // A slice can listen on several streams — its plugin's DCB log and any
+    // Aggregate EventTopic it named. Register the one handler under each, since
+    // the router dispatches by the record's own eventSourceARN. `sourceUrn` is
+    // the pre-multi-source spelling, kept as a fallback so an older handler
+    // config still routes.
+    const sourceUrns = entry.sourceUrns?.length
+      ? entry.sourceUrns
+      : entry.sourceUrn
+        ? [entry.sourceUrn]
+        : [];
+    for (const sourceUrn of sourceUrns) {
+      StreamOps.addToRegistry(handlers, sourceUrn, registered);
+    }
   }));
 
   return handlers;

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -24,6 +24,20 @@ type sliceInfo = {
   // Threaded to phase 1 collect/resolve on the automation path (mirrors the
   // in-process builder's `~context`); outbound slices take no context.
   context: option<Reventless.AutomationSlice.context>,
+  // The non-DCB topics this slice subscribes to — an Aggregate's EventTopic when
+  // it names one by `Spec.name`. Empty for the common DCB-only slice.
+  //
+  // Captured *synchronously* here for the same reason the whole `bundledInfos`
+  // path exists: `forEventCollector` runs inside a `Pulumi.Output.apply`, so
+  // `storedSpecs` — which carries the resolved topics on the dead `finish` path
+  // — is still empty when `finishWithDcbEventLog` runs. The core builders
+  // compute this dict before that apply, so the value is available in time; it
+  // just had nowhere to go until now.
+  sourceTopics: ReventlessCore.EventTopic.allOutputs,
+  // Whether this slice also reads the plugin's own DCB event log. True for every
+  // slice that declares no sources (the default) and for any that names the log
+  // explicitly, which is why it is not derivable from `sourceTopics` being empty.
+  consumesDcbLog: bool,
 }
 
 let bundledInfos: dict<sliceInfo> = Dict.make()
@@ -35,6 +49,9 @@ let setDcbQueueUrl = url => dcbQueueUrlRef := Some(url)
 // ApiFragmentRegistry push (2e) to dispatch RecordApiFragmentPush.
 let getDcbQueueUrl = () => dcbQueueUrlRef.contents
 
+// `~sourceTopics` / `~consumesDcbLog` default to the DCB-only shape every slice
+// had before aggregate sources existed, so a caller that has not been updated
+// keeps exactly its previous wiring.
 let registerAutomationSlice = (
   ~name,
   ~specModulePath,
@@ -43,10 +60,21 @@ let registerAutomationSlice = (
   ~queryDbTableName,
   ~queryDbResources=[],
   ~context=?,
+  ~sourceTopics=Dict.make(),
+  ~consumesDcbLog=true,
 ) =>
   bundledInfos->Dict.set(
     name,
-    {specModulePath, bodyModulePath, callbackType, queryDbTableName, queryDbResources, context},
+    {
+      specModulePath,
+      bodyModulePath,
+      callbackType,
+      queryDbTableName,
+      queryDbResources,
+      context,
+      sourceTopics,
+      consumesDcbLog,
+    },
   )
 
 type storedSpec = {
@@ -198,6 +226,16 @@ let finish = () =>
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+        // Deploy-derived capability endpoints — a geocoder URL today. Plugin-wide
+        // rather than per-handler, which is why they sit here and not inside
+        // HANDLER_CONFIG: this is one shared Lambda and every slice on it reaches
+        // the same capability. A capability the platform did not provision arrives
+        // as "", which its client reads as "not configured" and reports as a
+        // retryable `Unavailable` — a modelled outcome rather than a missing
+        // variable that fails as a crash.
+        PluginRuntime_Builder.capabilityEnv()->Array.forEach(((name, value)) =>
+          envVars->Dict.set(name, value->Pulumi.Output.asInput)
+        )
 
         let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
           ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",
@@ -249,9 +287,18 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         let opts = {Pulumi.ComponentResource.parent: parent}
         let dcbOutputs: ReventlessCore.DcbEventLog.outputs =
           dcbEventLog->ReventlessCore.Component.outputs
+        // The plugin's DCB log, plus every Aggregate EventTopic any slice on this
+        // Lambda named. One channel spans them all: `connect` turns each topic
+        // into its own event-source mapping, and the entry point routes an
+        // incoming record to the handlers registered for its stream, so a slice
+        // only ever sees the sources it asked for.
         let eventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
           ("DcbEventLog", dcbOutputs.eventTopic),
         ])
+        bundledInfos->Dict.forEach(info =>
+          info.sourceTopics->Dict.forEachWithKey((topic, key) => eventTopics->Dict.set(key, topic))
+        )
+
         let channel = EventCollectorChannel.make(
           ~name="AllAutomationSlices",
           ~eventTopics,
@@ -259,13 +306,29 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           ~opts,
         )
 
-        // One DCB stream URN, identical for every slice on this plugin log — the
-        // dispatch key the entry point maps event-source records back to.
-        let sourceUrn = switch dcbOutputs.eventTopic.resources->Array.get(0) {
+        let dcbSourceUrn = switch dcbOutputs.eventTopic.resources->Array.get(0) {
         | Some(resource) => resource.urn
         | None => Pulumi.Output.make("")
         }
 
+        // The stream URNs this one slice listens on — the dispatch keys the entry
+        // point maps event-source records back to. Per slice rather than one
+        // shared DCB URN, which is what lets an Aggregate-sourced slice exist at
+        // all: its events arrive on the Aggregate's stream and would otherwise
+        // reach a registry that has never heard of them.
+        let sourceUrnsFor = (info: sliceInfo): Pulumi.Output.t<array<string>> => {
+          let urns = []
+          if info.consumesDcbLog {
+            urns->Array.push(dcbSourceUrn)->ignore
+          }
+          info.sourceTopics
+          ->Dict.valuesToArray
+          ->Array.forEach(topic =>
+            topic.resources->Array.forEach(resource => urns->Array.push(resource.urn)->ignore)
+          )
+          urns->Pulumi.Output.all
+        }
+
         let dcbQueueUrl = switch dcbQueueUrlRef.contents {
         | Some(url) => url
         | None => Pulumi.Output.make("NOT_AVAILABLE")
@@ -297,10 +360,16 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           }
 
           let handlerJson =
-            Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, sourceUrn))
-            ->Pulumi.Output.apply(((tableName, queueUrl, urn)) =>
-              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${urn}"${contextFragment}}`
-            )
+            Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, sourceUrnsFor(info)))
+            ->Pulumi.Output.apply(((tableName, queueUrl, urns)) => {
+              let urnsJson =
+                urns->Array.map(JSON.Encode.string)->JSON.Encode.array->JSON.stringify
+              // `sourceUrn` stays beside `sourceUrns` so a handler config read by
+              // an entry point that predates multi-source still routes its first
+              // stream rather than none.
+              let firstUrn = urns->Array.get(0)->Option.getOr("")
+              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${firstUrn}","sourceUrns":${urnsJson}${contextFragment}}`
+            })
           let _ = handlerOutputs->Array.push(handlerJson)
         })
 
@@ -310,6 +379,16 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+        // Deploy-derived capability endpoints — a geocoder URL today. Plugin-wide
+        // rather than per-handler, which is why they sit here and not inside
+        // HANDLER_CONFIG: this is one shared Lambda and every slice on it reaches
+        // the same capability. A capability the platform did not provision arrives
+        // as "", which its client reads as "not configured" and reports as a
+        // retryable `Unavailable` — a modelled outcome rather than a missing
+        // variable that fails as a crash.
+        PluginRuntime_Builder.capabilityEnv()->Array.forEach(((name, value)) =>
+          envVars->Dict.set(name, value->Pulumi.Output.asInput)
+        )
 
         let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
           ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as PluginRuntime_Builder$ReventlessAws from "../../plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -27,16 +28,20 @@ function getDcbQueueUrl() {
   return dcbQueueUrlRef.contents;
 }
 
-function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context) {
+function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context, sourceTopicsOpt, consumesDcbLogOpt) {
   let callbackType = callbackTypeOpt !== undefined ? callbackTypeOpt : "automation";
   let queryDbResources = queryDbResourcesOpt !== undefined ? queryDbResourcesOpt : [];
+  let sourceTopics = sourceTopicsOpt !== undefined ? sourceTopicsOpt : ({});
+  let consumesDcbLog = consumesDcbLogOpt !== undefined ? consumesDcbLogOpt : true;
   bundledInfos[name] = {
     specModulePath: specModulePath,
     bodyModulePath: bodyModulePath,
     callbackType: callbackType,
     queryDbTableName: queryDbTableName,
     queryDbResources: queryDbResources,
-    context: context
+    context: context,
+    sourceTopics: sourceTopics,
+    consumesDcbLog: consumesDcbLog
   };
 }
 
@@ -129,6 +134,9 @@ function finish() {
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      PluginRuntime_Builder$ReventlessAws.capabilityEnv().forEach(param => {
+        envVars[param[0]] = param[1];
+      });
       let match$1 = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
       let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", "AutomationSlice", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, undefined, opts);
       let channelSpecs = storedSpecs.map(param => param.channelSpec);
@@ -157,9 +165,24 @@ function finishWithDcbEventLog(dcbEventLog) {
           "DcbEventLog",
           dcbOutputs.eventTopic
         ]]);
+      Stdlib_Dict.forEach(bundledInfos, info => Stdlib_Dict.forEachWithKey(info.sourceTopics, (topic, key) => {
+        eventTopics[key] = topic;
+      }));
       let channel = EventCollectorChannel_DynamoDbStream$ReventlessAws.make("AllAutomationSlices", eventTopics, undefined, opts);
       let resource = dcbOutputs.eventTopic.resources[0];
-      let sourceUrn = resource !== undefined ? resource.urn : Pulumi.output("");
+      let dcbSourceUrn = resource !== undefined ? resource.urn : Pulumi.output("");
+      let sourceUrnsFor = info => {
+        let urns = [];
+        if (info.consumesDcbLog) {
+          urns.push(dcbSourceUrn);
+        }
+        Object.values(info.sourceTopics).forEach(topic => {
+          topic.resources.forEach(resource => {
+            urns.push(resource.urn);
+          });
+        });
+        return Pulumi.all(urns);
+      };
       let url = dcbQueueUrlRef.contents;
       let dcbQueueUrl = url !== undefined ? url : Pulumi.output("NOT_AVAILABLE");
       let handlerOutputs = [];
@@ -181,13 +204,21 @@ function finishWithDcbEventLog(dcbEventLog) {
         let handlerJson = Pulumi.all([
           info.queryDbTableName,
           dcbQueueUrl,
-          sourceUrn
-        ]).apply(param => `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + param[2] + `"` + contextFragment + `}`);
+          sourceUrnsFor(info)
+        ]).apply(param => {
+          let urns = param[2];
+          let urnsJson = JSON.stringify(urns.map(prim => prim));
+          let firstUrn = Stdlib_Option.getOr(urns[0], "");
+          return `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + firstUrn + `","sourceUrns":` + urnsJson + contextFragment + `}`;
+        });
         handlerOutputs.push(handlerJson);
       });
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      PluginRuntime_Builder$ReventlessAws.capabilityEnv().forEach(param => {
+        envVars[param[0]] = param[1];
+      });
       let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
       let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", "AutomationSlice", match.code, match.sourceCodeHash, envVars, 1024, 30, undefined, undefined, undefined, undefined, undefined, opts);
       EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllAutomationSlices", [{

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res

@@ -331,26 +331,13 @@ let makeFromCodeAsset: (
     // is no race against Lambda's lazy auto-created group. Namespace/dimension
     // are CloudWatch-specific and live here, not in core (provider-neutral).
     if dcbMetrics {
-      [
-        "AppendRetry",
-        "AppendConflict",
-        "DcbDecisionModelCacheHit",
-        "DcbDecisionModelCacheMiss",
-        "DcbDecisionModelDeltaEventCount",
-      ]->Array.forEach(metricName => {
+      Util_DcbMetrics.metricNames->Array.forEach(metricName => {
         let _ = Cloudwatch.LogMetricFilter.make(
           ~name=`${name}${metricName}Filter`,
           ~args={
-            pattern: `{ $.reventlessMetric = "${metricName}" }`->Pulumi.Input.make,
+            pattern: Util_DcbMetrics.patternFor(metricName)->Pulumi.Input.make,
             logGroupName: logGroup.name->Pulumi.Output.asInput,
-            metricTransformation: ({
-              name: metricName->Pulumi.Input.make,
-              namespace: "Reventless/DCB"->Pulumi.Input.make,
-              value: "$.value"->Pulumi.Input.make,
-              defaultValue: "0"->Pulumi.Input.make,
-              unit: "Count"->Pulumi.Input.make,
-              dimensions: Dict.fromArray([("slice", "$.slice")])->Pulumi.Input.make,
-            }: Cloudwatch.LogMetricFilter.metricTransformation)->Pulumi.Input.make,
+            metricTransformation: Util_DcbMetrics.transformationFor(metricName)->Pulumi.Input.make,
           },
           ~opts?,
         )

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs

@@ -20,6 +20,7 @@ import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as Util_Lambda$ReventlessAws from "../../util/Util_Lambda.res.mjs";
 import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
 import * as Util_IAM_Role$ReventlessAws from "../../util/Util_IAM_Role.res.mjs";
+import * as Util_DcbMetrics$ReventlessAws from "../../util/Util_DcbMetrics.res.mjs";
 import * as Util_LocalConfig$ReventlessAws from "../../util/Util_LocalConfig.res.mjs";
 import * as Util_HostUiDomain$ReventlessAws from "../../util/Util_HostUiDomain.res.mjs";
 import * as Util_LogRetention$ReventlessAws from "../../util/Util_LogRetention.res.mjs";
@@ -136,27 +137,11 @@ function makeFromCodeAsset(name, unitKind, componentKind, code, sourceCodeHash,
       tags: tagsFor(name + `LogGroup`, "Logs")
     }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
     if (dcbMetrics) {
-      [
-        "AppendRetry",
-        "AppendConflict",
-        "DcbDecisionModelCacheHit",
-        "DcbDecisionModelCacheMiss",
-        "DcbDecisionModelDeltaEventCount"
-      ].forEach(metricName => {
+      Util_DcbMetrics$ReventlessAws.metricNames.forEach(metricName => {
         new (Aws.cloudwatch.LogMetricFilter)(name + metricName + `Filter`, {
-          pattern: `{ $.reventlessMetric = "` + metricName + `" }`,
+          pattern: Util_DcbMetrics$ReventlessAws.patternFor(metricName),
           logGroupName: logGroup.name,
-          metricTransformation: {
-            name: metricName,
-            namespace: "Reventless/DCB",
-            value: "$.value",
-            defaultValue: "0",
-            unit: "Count",
-            dimensions: Object.fromEntries([[
-                "slice",
-                "$.slice"
-              ]])
-          }
+          metricTransformation: Util_DcbMetrics$ReventlessAws.transformationFor(metricName)
         }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
       });
       return;

package/src/components/AutomationSlice_Builder.res

@@ -37,6 +37,17 @@ module Make = (Api: {
       let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
       let queryDbTableName = tableResource.name
 
+      // An automation names its sources through its Mappings rather than a flat
+      // list, but the runtime question is the same one the outbound builder
+      // answers: which streams must this Lambda listen on. Unlike outbound, an
+      // automation's DCB log is already a key in `allEventTopics`, so the filter
+      // picks it up and nothing extra has to be assumed.
+      let sourceTopics =
+        allEventTopics->ReventlessCore.EventTopic.filter(sourceNames->Belt.Set.String.fromArray)
+      let consumesDcbLog =
+        sourceNames->Array.length == 0 ||
+          sourceNames->Array.some(name => !(allEventTopics->Dict.has(name)))
+
       EventCollectorRuntimeBuilder.registerAutomationSlice(
         ~name=Spec.name,
         ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
@@ -45,6 +56,8 @@ module Make = (Api: {
         ~queryDbTableName,
         ~queryDbResources=queryDbOutputs.resources,
         ~context,
+        ~sourceTopics,
+        ~consumesDcbLog,
       )
 
       as_

package/src/components/AutomationSlice_Builder.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as EventTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventTopic/EventTopic.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
 import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
 import * as AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
@@ -36,19 +38,22 @@ function Make(Api) {
   })(Api);
   let Make$1 = Spec => (Automation => {
     let InnerMake = Inner.Make(Spec)(Automation);
+    let sourceNames = InnerMake.sourceNames;
     let make = (allEventTopics, publishJsons, context, runtime, opts) => {
       let as_ = InnerMake.make(allEventTopics, publishJsons, context, runtime, opts);
       let queryDbOutputs = Component$ReventlessCore.outputs(as_).queryDb;
       let tableResource = queryDbOutputs.resources[0];
       let queryDbTableName = tableResource.name;
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context);
+      let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(sourceNames));
+      let consumesDcbLog = sourceNames.length === 0 || sourceNames.some(name => !(name in allEventTopics));
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context, sourceTopics, consumesDcbLog);
       return as_;
     };
     return {
       Spec: Spec,
       Automation: Automation,
       queryDbName: InnerMake.queryDbName,
-      sourceNames: InnerMake.sourceNames,
+      sourceNames: sourceNames,
       make: make
     };
   });

package/src/components/OutboundTranslationSlice_Builder.res

@@ -38,13 +38,27 @@ module Make = (Api: {
     type component = InnerMake.component
     let queryDbName = InnerMake.queryDbName
 
-    let make = (~dcbEventLog, ~publishJsons, ~runtime=?, ~opts=?): component => {
-      let ots = InnerMake.make(~dcbEventLog, ~publishJsons, ~runtime?, ~opts?)
+    let make = (~dcbEventLog, ~allEventTopics=Dict.make(), ~publishJsons, ~runtime=?, ~opts=?): component => {
+      let ots = InnerMake.make(~dcbEventLog, ~allEventTopics, ~publishJsons, ~runtime?, ~opts?)
 
       let queryDbOutputs = (ots->ReventlessCore.Component.outputs).queryDb
       let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
       let queryDbTableName = tableResource.name
 
+      // Which streams this slice's Lambda must actually listen on. The core
+      // `make` above has already validated every declared name and thrown on a
+      // typo, so this only has to select — a name absent from `allEventTopics`
+      // is necessarily the plugin's own DCB log, the one source that dict does
+      // not carry.
+      let declaredSources = Spec.sourceNames
+      let sourceTopics =
+        allEventTopics->ReventlessCore.EventTopic.filter(
+          declaredSources->Belt.Set.String.fromArray,
+        )
+      let consumesDcbLog =
+        declaredSources->Array.length == 0 ||
+          declaredSources->Array.some(name => !(allEventTopics->Dict.has(name)))
+
       AutomationSliceRuntime_Builder_Single.registerAutomationSlice(
         ~name=Spec.name,
         ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
@@ -52,6 +66,8 @@ module Make = (Api: {
         ~callbackType="outbound",
         ~queryDbTableName,
         ~queryDbResources=queryDbOutputs.resources,
+        ~sourceTopics,
+        ~consumesDcbLog,
       )
 
       ots

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as EventTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventTopic/EventTopic.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
 import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
 import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
@@ -43,12 +45,16 @@ function Make(Api) {
   })(Api);
   let Make$1 = Spec => (Translation => {
     let InnerMake = Inner.Make(Spec)(Translation);
-    let make = (dcbEventLog, publishJsons, runtime, opts) => {
-      let ots = InnerMake.make(dcbEventLog, publishJsons, runtime, opts);
+    let make = (dcbEventLog, allEventTopicsOpt, publishJsons, runtime, opts) => {
+      let allEventTopics = allEventTopicsOpt !== undefined ? allEventTopicsOpt : ({});
+      let ots = InnerMake.make(dcbEventLog, allEventTopics, publishJsons, runtime, opts);
       let queryDbOutputs = Component$ReventlessCore.outputs(ots).queryDb;
       let tableResource = queryDbOutputs.resources[0];
       let queryDbTableName = tableResource.name;
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined);
+      let declaredSources = Spec.sourceNames;
+      let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(declaredSources));
+      let consumesDcbLog = declaredSources.length === 0 || declaredSources.some(name => !(name in allEventTopics));
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined, sourceTopics, consumesDcbLog);
       return ots;
     };
     return {

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -20,6 +20,37 @@ let configRef: ref<adminConfig> = ref({
   clonerEnabled: false,
 })
 
+/**
+Deploy-derived environment for a plugin's slice Lambdas, keyed by variable name.
+
+A capability the platform provisions — a geocoder, and the same shape whenever
+the next one arrives — is reachable only through a value the platform computes:
+a URL, an index name, a queue. The deployer never types it, which is what keeps
+it out of `commandHandlerConfig` (memory, timeout, the knobs a human chooses)
+and out of the hand-edited config files this framework exists to remove.
+
+Kept apart from `configRef` because the two are filled at different moments and
+by different halves: `registerConfig` runs inside `deployPlatform` and replaces
+its record wholesale, while these values are only knowable in `deployPlugin`,
+where a plugin stack reads them off the platform's stack reference.
+
+Keyed by the variable name rather than by capability so the runtime builders
+merge a dict they need no knowledge of. Naming a capability's variable is then
+a single decision at the single call site that knows which capability it is —
+not a table two modules have to agree on.
+*/
+let capabilityEnvRef: dict<Pulumi.Output.t<string>> = Dict.make()
+
+/** Registers one deploy-derived variable. Must be called before the plugin
+    builds — the slice runtimes read the dict when their finalizer runs. */
+let registerCapabilityEnv = (name: string, value: Pulumi.Output.t<string>) =>
+  capabilityEnvRef->Dict.set(name, value)
+
+/** The registered variables, for a runtime builder to merge into its Lambda's
+    environment. Empty is the ordinary answer for a platform that provisions no
+    capability, so this returns `[]` rather than throwing. */
+let capabilityEnv = () => capabilityEnvRef->Dict.toArray
+
 type sliceModulePaths = {
   specPath: string,
   behaviorPath: string,

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -34,6 +34,16 @@ let configRef = {
   }
 };
 
+let capabilityEnvRef = {};
+
+function registerCapabilityEnv(name, value) {
+  capabilityEnvRef[name] = value;
+}
+
+function capabilityEnv() {
+  return Object.entries(capabilityEnvRef);
+}
+
 let dcbConfigRef = {
   contents: {
     pluginName: "",
@@ -493,6 +503,9 @@ function Make(EventCollectorChannel) {
 export {
   log,
   configRef,
+  capabilityEnvRef,
+  registerCapabilityEnv,
+  capabilityEnv,
   dcbConfigRef,
   registeredSliceModulePaths,
   registerStateChangeSliceSpec,