@reventlessdev/reventless-aws 3.0.0-alpha.332 → 3.0.0-alpha.334

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -542,6 +542,12 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         }
 
         let handlerOutputs: array<Pulumi.Output.t<string>> = []
+        // The static half of each slice's config — module paths and context, all
+        // known synchronously. Rides in the code archive rather than the
+        // environment: two module specifiers per slice is the term that grows
+        // with the plugin, and it is what pushed this Lambda past AWS's 4KB env
+        // limit. Keyed by slice name, which is what the compact env entry names.
+        let sliceModuleEntries: array<string> = []
         let packageDirs: dict<string> = Dict.make()
         let allQueryDbResources: array<ReventlessInfra.Adapter.resource> = []
         // Whether any slice publishes to the DCB fallback rather than a target
@@ -549,7 +555,7 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         // too, once, below the loop.
         let anyDcbFallback = ref(false)
 
-        bundledInfos->Dict.forEachWithKey((info, _name) => {
+        bundledInfos->Dict.forEachWithKey((info, name) => {
           info.queryDbResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
           // The queue this slice publishes its command to. An Aggregate registers
           // its CommandTopic while plugin construction is still synchronous —
@@ -582,6 +588,12 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           | None => ""
           }
 
+          let nameJson = name->JSON.stringifyAny->Option.getOr(`""`)
+          let _ =
+            sliceModuleEntries->Array.push(
+              `${nameJson}:{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType}${contextFragment}}`,
+            )
+
           // Per slice, not plugin-wide: an outbound slice targeting an Aggregate
           // publishes to that aggregate's CommandTopic. Everything else keeps the
           // DCB topic, which is what the field has always meant — and with it the
@@ -590,17 +602,23 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           | Some({queueUrl, isFifo}) => (queueUrl, isFifo)
           | None => (dcbQueueUrl, dcbQueueIsFifo.contents)
           }
+          // What each slice may override is decided structurally, not from the
+          // resolved values: a slice listening only on the plugin's DCB log, and
+          // publishing to the DCB fallback, repeats the shared urn and queue URL
+          // exactly — so it emits neither and inherits both.
+          let hasOwnUrns =
+            !(info.consumesDcbLog) || info.sourceTopics->Dict.keysToArray->Array.length > 0
           let handlerJson =
             Pulumi.Output.all3((info.queryDbTableName, commandQueueUrl, 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("")
-              let fifoJson = commandQueueIsFifo ? "true" : "false"
-              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","commandQueueIsFifo":${fifoJson},"sourceUrn":"${firstUrn}","sourceUrns":${urnsJson}${contextFragment}}`
+              let urnsFragment = hasOwnUrns
+                ? `,"u":${urns->Array.map(JSON.Encode.string)->JSON.Encode.array->JSON.stringify}`
+                : ""
+              let queueFragment = switch target {
+              | Some(_) => `,"k":"${queueUrl}","f":${commandQueueIsFifo ? "true" : "false"}`
+              | None => ""
+              }
+              `{"n":${nameJson},"q":"${tableName}"${urnsFragment}${queueFragment}}`
             })
           let _ = handlerOutputs->Array.push(handlerJson)
         })
@@ -613,9 +631,24 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           dcbQueueResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
         }
 
+        // The defaults every non-overriding slice inherits, carried once.
+        let sharedOutput =
+          Pulumi.Output.all2((dcbQueueUrl, dcbSourceUrn))->Pulumi.Output.apply(((
+            queueUrl,
+            urn,
+          )) => {
+            let fifoJson = dcbQueueIsFifo.contents ? "true" : "false"
+            let urnJson = urn->JSON.stringifyAny->Option.getOr(`""`)
+            `"queueUrl":"${queueUrl}","commandQueueIsFifo":${fifoJson},"urns":[${urnJson}]`
+          })
+
         let handlerConfigOutput =
-          Pulumi.Output.all(handlerOutputs)
-          ->Pulumi.Output.apply(handlers => `{"handlers":[${handlers->Array.join(",")}]}`)
+          Pulumi.Output.all2((sharedOutput, Pulumi.Output.all(handlerOutputs)))
+          ->Pulumi.Output.apply(((shared, handlers)) => {
+            let json = `{${shared},"handlers":[${handlers->Array.join(",")}]}`
+            Util_LambdaEnvBudget.check(~lambdaName="AllAutomationSlices", ~handlerConfigJson=json)
+            json
+          })
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
@@ -630,9 +663,18 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           envVars->Dict.set(name, value->Pulumi.Output.asInput)
         )
 
