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

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.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.333",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -20,12 +20,12 @@
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.7",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/reventless-core": "3.0.0-alpha.253",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.154",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.34",
     "@reventlessdev/reventless-postgres": "3.0.0-alpha.117",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.34",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.126"
   },
   "devDependencies": {

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

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

@@ -49,12 +49,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) {
@@ -247,6 +282,8 @@ export {
   strOf,
   decodeContext,
   decodeEntry,
+  decodeCompactEntry,
+  parseHandlerConfigWithModules,
   parseHandlerConfig,
   warnMissingBodyModule,
   defaultContext,

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/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -83,6 +83,128 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 })
 
+// The compact form the builder emits: module paths and context ride in the
+// archive registry, and the DCB queue + source urn are hoisted out of every
+// entry that does not override them. Together these are what keep the Lambda's
+// environment under AWS's 4KB ceiling as a plugin gains slices.
+describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
+  let modules =
+    obj([
+      (
+        "Restock",
+        obj([
+          ("specModule", str("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs")),
+          ("bodyModule", str("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs")),
+          ("callbackType", str("automation")),
+          (
+            "context",
+            obj([
+              ("environment", str("alpha")),
+              ("platformName", str("OnlineShop")),
+              ("pluginName", str("Ordering")),
+              ("sliceName", str("Restock")),
+            ]),
+          ),
+        ]),
+      ),
+      (
+        "Ship",
+        obj([
+          ("specModule", str("@x/plugin/src/Order/OutboundTranslationSlice/Ship.res.mjs")),
+          ("bodyModule", str("@x/plugin/src/Order/OutboundTranslationSlice/Ship_Translation.res.mjs")),
+          ("callbackType", str("outbound")),
+        ]),
+      ),
+    ])->JSON.stringify
+
+  let compactConfig = handlers =>
+    obj([
+      ("queueUrl", str("https://sqs/dcb")),
+      ("commandQueueIsFifo", JSON.Encode.bool(false)),
+      ("urns", JSON.Encode.array([str("arn:dcb:log")])),
+      ("handlers", JSON.Encode.array(handlers)),
+    ])->JSON.stringify
+
+  testSync("a compact entry takes its modules from the registry and the shared defaults", () => {
+    let config = compactConfig([obj([("n", str("Restock")), ("q", str("RestockTodo-abc"))])])
+    let e =
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
+        modules,
+        config,
+      )->Array.getUnsafe(0)
+    expect(e.specModule)->toBe("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs")
+    expect(e.bodyModule)->toBe("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs")
+    expect(e.callbackType)->toBe("automation")
+    expect(e.queryDbTableName)->toBe("RestockTodo-abc")
+    expect(e.dcbQueueUrl)->toBe("https://sqs/dcb")
+    expect(e.commandQueueIsFifo)->toEqual(Some(false))
+    expect(e.sourceUrn)->toBe("arn:dcb:log")
+    switch e.context {
+    | Some(ctx) => expect(ctx.sliceName)->toBe("Restock")
+    | None => JsError.throwWithMessage("expected Some(context)")
+    }
+  })
+
+  testSync("per-entry queue and urn override the shared defaults", () => {
+    let config = compactConfig([
+      obj([
+        ("n", str("Ship")),
+        ("q", str("ShipTodo-abc")),
+        ("u", JSON.Encode.array([str("arn:aggregate:orders"), str("arn:dcb:log")])),
+        ("k", str("https://sqs/orders.fifo")),
+        ("f", JSON.Encode.bool(true)),
+      ]),
+    ])
+    let e =
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
+        modules,
+        config,
+      )->Array.getUnsafe(0)
+    expect(e.callbackType)->toBe("outbound")
+    expect(e.dcbQueueUrl)->toBe("https://sqs/orders.fifo")
+    expect(e.commandQueueIsFifo)->toEqual(Some(true))
+    // The first of its own urns, not the shared one.
+    expect(e.sourceUrn)->toBe("arn:aggregate:orders")
+    expect(e.context->Option.isNone)->toBe(true)
+  })
+
+  testSync("a compact entry with no registry match yields no bodyModule to skip on", () => {
+    let config = compactConfig([obj([("n", str("Gone")), ("q", str("GoneTodo-abc"))])])
+    let e =
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
+        modules,
+        config,
+      )->Array.getUnsafe(0)
+    expect(e.specModule)->toBe("")
+    expect(e.bodyModule)->toBe("")
+  })
+
+  testSync("full-key entries still decode when a registry is present", () => {
+    let config = obj([
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("specModule", str("a.res.mjs")),
+            ("bodyModule", str("b.res.mjs")),
+            ("callbackType", str("outbound")),
+            ("queryDbTableName", str("t")),
+            ("dcbQueueUrl", str("u")),
+            ("sourceUrn", str("arn")),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let e =
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
+        modules,
+        config,
+      )->Array.getUnsafe(0)
+    expect(e.specModule)->toBe("a.res.mjs")
+    expect(e.dcbQueueUrl)->toBe("u")
+  })
+})
+
 // Shared stubs — the pipelines only touch phase1/phase2 plus the injected
 // sync/publish, so the callback records carry empty TODO dicts.
 let noopPublish: ReventlessCore.CommandTopic.publishJsons = async _ => ()

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -119,6 +119,193 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
   });
 });
 
