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

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.334 (2026-09-02)
+
+* feat(aws)!: the messaging sender is configuration, and a stack can choose to only log ([23b8b4b](https://github.com/ReventlessDev/reventless-core/commit/23b8b4bfe9c70555de4d74266ca686cb427485ca))
+
+### BREAKING CHANGES
+
+* `Capability_Messaging_Ses.make` is replaced by
+`Capability_Messaging.make(~name)`, which reads the transport and the address
+from config; the SES module keeps only `emailSender`. A deployment that named its
+sender in code must move it to `platform:messagingEmailSender` or the deploy is
+refused.
+
+
+
+# 3.0.0-alpha.333 (2026-09-02)
+
+### Bug Fixes
+
+* **automation:** the slice registry rides in the archive, not the environment ([d03b42c](https://github.com/ReventlessDev/reventless-core/commit/d03b42cc074181fb6506f00e40205d617bc70ddb))
+
+
 # 3.0.0-alpha.332 (2026-09-01)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.332",
+  "version": "3.0.0-alpha.334",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -15,18 +15,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.14",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.7",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.14",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.7",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.253",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.154",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.254",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.155",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.34",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.117",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.126"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.118",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.127"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -103,6 +103,10 @@ let geocoderPlaceIndexRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make
     same `""` sentinel and the same reason. */
 let messagingEmailSenderRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
 
+/** The email transport behind that address, carried the same way for the same case.
+    `""` means the platform named none, which the runtime reads as its default. */
+let messagingEmailProviderRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
+
 module MakeWithConfig = (
   Config: {
     let splitApi: bool
@@ -2178,16 +2182,57 @@ module MakeWithConfig = (
       Pulumi.Pulumi.export("messagingEmailSender", messagingEmailSenderFlat)
       messagingEmailSenderRef := messagingEmailSenderFlat
 
+      // Which transport is behind that sender. Exported and threaded exactly like
+      // the address, because a plugin stack's Lambdas need both and read them the
+      // same way — the address alone would leave a runtime guessing what to send
+      // it with. `""` means "the platform did not say", which the runtime reads as
+      // the default rather than as an error.
+      let messagingEmailProviderFlat = switch cfg.messagingSender {
+      | Some({emailProvider: ?Some(name)}) => name->Pulumi.Output.fromInput
+      | _ => Pulumi.Output.make("")
+      }
+      Pulumi.Pulumi.export("messagingEmailProvider", messagingEmailProviderFlat)
+      messagingEmailProviderRef := messagingEmailProviderFlat
+
+      // Exported but not handed to a Lambda: nothing reads an SMS sender yet, and
+      // an env var no runtime consults is a setting that looks wired. The export
+      // is how a stack can see what it configured.
+      Pulumi.Pulumi.export(
+        "messagingSmsSender",
+        switch cfg.messagingSender {
+        | Some({smsSender: ?Some(sender)}) => sender->Pulumi.Output.fromInput
+        | _ => Pulumi.Output.make("")
+        },
+      )
+
       // Same gate as geocoding's, and the failure it prevents is worse: an
       // unprovisioned mailer answers `Unavailable` on every send, so the messages
       // queue and retry and are eventually abandoned — a notification nobody
       // receives and no error names.
-      if capabilities->Array.includes(Messaging) && cfg.messagingSender->Option.isNone {
+      //
+      // The test is the *sender*, not the handle. Since the address became
+      // configuration with no default, a root that calls the helper hands over a
+      // record either way — one carrying no sender when the stack named none — so
+      // a gate reading `Option.isNone` would pass a deployment with no mailer.
+      // Whether the field is present is known here, without resolving the Output
+      // behind it, which is what keeps this refusal at graph-construction time
+      // rather than in the `apply` further down: the same gap caught there fails
+      // the deploy midway, and is skipped entirely by `pulumi preview`.
+      let emailSenderProvisioned = switch cfg.messagingSender {
+      | Some({emailSender: ?Some(_)}) => true
+      | _ => false
+      }
+      if capabilities->Array.includes(Messaging) && !emailSenderProvisioned {
         JsError.throwWithMessage(
           `A plugin of this deployment declares the Messaging capability, but this platform ` ++
-          `provisions no sender.\n` ++
-          `  Add \`let sender = ReventlessAws.Capability_Messaging_Ses.make(~name=…, ~email=…)\` ` ++
-          `and pass \`~messagingSender=sender\` in \`~hostUiBundle\`.\n` ++
+          `provisions no email sender.\n` ++
+          `  The sender is configuration and has no default: set ` ++
+          `\`platform:messagingEmailSender\` in Pulumi.<stack>.yaml (or the env var ` ++
+          `REVENTLESS_MESSAGING_EMAIL_SENDER), then verify the address with SES.\n` ++
+          `  A stack that should not mail anybody sets \`platform:messagingEmailProvider: log\` ` ++
+          `instead — every message is logged and none is sent, and the address is optional.\n` ++
+          `  The root must also pass \`~messagingSender\` in \`~hostUiBundle\`, from ` ++
+          `\`ReventlessAws.Capability_Messaging.make(~name=…)\`.\n` ++
           `  The declaration is generated from the plugins' capabilities.json — regenerate with ` ++
           `\`pnpm run generate:platform\` if it is stale.`,
         )
@@ -2516,6 +2561,23 @@ module MakeWithConfig = (
     PluginRuntime_Builder.registerCapabilityEnv("MESSAGING_EMAIL_SENDER", messagingEmailSender)
     PluginRuntime_Builder.registerMessagingSender(messagingEmailSender)
 
+    // The transport, read across the same two halves. Only the env var: the IAM
+    // grant below keys off the address, and a log-transport deployment wants the same
+    // grant anyway — a stack that switches back to SES should not need its roles
+    // rebuilt.
+    let messagingEmailProvider: Pulumi.Output.t<string> = switch platformStackRef {
+    | Some(stackRef) =>
+      (
+        stackRef->Pulumi.StackReference.getOutput("messagingEmailProvider"):
+          Pulumi.Output.t<option<string>>
+      )->Pulumi.Output.apply(o => o->Option.getOr(""))
+    | None => messagingEmailProviderRef.contents
+    }
+    PluginRuntime_Builder.registerCapabilityEnv(
+      "MESSAGING_EMAIL_PROVIDER",
+      messagingEmailProvider,
+    )
+
     module P = unpack(plugin)
     let pluginComponent = P.make()
     ReventlessCore.Plugin_Helpers.clearOffload()
@@ -2698,8 +2760,11 @@ module MakeWithConfig = (
                   `\n  Geocoding is \`Capability_Geocoding_AwsLocation.make\`, passed to the ` ++
                   `platform as \`~geocoderPlaceIndex\`.`
                 | Messaging =>
-                  `\n  Messaging is \`Capability_Messaging_Ses.make\`, passed to the platform ` ++
-                  `as \`~messagingSender\`.`
+                  `\n  Messaging is \`Capability_Messaging.make\`, passed to the platform ` ++
+                  `as \`~messagingSender\`. The sender itself is configuration and has no ` ++
+                  `default: set \`platform:messagingEmailSender\` in Pulumi.<stack>.yaml (or ` ++
+                  `REVENTLESS_MESSAGING_EMAIL_SENDER), then verify the address with SES — or ` ++
+                  `\`platform:messagingEmailProvider: log\` to log every message and send none.`
                 }
               )
               // One line per capability, not per declaring component: two slices

package/src/Platform.res.mjs

@@ -144,6 +144,10 @@ let messagingEmailSenderRef = {
   contents: Pulumi.output("")
 };
 
+let messagingEmailProviderRef = {
+  contents: Pulumi.output("")
+};
+
 function MakeWithConfig(Config) {
   Stdlib_Option.forEach(Config.commandHandlerConfig.aggregates, param => {
     Stdlib_Option.forEach(param.sync, AggregateRuntime_Builder_Single$ReventlessAws.setConfig);
@@ -1168,8 +1172,29 @@ function MakeWithConfig(Config) {
       }
       Pulumi$Pulumi.$$export("messagingEmailSender", messagingEmailSenderFlat);
       messagingEmailSenderRef.contents = messagingEmailSenderFlat;
-      if (capabilities.includes("Messaging") && Stdlib_Option.isNone(hostUiBundle.messagingSender)) {
-        Stdlib_JsError.throwWithMessage(`A plugin of this deployment declares the Messaging capability, but this platform provisions no sender.\n  Add \`let sender = ReventlessAws.Capability_Messaging_Ses.make(~name=…, ~email=…)\` and pass \`~messagingSender=sender\` in \`~hostUiBundle\`.\n  The declaration is generated from the plugins' capabilities.json — regenerate with \`pnpm run generate:platform\` if it is stale.`);
+      let match$6 = hostUiBundle.messagingSender;
+      let messagingEmailProviderFlat;
+      if (match$6 !== undefined) {
+        let name = match$6.emailProvider;
+        messagingEmailProviderFlat = name !== undefined ? name : Pulumi.output("");
+      } else {
+        messagingEmailProviderFlat = Pulumi.output("");
+      }
+      Pulumi$Pulumi.$$export("messagingEmailProvider", messagingEmailProviderFlat);
+      messagingEmailProviderRef.contents = messagingEmailProviderFlat;
+      let match$7 = hostUiBundle.messagingSender;
+      let tmp$2;
+      if (match$7 !== undefined) {
+        let sender$1 = match$7.smsSender;
+        tmp$2 = sender$1 !== undefined ? sender$1 : Pulumi.output("");
+      } else {
+        tmp$2 = Pulumi.output("");
+      }
+      Pulumi$Pulumi.$$export("messagingSmsSender", tmp$2);
+      let match$8 = hostUiBundle.messagingSender;
+      let emailSenderProvisioned = match$8 !== undefined ? match$8.emailSender !== undefined : false;
+      if (capabilities.includes("Messaging") && !emailSenderProvisioned) {
+        Stdlib_JsError.throwWithMessage(`A plugin of this deployment declares the Messaging capability, but this platform provisions no email sender.\n  The sender is configuration and has no default: set \`platform:messagingEmailSender\` in Pulumi.<stack>.yaml (or the env var REVENTLESS_MESSAGING_EMAIL_SENDER), then verify the address with SES.\n  A stack that should not mail anybody sets \`platform:messagingEmailProvider: log\` instead — every message is logged and none is sent, and the address is optional.\n  The root must also pass \`~messagingSender\` in \`~hostUiBundle\`, from \`ReventlessAws.Capability_Messaging.make(~name=…)\`.\n  The declaration is generated from the plugins' capabilities.json — regenerate with \`pnpm run generate:platform\` if it is stale.`);
       }
       let configJsonContent = Pulumi.all([
         Pulumi.all([
@@ -1240,9 +1265,9 @@ function MakeWithConfig(Config) {
           contentType: "application/json"
         });
       }
-      let match$6 = hostUiBundle.bakedManifest;
-      if (componentDefinitions !== undefined && match$6 !== undefined) {
-        let manifestKeys = Platform_BakedManifest$ReventlessCore.files(match$6).map(param => param[0]);
+      let match$9 = hostUiBundle.bakedManifest;
+      if (componentDefinitions !== undefined && match$9 !== undefined) {
+        let manifestKeys = Platform_BakedManifest$ReventlessCore.files(match$9).map(param => param[0]);
         let manifestKey = Stdlib_Option.getOr(manifestKeys[0], Platform_BakedManifest$ReventlessCore.defaultKey);
         Pulumi.all([
           componentDefinitions.roleId,
@@ -1326,6 +1351,8 @@ function MakeWithConfig(Config) {
     let messagingEmailSender = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("messagingEmailSender").apply(o => Stdlib_Option.getOr(o, "")) : messagingEmailSenderRef.contents;
     PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("MESSAGING_EMAIL_SENDER", messagingEmailSender);
     PluginRuntime_Builder$ReventlessAws.registerMessagingSender(messagingEmailSender);
+    let messagingEmailProvider = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("messagingEmailProvider").apply(o => Stdlib_Option.getOr(o, "")) : messagingEmailProviderRef.contents;
+    PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("MESSAGING_EMAIL_PROVIDER", messagingEmailProvider);
     let pluginComponent = plugin.make();
     Plugin_Helpers$ReventlessCore.clearOffload();
     currentDeployTarget.contents = "Domain";
@@ -1398,7 +1425,7 @@ function MakeWithConfig(Config) {
             if (match === "Geocoding") {
               return `\n  Geocoding is \`Capability_Geocoding_AwsLocation.make\`, passed to the platform as \`~geocoderPlaceIndex\`.`;
             } else {
-              return `\n  Messaging is \`Capability_Messaging_Ses.make\`, passed to the platform as \`~messagingSender\`.`;
+              return `\n  Messaging is \`Capability_Messaging.make\`, passed to the platform as \`~messagingSender\`. The sender itself is configuration and has no default: set \`platform:messagingEmailSender\` in Pulumi.<stack>.yaml (or REVENTLESS_MESSAGING_EMAIL_SENDER), then verify the address with SES — or \`platform:messagingEmailProvider: log\` to log every message and send none.`;
             }
           }))).join(""));
         }
@@ -2506,8 +2533,29 @@ function Make($star) {
       }
       Pulumi$Pulumi.$$export("messagingEmailSender", messagingEmailSenderFlat);
       messagingEmailSenderRef.contents = messagingEmailSenderFlat;
-      if (capabilities.includes("Messaging") && Stdlib_Option.isNone(hostUiBundle.messagingSender)) {
-        Stdlib_JsError.throwWithMessage(`A plugin of this deployment declares the Messaging capability, but this platform provisions no sender.\n  Add \`let sender = ReventlessAws.Capability_Messaging_Ses.make(~name=…, ~email=…)\` and pass \`~messagingSender=sender\` in \`~hostUiBundle\`.\n  The declaration is generated from the plugins' capabilities.json — regenerate with \`pnpm run generate:platform\` if it is stale.`);
+      let match$6 = hostUiBundle.messagingSender;
+      let messagingEmailProviderFlat;
+      if (match$6 !== undefined) {
+        let name = match$6.emailProvider;
+        messagingEmailProviderFlat = name !== undefined ? name : Pulumi.output("");
+      } else {
+        messagingEmailProviderFlat = Pulumi.output("");
+      }
+      Pulumi$Pulumi.$$export("messagingEmailProvider", messagingEmailProviderFlat);
+      messagingEmailProviderRef.contents = messagingEmailProviderFlat;
+      let match$7 = hostUiBundle.messagingSender;
+      let tmp$2;
+      if (match$7 !== undefined) {
+        let sender$1 = match$7.smsSender;
+        tmp$2 = sender$1 !== undefined ? sender$1 : Pulumi.output("");
+      } else {
+        tmp$2 = Pulumi.output("");
+      }
+      Pulumi$Pulumi.$$export("messagingSmsSender", tmp$2);
+      let match$8 = hostUiBundle.messagingSender;
+      let emailSenderProvisioned = match$8 !== undefined ? match$8.emailSender !== undefined : false;
+      if (capabilities.includes("Messaging") && !emailSenderProvisioned) {
+        Stdlib_JsError.throwWithMessage(`A plugin of this deployment declares the Messaging capability, but this platform provisions no email sender.\n  The sender is configuration and has no default: set \`platform:messagingEmailSender\` in Pulumi.<stack>.yaml (or the env var REVENTLESS_MESSAGING_EMAIL_SENDER), then verify the address with SES.\n  A stack that should not mail anybody sets \`platform:messagingEmailProvider: log\` instead — every message is logged and none is sent, and the address is optional.\n  The root must also pass \`~messagingSender\` in \`~hostUiBundle\`, from \`ReventlessAws.Capability_Messaging.make(~name=…)\`.\n  The declaration is generated from the plugins' capabilities.json — regenerate with \`pnpm run generate:platform\` if it is stale.`);
       }
       let configJsonContent = Pulumi.all([
         Pulumi.all([
@@ -2578,9 +2626,9 @@ function Make($star) {
           contentType: "application/json"
         });
       }
-      let match$6 = hostUiBundle.bakedManifest;
-      if (componentDefinitions !== undefined && match$6 !== undefined) {
-        let manifestKeys = Platform_BakedManifest$ReventlessCore.files(match$6).map(param => param[0]);
+      let match$9 = hostUiBundle.bakedManifest;
+      if (componentDefinitions !== undefined && match$9 !== undefined) {
+        let manifestKeys = Platform_BakedManifest$ReventlessCore.files(match$9).map(param => param[0]);
         let manifestKey = Stdlib_Option.getOr(manifestKeys[0], Platform_BakedManifest$ReventlessCore.defaultKey);
         Pulumi.all([
           componentDefinitions.roleId,
@@ -2662,6 +2710,8 @@ function Make($star) {
     let messagingEmailSender = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("messagingEmailSender").apply(o => Stdlib_Option.getOr(o, "")) : messagingEmailSenderRef.contents;
     PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("MESSAGING_EMAIL_SENDER", messagingEmailSender);
     PluginRuntime_Builder$ReventlessAws.registerMessagingSender(messagingEmailSender);
+    let messagingEmailProvider = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("messagingEmailProvider").apply(o => Stdlib_Option.getOr(o, "")) : messagingEmailProviderRef.contents;
+    PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("MESSAGING_EMAIL_PROVIDER", messagingEmailProvider);
     let pluginComponent = plugin.make();
     Plugin_Helpers$ReventlessCore.clearOffload();
     currentDeployTarget.contents = "Domain";
@@ -2734,7 +2784,7 @@ function Make($star) {
             if (match === "Geocoding") {
               return `\n  Geocoding is \`Capability_Geocoding_AwsLocation.make\`, passed to the platform as \`~geocoderPlaceIndex\`.`;
             } else {
-              return `\n  Messaging is \`Capability_Messaging_Ses.make\`, passed to the platform as \`~messagingSender\`.`;
+              return `\n  Messaging is \`Capability_Messaging.make\`, passed to the platform as \`~messagingSender\`. The sender itself is configuration and has no default: set \`platform:messagingEmailSender\` in Pulumi.<stack>.yaml (or REVENTLESS_MESSAGING_EMAIL_SENDER), then verify the address with SES — or \`platform:messagingEmailProvider: log\` to log every message and send none.`;
             }
           }))).join(""));
         }
@@ -2855,6 +2905,7 @@ export {
   getObjectStoreEndpoints,
   geocoderPlaceIndexRef,
   messagingEmailSenderRef,
+  messagingEmailProviderRef,
   MakeWithConfig,
   Make,
 }

package/src/adapter/Runtime/AggregateRuntime_Builder_Single.res

@@ -278,9 +278,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="AllAggregatesCmdHandler", ~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/AggregateRuntime_Builder_Single.res.mjs

@@ -14,6 +14,7 @@ import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as PgConnection$ReventlessAws from "../Postgres/PgConnection.res.mjs";
 import * as EventLogBackend$ReventlessAws from "../EventLog/EventLogBackend.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 CommandTopicChannel_SQS_Sync$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
@@ -184,7 +185,11 @@ function finish() {
         ]).apply(param => `{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"` + pluginFragment + param[3] + `}`);
         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("AllAggregatesCmdHandler", json, undefined);
+        return json;
+      });
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
       let tableName = pluginRmTableName.contents;

package/src/adapter/Runtime/AutomationSliceEntryPoint.mjs

@@ -18,9 +18,21 @@ import { Make as outboundTranslationSliceCallbackMake } from "@reventlessdev/rev
 import * as StreamOps from "./StreamRoutedEntryPoint_Ops.res.mjs";
 import * as Ops from "./AutomationSliceEntryPoint_Ops.res.mjs";
 import { runtimeExtensionsReady } from "./HandlerFactoryHelpers.mjs";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
+// Absent whenever the config is full-key (tests, and any pre-split deployment),
+// which is why a missing file is not an error.
+const readSliceModules = () => {
+  try {
+    return readFileSync(join(process.cwd(), "automationSliceModules.json"), "utf-8");
+  } catch {
+    return "";
+  }
+};
+
 async function buildAllHandlers() {
   // Runtime extension seam: any registered out-of-tree extension gets its
   // onColdStart before a single handler is built, which is what makes the
@@ -29,7 +41,15 @@ async function buildAllHandlers() {
   await runtimeExtensionsReady;
   const handlers = {};
   const sweeps = [];
-  const entries = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "");
+  // The slice registry rides in the archive, not the environment — two module
+  // specifiers per slice outgrow Lambda's 4KB env-var ceiling (see the asset in
+  // AutomationSliceRuntime_Builder_Single). A full-key config still wins, so a
+  // caller that supplies one — every test that drives a config directly — needs
+  // no asset on disk. process.cwd() is /var/task, where the archive unpacks.
+  const entries = Ops.parseHandlerConfigWithModules(
+    readSliceModules(),
+    process.env["HANDLER_CONFIG"] || "",
+  );
 
   await Promise.all(entries.map(async (entry) => {
     if (!entry.bodyModule) {

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -62,16 +62,83 @@ let decodeEntry = (json: JSON.t): option<handlerEntry> =>
     context: h->Dict.get("context")->Option.flatMap(decodeContext),
   })
 
-let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
+// A compact entry names its slice and carries only what the deploy resolved;
+// the module paths and context live in the archive registry, keyed by the same
+// name (AutomationSliceRuntime_Builder_Single). Shared `queueUrl` /
+// `commandQueueIsFifo` / `urns` are hoisted out of the per-entry keys, since a
+// slice publishing to the DCB fallback and reading its plugin's log repeats
+// both verbatim — which is what outgrew the 4KB env limit.
+let decodeCompactEntry = (
+  ~modules: dict<JSON.t>,
+  ~sharedQueueUrl: string,
+  ~sharedIsFifo: option<bool>,
+  ~sharedUrns: array<string>,
+  h: dict<JSON.t>,
+  name: string,
+): handlerEntry => {
+  let m = modules->Dict.get(name)->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+  let urns =
+    h
+    ->Dict.get("u")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.map(a => a->Array.filterMap(JSON.Decode.string))
+    ->Option.getOr(sharedUrns)
+  {
+    specModule: m->strOf("specModule")->Option.getOr(""),
+    bodyModule: m->strOf("bodyModule")->Option.getOr(""),
+    callbackType: m->strOf("callbackType")->Option.getOr("automation"),
+    queryDbTableName: h->strOf("q")->Option.getOr(""),
+    dcbQueueUrl: h->strOf("k")->Option.getOr(sharedQueueUrl),
+    commandQueueIsFifo: switch h->Dict.get("f")->Option.flatMap(JSON.Decode.bool) {
+    | Some(f) => Some(f)
+    | None => sharedIsFifo
+    },
+    // Only the first, which is all the shell registers today. The remaining
+    // urns stay in the config for the multi-source registration to use.
+    sourceUrn: urns->Array.get(0)->Option.getOr(""),
+    context: m->Dict.get("context")->Option.flatMap(decodeContext),
+  }
+}
+
+/** `modulesJson` is the archive-side slice registry (`""` when there is none);
+    an entry carrying its own `specModule` is a full-key config and needs it. */
+let parseHandlerConfigWithModules = (modulesJson: string, rawJson: string): array<handlerEntry> =>
   rawJson == ""
     ? []
-    : rawJson
-      ->JSON.parseOrThrow
-      ->JSON.Decode.object
-      ->Option.flatMap(obj => obj->Dict.get("handlers"))
-      ->Option.flatMap(JSON.Decode.array)
-      ->Option.getOr([])
-      ->Array.filterMap(decodeEntry)
+    : {
+        let obj = rawJson->JSON.parseOrThrow->JSON.Decode.object->Option.getOr(Dict.make())
+        let modules =
+          modulesJson == ""
+            ? Dict.make()
+            : modulesJson->JSON.parseOrThrow->JSON.Decode.object->Option.getOr(Dict.make())
+        let sharedQueueUrl = obj->strOf("queueUrl")->Option.getOr("")
+        let sharedIsFifo = obj->Dict.get("commandQueueIsFifo")->Option.flatMap(JSON.Decode.bool)
+        let sharedUrns =
+          obj
+          ->Dict.get("urns")
+          ->Option.flatMap(JSON.Decode.array)
+          ->Option.map(a => a->Array.filterMap(JSON.Decode.string))
+          ->Option.getOr([])
+        obj
+        ->Dict.get("handlers")
+        ->Option.flatMap(JSON.Decode.array)
+        ->Option.getOr([])
+        ->Array.filterMap(item =>
+          switch item->JSON.Decode.object {
+          | None => None
+          | Some(h) =>
+            switch h->strOf("n") {
+            | Some(name) =>
+              Some(decodeCompactEntry(~modules, ~sharedQueueUrl, ~sharedIsFifo, ~sharedUrns, h, name))
+            | None => decodeEntry(item)
+            }
+          }
+        )
+      }
+
+/** The full-key form, for a config that carries its own module paths. */
+let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
+  parseHandlerConfigWithModules("", rawJson)
 
 // A pre-`bodyModule` config entry cannot rebuild the callback (the spec module
 // alone lacks the mappings/process). Warn and skip rather than crash the whole
@@ -230,15 +297,30 @@ outcome, not a verdict on the address. `MESSAGING_EMAIL_SENDER` is read the same
 way, and empty yields a provider with no channels rather than one that claims a
 channel it cannot send on.
 */
+/** The email transport this deployment chose.
+
+    Read per call like the sender beside it, and defaulting to SES on anything it
+    does not recognise — including the empty string a platform that named nothing
+    exports. The deploy already refuses an unknown value (`Capability_Messaging`
+    parses it there, where a human is watching); defaulting again here is for the
+    case that cannot be refused, a Lambda whose variable was edited by hand. SES
+    is the safe direction: a message that should have been logged and was sent is
+    recoverable, a customer notification silently swallowed by a log line is not. */
+let messagingEmailProvider = (): Reventless.Messaging.provider => {
+  let sender = NodeProcess.env->Dict.get("MESSAGING_EMAIL_SENDER")->Option.getOr("")
+  switch NodeProcess.env->Dict.get("MESSAGING_EMAIL_PROVIDER")->Option.getOr("") {
+  | "log" => ReventlessCore.Messaging_Log_Backend.provider(~sender)
+  | _ => Messaging_Ses_Backend.provider(~sender)
+  }
+}
+
 let capabilities = (): Reventless.Capabilities.t => {
   geocode: (~text) =>
     Geocoder_AwsLocation_Backend.search(
       ~indexName=NodeProcess.env->Dict.get("PLACE_INDEX_NAME")->Option.getOr(""),
       ~text,
     ),
-  messaging: Messaging_Ses_Backend.provider(
-    ~sender=NodeProcess.env->Dict.get("MESSAGING_EMAIL_SENDER")->Option.getOr(""),
-  ),
+  messaging: messagingEmailProvider(),
 }
 
 // ── Phase-1/phase-2 pipelines ───────────────────────────────────────────────

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

@@ -16,6 +16,7 @@ import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src
 import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.mjs";
 import * as Messaging_Ses_Backend$ReventlessAws from "../Messaging/Messaging_Ses_Backend.res.mjs";
 import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
+import * as Messaging_Log_Backend$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Messaging/Messaging_Log_Backend.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
 import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
 import * as Geocoder_AwsLocation_Backend$ReventlessAws from "../Geocoder/Geocoder_AwsLocation_Backend.res.mjs";
@@ -49,12 +50,47 @@ function decodeEntry(json) {
   }));
 }
 
-function parseHandlerConfig(rawJson) {
+function decodeCompactEntry(modules, sharedQueueUrl, sharedIsFifo, sharedUrns, h, name) {
+  let m = Stdlib_Option.getOr(Stdlib_Option.flatMap(modules[name], Stdlib_JSON.Decode.object), {});
+  let urns = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(h["u"], Stdlib_JSON.Decode.array), a => Stdlib_Array.filterMap(a, Stdlib_JSON.Decode.string)), sharedUrns);
+  let f = Stdlib_Option.flatMap(h["f"], Stdlib_JSON.Decode.bool);
+  return {
+    specModule: Stdlib_Option.getOr(strOf(m, "specModule"), ""),
+    bodyModule: Stdlib_Option.getOr(strOf(m, "bodyModule"), ""),
+    callbackType: Stdlib_Option.getOr(strOf(m, "callbackType"), "automation"),
+    queryDbTableName: Stdlib_Option.getOr(strOf(h, "q"), ""),
+    dcbQueueUrl: Stdlib_Option.getOr(strOf(h, "k"), sharedQueueUrl),
+    commandQueueIsFifo: f !== undefined ? f : sharedIsFifo,
+    sourceUrn: Stdlib_Option.getOr(urns[0], ""),
+    context: Stdlib_Option.flatMap(m["context"], decodeContext)
+  };
+}
+
+function parseHandlerConfigWithModules(modulesJson, rawJson) {
   if (rawJson === "") {
     return [];
-  } else {
-    return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(rawJson)), obj => obj["handlers"]), Stdlib_JSON.Decode.array), []), decodeEntry);
   }
+  let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(rawJson)), {});
+  let modules = modulesJson === "" ? ({}) : Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(modulesJson)), {});
+  let sharedQueueUrl = Stdlib_Option.getOr(strOf(obj, "queueUrl"), "");
+  let sharedIsFifo = Stdlib_Option.flatMap(obj["commandQueueIsFifo"], Stdlib_JSON.Decode.bool);
+  let sharedUrns = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(obj["urns"], Stdlib_JSON.Decode.array), a => Stdlib_Array.filterMap(a, Stdlib_JSON.Decode.string)), []);
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["handlers"], Stdlib_JSON.Decode.array), []), item => {
+    let h = Stdlib_JSON.Decode.object(item);
+    if (h === undefined) {
+      return;
+    }
+    let name = strOf(h, "n");
+    if (name !== undefined) {
+      return decodeCompactEntry(modules, sharedQueueUrl, sharedIsFifo, sharedUrns, h, name);
+    } else {
+      return decodeEntry(item);
+    }
+  });
+}
+
+function parseHandlerConfig(rawJson) {
+  return parseHandlerConfigWithModules("", rawJson);
 }
 
 function warnMissingBodyModule(entry) {
@@ -150,10 +186,20 @@ function makeLoadTodoItems(queryDbTableName, todoItems, rowSchema, comp) {
   };
 }
 
+function messagingEmailProvider() {
+  let sender = Stdlib_Option.getOr(process.env["MESSAGING_EMAIL_SENDER"], "");
+  let match = Stdlib_Option.getOr(process.env["MESSAGING_EMAIL_PROVIDER"], "");
+  if (match === "log") {
+    return Messaging_Log_Backend$ReventlessCore.provider(sender);
+  } else {
+    return Messaging_Ses_Backend$ReventlessAws.provider(sender);
+  }
+}
+
 function capabilities() {
   return {
     geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined),
-    messaging: Messaging_Ses_Backend$ReventlessAws.provider(Stdlib_Option.getOr(process.env["MESSAGING_EMAIL_SENDER"], ""))
+    messaging: messagingEmailProvider()
   };
 }
 
@@ -247,12 +293,15 @@ export {
   strOf,
   decodeContext,
   decodeEntry,
+  decodeCompactEntry,
+  parseHandlerConfigWithModules,
   parseHandlerConfig,
   warnMissingBodyModule,
   defaultContext,
   makePublishJsons,
   makeSyncTodoItems,
   makeLoadTodoItems,
+  messagingEmailProvider,
   capabilities,
   makeAutomationJsonEventsHandler,
   makeOutboundJsonEventsHandler,