+        // Carries no Pulumi Output, so the archive is still built synchronously —
+        // the table names and urns that do are what stays in HANDLER_CONFIG.
+        let extraStringAssets = Dict.make()
+        extraStringAssets->Dict.set(
+          "automationSliceModules.json",
+          `{${sliceModuleEntries->Array.join(",")}}`,
+        )
+
         let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
           ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",
           ~packageDirs,
+          ~extraStringAssets,
         )
 
         let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(

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

@@ -18,6 +18,7 @@ import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/
 import * as Cloudwatch_EventRule$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Cloudwatch/Cloudwatch_EventRule.res.mjs";
 import * as Cloudwatch_EventTarget$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Cloudwatch/Cloudwatch_EventTarget.res.mjs";
 import * as CommandTopicRegistry$ReventlessAws from "../CommandTopic/CommandTopicRegistry.res.mjs";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../../util/Util_LambdaEnvBudget.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";
@@ -279,12 +280,13 @@ function finishWithDcbEventLog(dcbEventLog) {
       let url = dcbQueueUrlRef.contents;
       let dcbQueueUrl = url !== undefined ? url : Pulumi.output("NOT_AVAILABLE");
       let handlerOutputs = [];
+      let sliceModuleEntries = [];
       let packageDirs = {};
       let allQueryDbResources = [];
       let anyDcbFallback = {
         contents: false
       };
-      Stdlib_Dict.forEachWithKey(bundledInfos, (info, _name) => {
+      Stdlib_Dict.forEachWithKey(bundledInfos, (info, name) => {
         info.queryDbResources.forEach(r => {
           allQueryDbResources.push(r);
         });
@@ -303,6 +305,8 @@ function finishWithDcbEventLog(dcbEventLog) {
         let callbackType = Stdlib_Option.getOr(JSON.stringify(info.callbackType), `""`);
         let context = info.context;
         let contextFragment = context !== undefined ? Stdlib_Option.getOr(Stdlib_Option.map(JSON.stringify(context), json => `,"context":` + json), "") : "";
+        let nameJson = Stdlib_Option.getOr(JSON.stringify(name), `""`);
+        sliceModuleEntries.push(nameJson + `:{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + contextFragment + `}`);
         let match = target !== undefined ? [
             target.queueUrl,
             target.isFifo
@@ -311,16 +315,17 @@ function finishWithDcbEventLog(dcbEventLog) {
             dcbQueueIsFifo.contents
           ];
         let commandQueueIsFifo = match[1];
+        let hasOwnUrns = !info.consumesDcbLog || Object.keys(info.sourceTopics).length !== 0;
         let handlerJson = Pulumi.all([
           info.queryDbTableName,
           match[0],
           sourceUrnsFor(info)
         ]).apply(param => {
-          let urns = param[2];
-          let urnsJson = JSON.stringify(urns.map(prim => prim));
-          let firstUrn = Stdlib_Option.getOr(urns[0], "");
-          let fifoJson = commandQueueIsFifo ? "true" : "false";
-          return `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","commandQueueIsFifo":` + fifoJson + `,"sourceUrn":"` + firstUrn + `","sourceUrns":` + urnsJson + contextFragment + `}`;
+          let urnsFragment = hasOwnUrns ? `,"u":` + JSON.stringify(param[2].map(prim => prim)) : "";
+          let queueFragment = target !== undefined ? `,"k":"` + param[1] + `","f":` + (
+              commandQueueIsFifo ? "true" : "false"
+            ) : "";
+          return `{"n":` + nameJson + `,"q":"` + param[0] + `"` + urnsFragment + queueFragment + `}`;
         });
         handlerOutputs.push(handlerJson);
       });
@@ -329,13 +334,30 @@ function finishWithDcbEventLog(dcbEventLog) {
           allQueryDbResources.push(r);
         });
       }
-      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
+      let sharedOutput = Pulumi.all([
+        dcbQueueUrl,
+        dcbSourceUrn
+      ]).apply(param => {
+        let fifoJson = dcbQueueIsFifo.contents ? "true" : "false";
+        let urnJson = Stdlib_Option.getOr(JSON.stringify(param[1]), `""`);
+        return `"queueUrl":"` + param[0] + `","commandQueueIsFifo":` + fifoJson + `,"urns":[` + urnJson + `]`;
+      });
+      let handlerConfigOutput = Pulumi.all([
+        sharedOutput,
+        Pulumi.all(handlerOutputs)
+      ]).apply(param => {
+        let json = `{` + param[0] + `,"handlers":[` + param[1].join(",") + `]}`;
+        Util_LambdaEnvBudget$ReventlessAws.check("AllAutomationSlices", json, undefined);
+        return json;
+      });
       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, undefined);