+globalThis.describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
+  let modules = JSON.stringify(Object.fromEntries([
+    [
+      "Restock",
+      Object.fromEntries([
+        [
+          "specModule",
+          "@x/plugin/src/Order/AutomationSlice/Restock.res.mjs"
+        ],
+        [
+          "bodyModule",
+          "@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs"
+        ],
+        [
+          "callbackType",
+          "automation"
+        ],
+        [
+          "context",
+          Object.fromEntries([
+            [
+              "environment",
+              "alpha"
+            ],
+            [
+              "platformName",
+              "OnlineShop"
+            ],
+            [
+              "pluginName",
+              "Ordering"
+            ],
+            [
+              "sliceName",
+              "Restock"
+            ]
+          ])
+        ]
+      ])
+    ],
+    [
+      "Ship",
+      Object.fromEntries([
+        [
+          "specModule",
+          "@x/plugin/src/Order/OutboundTranslationSlice/Ship.res.mjs"
+        ],
+        [
+          "bodyModule",
+          "@x/plugin/src/Order/OutboundTranslationSlice/Ship_Translation.res.mjs"
+        ],
+        [
+          "callbackType",
+          "outbound"
+        ]
+      ])
+    ]
+  ]));
+  let compactConfig = handlers => JSON.stringify(Object.fromEntries([
+    [
+      "queueUrl",
+      "https://sqs/dcb"
+    ],
+    [
+      "commandQueueIsFifo",
+      false
+    ],
+    [
+      "urns",
+      ["arn:dcb:log"]
+    ],
+    [
+      "handlers",
+      handlers
+    ]
+  ]));
+  globalThis.test("a compact entry takes its modules from the registry and the shared defaults", () => {
+    let config = compactConfig([Object.fromEntries([
+        [
+          "n",
+          "Restock"
+        ],
+        [
+          "q",
+          "RestockTodo-abc"
+        ]
+      ])]);
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.specModule).toBe("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs");
+    globalThis.expect(e.bodyModule).toBe("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs");
+    globalThis.expect(e.callbackType).toBe("automation");
+    globalThis.expect(e.queryDbTableName).toBe("RestockTodo-abc");
+    globalThis.expect(e.dcbQueueUrl).toBe("https://sqs/dcb");
+    globalThis.expect(e.commandQueueIsFifo).toEqual(false);
+    globalThis.expect(e.sourceUrn).toBe("arn:dcb:log");
+    let ctx = e.context;
+    if (ctx !== undefined) {
+      globalThis.expect(ctx.sliceName).toBe("Restock");
+      return;
+    } else {
+      return Stdlib_JsError.throwWithMessage("expected Some(context)");
+    }
+  });
+  globalThis.test("per-entry queue and urn override the shared defaults", () => {
+    let config = compactConfig([Object.fromEntries([
+        [
+          "n",
+          "Ship"
+        ],
+        [
+          "q",
+          "ShipTodo-abc"
+        ],
+        [
+          "u",
+          [
+            "arn:aggregate:orders",
+            "arn:dcb:log"
+          ]
+        ],
+        [
+          "k",
+          "https://sqs/orders.fifo"
+        ],
+        [
+          "f",
+          true
+        ]
+      ])]);
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.callbackType).toBe("outbound");
+    globalThis.expect(e.dcbQueueUrl).toBe("https://sqs/orders.fifo");
+    globalThis.expect(e.commandQueueIsFifo).toEqual(true);
+    globalThis.expect(e.sourceUrn).toBe("arn:aggregate:orders");
+    globalThis.expect(Stdlib_Option.isNone(e.context)).toBe(true);
+  });
+  globalThis.test("a compact entry with no registry match yields no bodyModule to skip on", () => {
+    let config = compactConfig([Object.fromEntries([
+        [
+          "n",
+          "Gone"
+        ],
+        [
+          "q",
+          "GoneTodo-abc"
+        ]
+      ])]);
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.specModule).toBe("");
+    globalThis.expect(e.bodyModule).toBe("");
+  });
+  globalThis.test("full-key entries still decode when a registry is present", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "a.res.mjs"
+            ],
+            [
+              "bodyModule",
+              "b.res.mjs"
+            ],
+            [
+              "callbackType",
+              "outbound"
+            ],
+            [
+              "queryDbTableName",
+              "t"
+            ],
+            [
+              "dcbQueueUrl",
+              "u"
+            ],
+            [
+              "sourceUrn",
+              "arn"
+            ]
+          ])]
+      ]]));
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.specModule).toBe("a.res.mjs");
+    globalThis.expect(e.dcbQueueUrl).toBe("u");
+  });
+});
+
 async function noopPublish(param) {
   
 }