+      let extraStringAssets = {};
+      extraStringAssets["automationSliceModules.json"] = `{` + sliceModuleEntries.join(",") + `}`;
+      let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, extraStringAssets, 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", [{
           channel: channel,

package/src/adapter/Runtime/EventCollectorRuntime_Builder_Single.res

@@ -251,9 +251,11 @@ let finish = () =>
 
         let handlerConfigOutput =
           Pulumi.Output.all(handlerOutputs)
-          ->Pulumi.Output.apply(handlers =>
-            `{"handlers":[${handlers->Array.join(",")}]}`
-          )
+          ->Pulumi.Output.apply(handlers => {
+            let json = `{"handlers":[${handlers->Array.join(",")}]}`
+            Util_LambdaEnvBudget.check(~lambdaName="AllReadModels", ~handlerConfigJson=json)
+            json
+          })
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)

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

@@ -18,6 +18,7 @@ import * as EventLogBackend$ReventlessAws from "../EventLog/EventLogBackend.res.
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as PgProjectionFeed$ReventlessAws from "../Postgres/PgProjectionFeed.res.mjs";
 import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../../util/Util_LambdaEnvBudget.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -142,7 +143,11 @@ function finish() {
         });
         handlerOutputs.push(handlerJson);
       });
-      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
+      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => {
+        let json = `{"handlers":[` + handlers.join(",") + `]}`;
+        Util_LambdaEnvBudget$ReventlessAws.check("AllReadModels", json, undefined);
+        return json;
+      });
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
       let anyPgStream = Object.keys(readModelInfos).some(rmName => {

package/src/adapter/Runtime/SideEffectHandlerRuntime_Builder_Single.res

@@ -153,9 +153,11 @@ let finish = () =>
 
         let handlerConfigOutput =
           Pulumi.Output.all(handlerOutputs)
-          ->Pulumi.Output.apply(handlers =>
-            `{"handlers":[${handlers->Array.join(",")}]}`
-          )
+          ->Pulumi.Output.apply(handlers => {
+            let json = `{"handlers":[${handlers->Array.join(",")}]}`
+            Util_LambdaEnvBudget.check(~lambdaName="AllSideEffectHandlers", ~handlerConfigJson=json)
+            json
+          })
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)

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

@@ -11,6 +11,7 @@ import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/co
 import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../../util/Util_LambdaEnvBudget.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -109,7 +110,11 @@ function finish() {
         });
         handlerOutputs.push(handlerJson);
       });
-      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
+      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => {
+        let json = `{"handlers":[` + handlers.join(",") + `]}`;
+        Util_LambdaEnvBudget$ReventlessAws.check("AllSideEffectHandlers", json, undefined);
+        return json;
+      });
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
       Stdlib_Dict.forEachWithKey(extraEnvVarsAll, (v, k) => {

package/src/adapter/Runtime/StateViewSliceRuntime_Builder_Single.res

@@ -222,7 +222,9 @@ let buildLambda = (
         ->Array.join(",")
       let baseJson = base->JSON.stringifyAny->Option.getOr(`""`)
       let urnJson = sharedUrn->JSON.stringifyAny->Option.getOr(`""`)
-      `{"v":2,"base":${baseJson},"sourceUrn":${urnJson},"handlers":[${entries}]${pgFragment}}`
+      let json = `{"v":2,"base":${baseJson},"sourceUrn":${urnJson},"handlers":[${entries}]${pgFragment}}`
+      Util_LambdaEnvBudget.check(~lambdaName="AllStateViewSlices", ~handlerConfigJson=json)
+      json
     })
 
   let envVars: dict<Pulumi.Input.t<string>> = Dict.make()

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

@@ -18,6 +18,7 @@ import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/
 import * as QueryDbBackend$ReventlessAws from "../QueryDb/QueryDbBackend.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as PgProjectionFeed$ReventlessAws from "../Postgres/PgProjectionFeed.res.mjs";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../../util/Util_LambdaEnvBudget.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -144,7 +145,9 @@ function buildLambda(parent, handlerOutputs, packageDirs, channelSpecs, feedQueu
     }).join(",");
     let baseJson = Stdlib_Option.getOr(JSON.stringify(base), `""`);
     let urnJson = Stdlib_Option.getOr(JSON.stringify(sharedUrn), `""`);
-    return `{"v":2,"base":` + baseJson + `,"sourceUrn":` + urnJson + `,"handlers":[` + entries + `]` + param[1] + `}`;
+    let json = `{"v":2,"base":` + baseJson + `,"sourceUrn":` + urnJson + `,"handlers":[` + entries + `]` + param[1] + `}`;
+    Util_LambdaEnvBudget$ReventlessAws.check("AllStateViewSlices", json, undefined);
+    return json;
   });
   let envVars = {};
   envVars["HANDLER_CONFIG"] = handlerConfigOutput;

package/src/capability/Capability_Messaging.res

@@ -0,0 +1,141 @@
+// The messaging capability a deployment provisions: which transport, sending as
+// whom. The entry point a platform root calls; the transports sit below it.
+//
+// **All of it is configuration, none of it is code.** Which transport is a
+// per-environment decision — a staging stack should not mail customers, and
+// nothing about the shop it deploys says so — and the address is a per-account
+// fact, since SES sends from one verified identity. A repository cannot know
+// either, and a placeholder default for the address is worse than none: it
+// provisions an identity nobody can verify, after which every send is refused at
+// the sender while reading like a delivery problem.
+//
+// Config keys, on the usual ladder — env var `REVENTLESS_<SCREAMING_SNAKE>`, then
+// `Pulumi.local.yaml`, then `platform:<key>` in `Pulumi.<stack>.yaml`:
+//
+//   - `messagingEmailProvider`   — "ses" (default) or "log". Per channel, like
+//                                  the senders: an SMS transport will bring its own.
+//   - `messagingEmailSender`     — the address messages are sent from. Under
+//                                  `ses` it is verified and required; under
+//                                  `log` it is only a header and defaults.
+//   - `messagingEmailSenderName` — optional display name for the `From:` header.
+//   - `messagingSmsSender`       — origination number or sender id. Carried only;
+//                                  no transport reads it yet.
+//
+// **Unset is a real answer, and the deploy still checks it.** A platform whose
+// plugins declare the Messaging capability and which provisions no sender is
+// refused at deploy time by `Platform.deployPlatform`, naming the key — so "no
+// mail configured" cannot reach production as silence.
+
+let emailProviderKey = "messagingEmailProvider"
+let emailSenderKey = "messagingEmailSender"
+let emailSenderNameKey = "messagingEmailSenderName"
+let smsSenderKey = "messagingSmsSender"
+
+/** One key off the ladder, trimmed, with blank read as absent.
+
+    Blank matters because the ways to write "nothing" must not differ: a stray
+    `REVENTLESS_MESSAGING_EMAIL_SENDER=` in CI, a blank line in
+    `Pulumi.local.yaml`, and a key left with a space after the colon all mean the
+    stack named no sender. Honouring any of them would ask SES for an identity
+    with a blank address — a deploy failure whose cause is whitespace, and one
+    that reaches AWS before anything here explains it.
+
+    Trimmed rather than only compared, so a value that survives is also the value
+    used: an address with a trailing space is a `From:` header with one. */
+let configured = (key: string): option<string> =>
+  switch Util_LocalConfig.get(key) {
+  | Some(_) as v => v
+  | None => Pulumi.Config.make(Some("platform"))->Pulumi.Config.get(key)
+  }->Option.flatMap(value => {
+    let trimmed = value->String.trim
+    trimmed === "" ? None : Some(trimmed)
+  })
+
+/** The transports a deployment can choose between for the EMAIL channel. The name travels to the
+    Lambdas, so it is also the wire value — one spelling, not a deploy-time enum
+    and a runtime string that can disagree. */
+type emailProvider =
+  | Ses
+  | Log
+
+let emailProviderName = (provider: emailProvider): string =>
+  switch provider {
+  | Ses => "ses"
+  | Log => "log"
+  }
+
+/**
+Which transport this stack asked for. SES is the default, so a deployment that
+says nothing gets the real one — the safe direction is that mail works, and a
+stack opting out of sending says so explicitly.
+
+An unrecognised value is refused rather than defaulted. Falling back to SES on a
+typo would provision a real identity for a stack that asked to only log, which
+is the one mistake this key exists to prevent.
+*/
+let parseEmailProvider = (raw: string): emailProvider =>
+  switch raw->String.trim->String.toLowerCase {
+  | "ses" => Ses
+  | "log" => Log
+  | other =>
+    JsError.throwWithMessage(
+      `platform:${emailProviderKey} is "${other}", which is not an email provider.\n` ++
+      `  Known values: "ses" (default — a verified SES identity) and "log" ` ++
+      `(writes each message to the log, sends nothing).`,
+    )
+  }
+
+let emailProvider = (): emailProvider =>
+  configured(emailProviderKey)->Option.mapOr(Ses, parseEmailProvider)
+
+/** The `From:` a log-transport deployment presents as when the stack named no
+    address.
+
+    Hard-coded where the SES address is required, and the asymmetry follows from
+    what the value is for: a logged message reaches nobody, so there is nothing to
+    verify and nothing that differs per environment. `.test` is reserved for
+    exactly this (RFC 6761) — it can never resolve, so an address escaping into a
+    fixture cannot reach a real inbox. */
+let logDefaultAddress = "notifications@online-shop.test"
+
+/**
+Provision the capability and hand back the platform's messaging handle.
+
+`~name` is used only by the SES arm, which is the only arm with a resource: the
+log transport is a runtime decision carried in an environment variable, so choosing it
+creates nothing and costs nothing to leave configured on a stack that is torn
+down and rebuilt.
+*/
+let make = (
+  ~name: string,
+  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
+): ReventlessInfra.Platform.messagingSender => {
+  // Read whether or not there is an email sender: the SMS half is independent,
+  // and a stack may state one without the other.
+  let smsSender = configured(smsSenderKey)->Option.map(Pulumi.Input.make)
+  let chosen = emailProvider()
+  let displayName = configured(emailSenderNameKey)
+  let providerInput = Pulumi.Input.make(chosen->emailProviderName)
+
+  switch (chosen, configured(emailSenderKey)) {
+  // Asked for SES and named no address. Nothing is provisioned, and the deploy
+  // gate refuses this the moment a plugin declares it needs messaging — here
+  // rather than there because this module has no view of what the plugins want.
+  | (Ses, None) => {emailProvider: providerInput, smsSender: ?smsSender}
+  | (Ses, Some(address)) => {
+      emailSender: Capability_Messaging_Ses.emailSender(~name, ~address, ~displayName, ~opts?),
+      emailProvider: providerInput,
+      smsSender: ?smsSender,
+    }
+  | (Log, address) => {
+      emailSender: Pulumi.Input.make(
+        Reventless.Messaging.fromHeader(
+          ~displayName,
+          ~address=address->Option.getOr(logDefaultAddress),
+        ),
+      ),
+      emailProvider: providerInput,
+      smsSender: ?smsSender,
+    }
+  }
+}

package/src/capability/Capability_Messaging.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
+import * as Util_LocalConfig$ReventlessAws from "../util/Util_LocalConfig.res.mjs";
+import * as Capability_Messaging_Ses$ReventlessAws from "./Capability_Messaging_Ses.res.mjs";
+
+let emailProviderKey = "messagingEmailProvider";
+
+let emailSenderKey = "messagingEmailSender";
+
+let emailSenderNameKey = "messagingEmailSenderName";
+
+let smsSenderKey = "messagingSmsSender";
+
+function configured(key) {
+  let v = Util_LocalConfig$ReventlessAws.get(key);
+  return Stdlib_Option.flatMap(v !== undefined ? v : new Pulumi.Config("platform").get(key), value => {
+    let trimmed = value.trim();
+    if (trimmed === "") {
+      return;
+    } else {
+      return trimmed;
+    }
+  });
+}
+
+function emailProviderName(provider) {
+  if (provider === "Ses") {
+    return "ses";
+  } else {
+    return "log";
+  }
+}
+
+function parseEmailProvider(raw) {
+  let other = raw.trim().toLowerCase();
+  switch (other) {
+    case "log" :
+      return "Log";
+    case "ses" :
+      return "Ses";
+    default:
+      return Stdlib_JsError.throwWithMessage(`platform:` + emailProviderKey + ` is "` + other + `", which is not an email provider.\n  Known values: "ses" (default — a verified SES identity) and "log" (writes each message to the log, sends nothing).`);
+  }
+}
+
+function emailProvider() {
+  return Stdlib_Option.mapOr(configured(emailProviderKey), "Ses", parseEmailProvider);
+}
+
+let logDefaultAddress = "notifications@online-shop.test";
+
+function make(name, opts) {
+  let smsSender = Stdlib_Option.map(configured(smsSenderKey), prim => prim);
+  let chosen = emailProvider();
+  let displayName = configured(emailSenderNameKey);
+  let providerInput = emailProviderName(chosen);
+  let match = configured(emailSenderKey);
+  if (chosen === "Ses") {
+    if (match !== undefined) {
+      return {
+        emailSender: Capability_Messaging_Ses$ReventlessAws.emailSender(name, match, displayName, opts),
+        smsSender: smsSender,
+        emailProvider: providerInput
+      };
+    } else {
+      return {
+        smsSender: smsSender,
+        emailProvider: providerInput
+      };
+    }
+  } else {
+    return {
+      emailSender: Messaging$Reventless.fromHeader(displayName, Stdlib_Option.getOr(match, logDefaultAddress)),
+      smsSender: smsSender,
+      emailProvider: providerInput
+    };
+  }
+}
+
+export {
+  emailProviderKey,
+  emailSenderKey,
+  emailSenderNameKey,
+  smsSenderKey,
+  configured,
+  emailProviderName,
+  parseEmailProvider,
+  emailProvider,
+  logDefaultAddress,
+  make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/capability/Capability_Messaging_Ses.res

@@ -1,10 +1,11 @@
-// A verified SES sender identity, provisioned with the framework's house
-// conventions applied — the backing for the messaging capability's email channel.
+// A verified SES sender identity — the email channel's real transport.
 //
-// The identity is the whole of the provisioning: SES sends from a verified
-// address, and everything else a send needs travels on the message. So this
-// helper exists to make the sender a deploy-time decision with one owner rather
-// than an environment variable each stack spells for itself.
+// Provisioning only. Which transport a deployment uses, and what address it
+// sends from, are read by `Capability_Messaging`, which is the entry point a
+// platform root calls; this module receives a resolved address and creates the
+// identity for it. Split that way because a deployment can choose *not* to have
+// an SES identity, and a module that read its own config could not be left
+// uncalled without also leaving the config unread.
 //
 // **Verification is not instant and not automatic.** Creating the identity asks
 // AWS to send a confirmation mail to the address; until somebody follows it, SES
@@ -18,14 +19,26 @@
 
 open PulumiAws
 
-/** Declare the sender address and hand back the platform's messaging handle.
-    `~email` is the `From:` every message this deployment sends carries. */
-let make = (
+/**
+Create the identity and hand back the `From:` it sends as.
+
+`~name` is the Pulumi resource name — a URN rather than a setting, so it stays in
+code: moving it to config would replace the resource whenever a stack spelled it
+differently.
+
+The identity is created for the bare address, because SES verifies an address and
+not a header; the display name is applied afterwards, to the value the send path
+reads. Applied over the identity's own output rather than over the configured
+string, so the sender a Lambda is handed still depends on the resource existing.
+*/
+let emailSender = (
   ~name: string,
-  ~email: string,
+  ~address: string,
+  ~displayName: option<string>,
   ~opts: option<Pulumi.CustomResourceOptions.t>=?,
-): ReventlessInfra.Platform.messagingSender => {
-  let identity = SES.EmailIdentity.make(~name, ~args={email: email}, ~opts?)
-
-  {emailSender: identity.email->Pulumi.Output.asInput}
+): Pulumi.Input.t<string> => {
+  let identity = SES.EmailIdentity.make(~name, ~args={email: address}, ~opts?)
+  identity.email
+  ->Pulumi.Output.apply(verified => Reventless.Messaging.fromHeader(~displayName, ~address=verified))
+  ->Pulumi.Output.asInput
 }

package/src/capability/Capability_Messaging_Ses.res.mjs

@@ -2,17 +2,16 @@
 
 import * as Aws from "@pulumi/aws";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
 
-function make(name, email, opts) {
+function emailSender(name, address, displayName, opts) {
   let identity = new (Aws.ses.EmailIdentity)(name, {
-    email: email
+    email: address
   }, opts !== undefined ? Primitive_option.valFromOption(opts) : undefined);
-  return {
-    emailSender: identity.email
-  };
+  return identity.email.apply(verified => Messaging$Reventless.fromHeader(displayName, verified));
 }
 
 export {
-  make,
+  emailSender,
 }
 /* @pulumi/aws Not a pure module */