@reventlessdev/reventless-aws 3.0.0-alpha.303 → 3.0.0-alpha.305

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.305 (2026-08-16)
+
+### Bug Fixes
+
+* **aws:** move the EventCollector's queue-URL maps out of the environment ([31172cb](https://github.com/ReventlessDev/reventless-core/commit/31172cb793d267729f201794ff785f9f982315fa))
+
+
+# 3.0.0-alpha.304 (2026-08-16)
+
+### Bug Fixes
+
+* **aws:** ship the DCB slice registry in the archive, not the environment ([3cda4cb](https://github.com/ReventlessDev/reventless-core/commit/3cda4cb780848598a436ab8e80843cf15a4d22b6))
+
+
 # 3.0.0-alpha.303 (2026-08-16)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.303",
+  "version": "3.0.0-alpha.305",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -17,11 +17,11 @@
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.7",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.77",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-core": "3.0.0-alpha.237",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.143",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.31",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/reventless-postgres": "3.0.0-alpha.101",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.115"
   },

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -3,6 +3,8 @@
 // builds shared DcbEventLog operations and per-slice handlers keyed by command type name.
 // Dual routing: AppSync direct invocation and SQS CommandTopic events.
 
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -245,6 +247,16 @@ async function buildHandler() {
   // Lambda always sets HANDLER_CONFIG; the production path is unchanged.
   if (!configStr) return [null, null, undefined, undefined];
   const config = JSON.parse(configStr);
+  // 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
+  // StateChangeSliceRuntime_Builder_Single). An inline registry 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.
+  if (config.stateChangeSliceModules === undefined) {
+    config.stateChangeSliceModules = JSON.parse(
+      readFileSync(join(process.cwd(), "sliceModules.json"), "utf-8"),
+    );
+  }
   return buildHandlersForConfig(config, { loadModule: dynamicImport });
 }
 

package/src/adapter/Runtime/EventCollectorEntryPoint.mjs

@@ -46,12 +46,9 @@
 //       "readModelNames":     string[]         // RMs this extension may enqueue events into (filter into readModelQueueUrls)
 //     }
 //   ],
-//   "publishToAggregates": {                   // aggregateName → env-var name holding the aggregate's cmd-topic SQS URL
-//     "Plugin": "PTA_Plugin_QUEUE_URL"
-//   },
-//   "readModelQueueUrls": {                    // rmName → env-var name holding the RM's EventCollector SQS URL
-//     "ProductDemands": "PRM_ProductDemands_QUEUE_URL"
-//   },
+//   (publishToAggregates / readModelQueueUrls moved to the queueUrls.json asset —
+//    one entry per target, so they outgrew the 4KB environment. Each still maps a
+//    target name to the PTA_/PRM_ env var holding its SQS URL.)
 //   "readModelNamesForSourceName": {           // deploy-side inversion of RM.sourceNames; sourceServiceName → [rmName]
 //     "Ordering.Orders": ["ProductDemands"]
 //   }
@@ -100,6 +97,8 @@ async function buildHandler() {
   await runtimeExtensionsReady;
   const config = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "");
   const pluginDefinition = Ops.loadPluginDefinition();
+  // target → env-var name; the URLs themselves stay in the environment.
+  const queueUrlNames = Ops.loadQueueUrlNames();
 
   const queryEngine = Ops.makeQueryEngine(config.pluginReadModelTableName);
   const scheduler = Ops.makeScheduler(config.schedulerRoleArn);
@@ -165,7 +164,7 @@ async function buildHandler() {
     return { aggregateNames: ep.aggregateNames, outgoingHandler: ops.outgoingJsonEventsHandler };
   }));
 
-  const publishToAggregates = Ops.buildPublishToAggregates(config.publishToAggregates);
+  const publishToAggregates = Ops.buildPublishToAggregates(queueUrlNames.publishToAggregates);
   const publishToPluginExtensionPoint = Ops.makePublishJsons(config.pluginExtensionPointCmdTopicUrl);
 
   // Connect extension — exactly one entry per plugin Lambda; null for admin.
@@ -230,7 +229,7 @@ async function buildHandler() {
       mappings: [transformedMapping],
     };
 
-    const dicts = Ops.extensionPublishDicts(config, ext);
+    const dicts = Ops.extensionPublishDicts(config, queueUrlNames, ext);
     const ops = extensionOperationsMake(epSpec)(mappingsModule)({
       publishToAggregates: dicts.publishToAggregates,
       publishToPluginExtensionPoint,

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res

@@ -109,9 +109,16 @@ type handlerConfig = {
   extensionPoints: array<extensionPointConfig>,
   connectExtension: option<connectExtensionConfig>,
   extensions: array<extensionConfig>,
+  readModelNamesForSourceName: dict<array<string>>,
+}
+
+// The target→env-var maps that used to ride HANDLER_CONFIG, now read from
+// queueUrls.json (PluginRuntime_Builder). Values are env var NAMES, not URLs —
+// the URLs stay in the environment because the builder cannot resolve those
+// Outputs in bulk.
+type queueUrlNames = {
   publishToAggregates: dict<string>,
   readModelQueueUrls: dict<string>,
-  readModelNamesForSourceName: dict<array<string>>,
 }
 
 let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
@@ -149,7 +156,6 @@ let parseHandlerConfig = (rawJson: string): handlerConfig => {
     "schedulerQueueName",
     "extensionPoints",
     "extensions",
-    "publishToAggregates",
   ]->Array.forEach(k =>
     if obj->Dict.get(k)->Option.isNone {
       JsError.throwWithMessage("HANDLER_CONFIG missing required field: " ++ k)
@@ -225,8 +231,6 @@ let parseHandlerConfig = (rawJson: string): handlerConfig => {
     extensionPoints,
     connectExtension,
     extensions,
-    publishToAggregates: obj->strDictOf("publishToAggregates"),
-    readModelQueueUrls: obj->strDictOf("readModelQueueUrls"),
     readModelNamesForSourceName,
   }
 }
@@ -625,7 +629,11 @@ type extensionDicts = {
   readModelNamesForSourceName: dict<array<string>>,
 }
 
-let extensionPublishDicts = (config: handlerConfig, ext: extensionConfig): extensionDicts => {
+let extensionPublishDicts = (
+  config: handlerConfig,
+  names: queueUrlNames,
+  ext: extensionConfig,
+): extensionDicts => {
   let resolve = (names: array<string>, envVarNames: dict<string>) =>
     names
     ->Array.filterMap(name =>
@@ -637,8 +645,8 @@ let extensionPublishDicts = (config: handlerConfig, ext: extensionConfig): exten
     )
     ->Dict.fromArray
   {
-    publishToAggregates: resolve(ext.aggregateNames, config.publishToAggregates),
-    publishToReadModels: resolve(ext.readModelNames, config.readModelQueueUrls),
+    publishToAggregates: resolve(ext.aggregateNames, names.publishToAggregates),
+    publishToReadModels: resolve(ext.readModelNames, names.readModelQueueUrls),
     // Scoped to this extension's EP — Extension_Operations uses this dict to
     // decide which RMs receive each incoming event.
     readModelNamesForSourceName: Dict.fromArray([
@@ -680,6 +688,26 @@ let loadPluginDefinition = (): Reventless.Plugin.pluginDefinition =>
     )
   }
 
+// The target→env-var maps, read once at cold start. A plugin that publishes
+// nowhere writes empty maps rather than omitting the file, so a read failure is
+// a genuinely broken archive and not an empty-map case worth guessing at.
+let loadQueueUrlNames = (): queueUrlNames =>
+  try {
+    let obj =
+      assetPath("queueUrls.json")
+      ->NodeFs.readFileSync
+      ->JSON.parseOrThrow
+      ->JSON.Decode.object
+      ->Option.getOr(Dict.make())
+    {
+      publishToAggregates: obj->strDictOf("publishToAggregates"),
+      readModelQueueUrls: obj->strDictOf("readModelQueueUrls"),
+    }
+  } catch {
+  | exn =>
+    JsError.throwWithMessage("Failed to load queueUrls.json from asset zip: " ++ exnMessage(exn))
+  }
+
 // The plugin's UI-fragment manifest — its own asset since the manifest no
 // longer rides pluginDefinition (the UiFragmentRegistry slice owns fragment
 // state). JSON null (plugins without a UI) and a missing file (older archives)

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

@@ -111,8 +111,7 @@ function parseHandlerConfig(rawJson) {
     "schedulerQueueArn",
     "schedulerQueueName",
     "extensionPoints",
-    "extensions",
-    "publishToAggregates"
+    "extensions"
   ].forEach(k => {
     if (Stdlib_Option.isNone(obj[k])) {
       return Stdlib_JsError.throwWithMessage("HANDLER_CONFIG missing required field: " + k);
@@ -159,8 +158,6 @@ function parseHandlerConfig(rawJson) {
     extensionPoints: extensionPoints,
     connectExtension: connectExtension,
     extensions: extensions,
-    publishToAggregates: strDictOf(obj, "publishToAggregates"),
-    readModelQueueUrls: strDictOf(obj, "readModelQueueUrls"),
     readModelNamesForSourceName: readModelNamesForSourceName
   };
 }
@@ -495,14 +492,14 @@ function buildPublishToAggregates(map) {
   ]));
 }
 
-function extensionPublishDicts(config, ext) {
+function extensionPublishDicts(config, names, ext) {
   let resolve = (names, envVarNames) => Object.fromEntries(Stdlib_Array.filterMap(names, name => Stdlib_Option.map(Stdlib_Option.filter(Stdlib_Option.flatMap(envVarNames[name], envVarName => process.env[envVarName]), queueUrl => queueUrl !== ""), queueUrl => [
     name,
     makePublishJsons(queueUrl)
   ])));
   return {
-    publishToAggregates: resolve(ext.aggregateNames, config.publishToAggregates),
-    publishToReadModels: resolve(ext.readModelNames, config.readModelQueueUrls),
+    publishToAggregates: resolve(ext.aggregateNames, names.publishToAggregates),
+    publishToReadModels: resolve(ext.readModelNames, names.readModelQueueUrls),
     readModelNamesForSourceName: Object.fromEntries([[
         ext.extensionPointName,
         Stdlib_Option.getOr(config.readModelNamesForSourceName[ext.extensionPointName], [])
@@ -529,6 +526,19 @@ function loadPluginDefinition() {
   }
 }
 
+function loadQueueUrlNames() {
+  try {
+    let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(assetPath("queueUrls.json"), "utf8"))), {});
+    return {
+      publishToAggregates: strDictOf(obj, "publishToAggregates"),
+      readModelQueueUrls: strDictOf(obj, "readModelQueueUrls")
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Stdlib_JsError.throwWithMessage("Failed to load queueUrls.json from asset zip: " + exnMessage(exn));
+  }
+}
+
 function loadUiFragments() {
   try {
     let json = JSON.parse(Nodefs.readFileSync(assetPath("uiFragments.json"), "utf8"));
@@ -649,6 +659,7 @@ export {
   warnSkippedExtension,
   assetPath,
   loadPluginDefinition,
+  loadQueueUrlNames,
   loadUiFragments,
   pushHandler,
   makeSqsHandlerBundle,

package/src/adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res

@@ -113,9 +113,16 @@ let forDcbCommandTopic = (
       envVars->Dict.set("LOG_LEVEL", level->Pulumi.Output.make->Pulumi.Output.asInput)
     )
 
-    // Build HANDLER_CONFIG JSON: array of {spec, behavior} objects so the entry point
+    // The slice registry: an array of {spec, behavior} objects so the entry point
     // can dynamically import both modules and apply the curried StateChangeSlice_Callback.Make
     // functor (Make(Spec)(Behavior)).
+    //
+    // Shipped as a `sliceModules.json` asset rather than inline in HANDLER_CONFIG.
+    // Two absolute module specifiers per slice is the one term here that grows
+    // with the plugin, and a plugin with a dozen-odd slices carries enough of
+    // them to pass Lambda's 4KB UpdateFunctionConfiguration ceiling on the whole
+    // environment — the same wall `pluginDefinition` hit in PluginRuntime_Builder,
+    // and it fails at deploy with the registry already committed to the stack.
     let sliceModulesJson =
       slicePaths
       ->Array.map(((specPath, behaviorPath)) => {
@@ -172,7 +179,9 @@ let forDcbCommandTopic = (
       Pulumi.Output.all4((dcbTableName, queue.id, pgConnectionFragment, inboundFragment))
       ->Pulumi.Output.apply(((table, queueUrl, pgFragment, inbFragment)) => {
         let pluginNameJson = pluginName->JSON.stringifyAny->Option.getOr(`""`)
-        `{"dcbEventLogTableName":"${table}","queueUrl":"${queueUrl}","pluginName":${pluginNameJson},"stateChangeSliceModules":[${sliceModulesJson}]${pgFragment}${inbFragment}}`
+        let json = `{"dcbEventLogTableName":"${table}","queueUrl":"${queueUrl}","pluginName":${pluginNameJson}${pgFragment}${inbFragment}}`
+        Util_LambdaEnvBudget.check(~lambdaName=name, ~handlerConfigJson=json)
+        json
       })
     envVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
 
@@ -205,9 +214,16 @@ let forDcbCommandTopic = (
       Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-core"),
     )
 
+    // Carries no Pulumi Output, so the archive is still built synchronously —
+    // the audit table names that do are in the inbound fragment, which stays in
+    // HANDLER_CONFIG.
+    let extraStringAssets = Dict.make()
+    extraStringAssets->Dict.set("sliceModules.json", `[${sliceModulesJson}]`)
+
     let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
       ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs",
       ~packageDirs,
+      ~extraStringAssets,
     )
 
     cfg.sqsBatchSize->Option.forEach(CommandTopicChannel.SQS.setBatchSize)

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

@@ -11,6 +11,7 @@ import * as DcbBackend$ReventlessAws from "../DcbEventLog/DcbBackend.res.mjs";
 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 PgConnection$ReventlessAws from "../Postgres/PgConnection.res.mjs";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../../util/Util_LambdaEnvBudget.res.mjs";
 import * as CommandTopicChannel_SQS$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 
@@ -79,7 +80,9 @@ function forDcbCommandTopic(slicePaths, inboundSlicesOpt, dcbTableName, pluginNa
     inboundFragment
   ]).apply(param => {
     let pluginNameJson = Stdlib_Option.getOr(JSON.stringify(pluginName), `""`);
-    return `{"dcbEventLogTableName":"` + param[0] + `","queueUrl":"` + param[1] + `","pluginName":` + pluginNameJson + `,"stateChangeSliceModules":[` + sliceModulesJson + `]` + param[2] + param[3] + `}`;
+    let json = `{"dcbEventLogTableName":"` + param[0] + `","queueUrl":"` + param[1] + `","pluginName":` + pluginNameJson + param[2] + param[3] + `}`;
+    Util_LambdaEnvBudget$ReventlessAws.check(name, json, undefined);
+    return json;
   });
   envVars["HANDLER_CONFIG"] = handlerConfigJson;
   let packageDirs = {};
@@ -97,7 +100,9 @@ function forDcbCommandTopic(slicePaths, inboundSlicesOpt, dcbTableName, pluginNa
   });
   packageDirs["@reventlessdev/reventless-aws"] = Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, "@reventlessdev/reventless-aws");
   packageDirs["@reventlessdev/reventless-core"] = Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, "@reventlessdev/reventless-core");
-  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs", packageDirs, undefined, undefined);
+  let extraStringAssets = {};
+  extraStringAssets["sliceModules.json"] = `[` + sliceModulesJson + `]`;
+  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs", packageDirs, extraStringAssets, undefined);
   Stdlib_Option.forEach(cfg.sqsBatchSize, CommandTopicChannel_SQS$ReventlessAws.setBatchSize);
   let vpcConfig = pgSelection !== undefined ? pgSelection.securityGroupId.apply(sgId => ({
       subnetIds: pgSelection.subnetIds,

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -503,27 +503,13 @@ module Make = (
           })
         dict->Dict.set("extensions", JSON.Encode.array(extensionsArr))
 
-        let publishToAggregatesDict = Dict.make()
-        context.publishToAggregates
-        ->Dict.keysToArray
-        ->Array.forEach(aggName =>
-          publishToAggregatesDict->Dict.set(
-            aggName,
-            JSON.Encode.string(`PTA_${aggName}_QUEUE_URL`),
-          )
-        )
-        dict->Dict.set("publishToAggregates", JSON.Encode.object(publishToAggregatesDict))
-
-        let readModelQueueUrlsDict = Dict.make()
-        context.readModelQueueUrls
-        ->Dict.keysToArray
-        ->Array.forEach(rmName =>
-          readModelQueueUrlsDict->Dict.set(
-            rmName,
-            JSON.Encode.string(`PRM_${rmName}_QUEUE_URL`),
-          )
-        )
-        dict->Dict.set("readModelQueueUrls", JSON.Encode.object(readModelQueueUrlsDict))
+        // publishToAggregates / readModelQueueUrls live in queueUrls.json (see the
+        // asset bundle below). Both are one entry per target, so they grow with the
+        // plugin, and together with the PTA_/PRM_ vars they name they carried the
+        // catalog EventCollector past Lambda's 4KB environment ceiling. Only the
+        // maps move: they are built from Dict.keysToArray, so they hold no Pulumi
+        // Output and can be serialized here. The URLs themselves cannot follow —
+        // see the note on the aggregate walk further down.
 
         let rmNamesForSourceDict = Dict.make()
         context.readModelNamesForSourceName
@@ -536,7 +522,22 @@ module Make = (
         )
         dict->Dict.set("readModelNamesForSourceName", JSON.Encode.object(rmNamesForSourceDict))
 
-        JSON.Encode.object(dict)->JSON.stringify
+        let json = JSON.Encode.object(dict)->JSON.stringify
+        // The PTA_/PRM_ vars are the rest of this Lambda's environment and the
+        // half that grows with the plugin. Their names are known here; their
+        // values are still Outputs, so the budget check estimates those.
+        let queueUrlKeys = Array.concat(
+          context.publishToAggregates
+          ->Dict.keysToArray
+          ->Array.map(n => `PTA_${n}_QUEUE_URL`),
+          context.readModelQueueUrls->Dict.keysToArray->Array.map(n => `PRM_${n}_QUEUE_URL`),
+        )
+        Util_LambdaEnvBudget.check(
+          ~lambdaName=name,
+          ~handlerConfigJson=json,
+          ~outputValuedKeys=queueUrlKeys,
+        )
+        json
       })
     envVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
 
@@ -599,6 +600,29 @@ module Make = (
       ->Pulumi.Output.apply(((pluginDefinitionJson, uiFragmentsJson)) => {
         let extraStringAssets = Dict.make()
         extraStringAssets->Dict.set("pluginDefinition.json", pluginDefinitionJson)
+        // target name → the env var holding that target's queue URL. The
+        // indirection stays (the URLs are Outputs this builder must not resolve
+        // in bulk); only the naming map moves out of HANDLER_CONFIG.
+        let nameMap = (names: array<string>, prefix: string) => {
+          let d = Dict.make()
+          names
+          ->Array.toSorted(String.compare)
+          ->Array.forEach(n => d->Dict.set(n, JSON.Encode.string(`${prefix}_${n}_QUEUE_URL`)))
+          JSON.Encode.object(d)
+        }
+        let queueUrlsDict = Dict.make()
+        queueUrlsDict->Dict.set(
+          "publishToAggregates",
+          nameMap(context.publishToAggregates->Dict.keysToArray, "PTA"),
+        )
+        queueUrlsDict->Dict.set(
+          "readModelQueueUrls",
+          nameMap(context.readModelQueueUrls->Dict.keysToArray, "PRM"),
+        )
+        extraStringAssets->Dict.set(
+          "queueUrls.json",
+          JSON.Encode.object(queueUrlsDict)->JSON.stringify,
+        )
         // The UI-fragment manifest no longer rides pluginDefinition — ship it as
         // its own asset ("null" for plugins without a UI) so the bundled Connect
         // extension can emit RegisterUiFragment in the handshake answer.

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

@@ -16,6 +16,7 @@ import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/sr
 import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.res.mjs";
 import * as EventLogBackend$ReventlessAws from "../../adapter/EventLog/EventLogBackend.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../../util/Util_LambdaEnvBudget.res.mjs";
 import * as Platform_Admin_Structure$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin_Structure.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "../../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
 import * as StateChangeSliceRuntime_Builder_Single$ReventlessAws from "../../adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res.mjs";
@@ -323,22 +324,15 @@ function Make(EventCollectorChannel) {
         return entryDict;
       });
       dict["extensions"] = extensionsArr;
-      let publishToAggregatesDict = {};
-      Object.keys(context.publishToAggregates).forEach(aggName => {
-        publishToAggregatesDict[aggName] = `PTA_` + aggName + `_QUEUE_URL`;
-      });
-      dict["publishToAggregates"] = publishToAggregatesDict;
-      let readModelQueueUrlsDict = {};
-      Object.keys(context.readModelQueueUrls).forEach(rmName => {
-        readModelQueueUrlsDict[rmName] = `PRM_` + rmName + `_QUEUE_URL`;
-      });
-      dict["readModelQueueUrls"] = readModelQueueUrlsDict;
       let rmNamesForSourceDict = {};
       Object.entries(context.readModelNamesForSourceName).forEach(param => {
         rmNamesForSourceDict[param[0]] = param[1].map(prim => prim);
       });
       dict["readModelNamesForSourceName"] = rmNamesForSourceDict;
-      return JSON.stringify(dict);
+      let json = JSON.stringify(dict);
+      let queueUrlKeys = Object.keys(context.publishToAggregates).map(n => `PTA_` + n + `_QUEUE_URL`).concat(Object.keys(context.readModelQueueUrls).map(n => `PRM_` + n + `_QUEUE_URL`));
+      Util_LambdaEnvBudget$ReventlessAws.check(name, json, queueUrlKeys);
+      return json;
     });
     envVars["HANDLER_CONFIG"] = handlerConfigJson;
     let packageDirs = {};
@@ -374,6 +368,17 @@ function Make(EventCollectorChannel) {
     ]).apply(param => {
       let extraStringAssets = {};
       extraStringAssets["pluginDefinition.json"] = param[0];
+      let nameMap = (names, prefix) => {
+        let d = {};
+        names.toSorted(Primitive_string.compare).forEach(n => {
+          d[n] = prefix + `_` + n + `_QUEUE_URL`;
+        });
+        return d;
+      };
+      let queueUrlsDict = {};
+      queueUrlsDict["publishToAggregates"] = nameMap(Object.keys(context.publishToAggregates), "PTA");
+      queueUrlsDict["readModelQueueUrls"] = nameMap(Object.keys(context.readModelQueueUrls), "PRM");
+      extraStringAssets["queueUrls.json"] = JSON.stringify(queueUrlsDict);
       extraStringAssets["uiFragments.json"] = param[1];
       return Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/EventCollectorEntryPoint.mjs", packageDirs, extraStringAssets, undefined);
     });

package/src/util/Util_LambdaEnvBudget.res

@@ -0,0 +1,74 @@
+// Deploy-time check on a Lambda's environment size.
+//
+// AWS caps the whole environment of a function at 4096 bytes and rejects the
+// UpdateFunctionConfiguration call that exceeds it. That rejection lands in the
+// middle of a `pulumi up`, after the surrounding resources have already moved,
+// so the stack is left half-updated and the message names a byte count rather
+// than the field that grew. This has now bitten three times: `pluginDefinition`
+// inline in HANDLER_CONFIG, the DCB slice registry, and the EventCollector's
+// publishToAggregates map plus the PTA_ vars it names.
+//
+// The check runs where HANDLER_CONFIG is still a plain string — inside the
+// builders' `Pulumi.Output.apply` — because that is the last point anything is
+// measurable. By the time the env reaches `RuntimeEnvironment_Lambda`, the big
+// values are Outputs, and totalling them there would mean a bulk resolve of the
+// very dict `PluginRuntime_Builder` documents as unsafe to resolve in bulk.
+//
+// So the total is part exact, part estimated:
+//   * exact    — the fixed framework vars, HANDLER_CONFIG, and every env var NAME
+//   * estimated — one allowance per Output-valued env var, since the value (an SQS
+//                 URL) is not resolved yet
+//
+// Exceeding the limit on the exact part alone is a certainty, and fails the
+// deploy. Exceeding it only once the allowances are added is a likelihood, and
+// warns: a wrong estimate must not block a deploy that would have succeeded.
+
+let limit = 4096
+
+// Environment, NODE_OPTIONS, ESM_FALLBACK_DIRS, LOG_LEVEL,
+// REVENTLESS_ELEVATED_GROUPS — set for every Lambda by RuntimeEnvironment_Lambda.
+let frameworkVarsBytes = 191
+
+// An SQS queue URL: https://sqs.<region>.amazonaws.com/<account>/<name>[.fifo].
+// Rounded up from the longest in the example platforms, so the estimate errs
+// toward warning early rather than reporting a limit breach as headroom.
+let outputValueAllowance = 100
+
+let log = ReventlessCore.Logger.fromEnv()
+
+/**
+ * Check one Lambda's environment against the 4KB limit.
+ *
+ * `~outputValuedKeys` are env vars whose value is still an unresolved Output —
+ * counted by name plus `outputValueAllowance`. Raises when the exact portion
+ * alone is over the limit; warns when only the estimate is.
+ */
+let check = (
+  ~lambdaName: string,
+  ~handlerConfigJson: string,
+  ~outputValuedKeys: array<string>=[],
+) => {
+  let handlerConfigBytes = String.length("HANDLER_CONFIG") + String.length(handlerConfigJson)
+  let keyBytes = outputValuedKeys->Array.reduce(0, (acc, k) => acc + String.length(k))
+  let exact = frameworkVarsBytes + handlerConfigBytes + keyBytes
+  let estimated = exact + outputValuedKeys->Array.length * outputValueAllowance
+
+  if exact > limit {
+    JsError.throwWithMessage(
+      `${lambdaName}: Lambda environment is ${exact->Int.toString} bytes before the ` ++
+      `${outputValuedKeys->Array.length->Int.toString} queue-URL vars are resolved, over the ` ++
+      `${limit->Int.toString}-byte limit. HANDLER_CONFIG is ${handlerConfigBytes->Int.toString} ` ++
+      `bytes of it — move the term that grows with the plugin into a code-archive asset ` ++
+      `(Util_Bundle.buildCodeArchive ~extraStringAssets), as pluginDefinition.json and ` ++
+      `sliceModules.json already are.`,
+    )
+  } else if estimated > limit {
+    log.warn(
+      ~comp="Util_LambdaEnvBudget",
+      `${lambdaName}: Lambda environment is about ${estimated->Int.toString} bytes ` ++
+      `(${exact->Int.toString} exact + ${outputValuedKeys->Array.length->Int.toString} queue-URL ` ++
+      `vars), at or over the ${limit->Int.toString}-byte limit. The deploy may fail on ` ++
+      `UpdateFunctionConfiguration; move a plugin-sized term out of HANDLER_CONFIG.`,
+    )
+  }
+}

package/src/util/Util_LambdaEnvBudget.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function check(lambdaName, handlerConfigJson, outputValuedKeysOpt) {
+  let outputValuedKeys = outputValuedKeysOpt !== undefined ? outputValuedKeysOpt : [];
+  let handlerConfigBytes = "HANDLER_CONFIG".length + handlerConfigJson.length | 0;
+  let keyBytes = Stdlib_Array.reduce(outputValuedKeys, 0, (acc, k) => acc + k.length | 0);
+  let exact = (191 + handlerConfigBytes | 0) + keyBytes | 0;
+  let estimated = exact + (outputValuedKeys.length * 100 | 0) | 0;
+  if (exact > 4096) {
+    return Stdlib_JsError.throwWithMessage(lambdaName + `: Lambda environment is ` + exact.toString() + ` bytes before the ` + (outputValuedKeys.length.toString() + ` queue-URL vars are resolved, over the `) + ((4096).toString() + `-byte limit. HANDLER_CONFIG is ` + handlerConfigBytes.toString() + ` `) + `bytes of it — move the term that grows with the plugin into a code-archive asset (Util_Bundle.buildCodeArchive ~extraStringAssets), as pluginDefinition.json and sliceModules.json already are.`);
+  } else if (estimated > 4096) {
+    return log.warn("Util_LambdaEnvBudget", undefined, lambdaName + `: Lambda environment is about ` + estimated.toString() + ` bytes ` + (`(` + exact.toString() + ` exact + ` + outputValuedKeys.length.toString() + ` queue-URL `) + (`vars), at or over the ` + (4096).toString() + `-byte limit. The deploy may fail on `) + `UpdateFunctionConfiguration; move a plugin-sized term out of HANDLER_CONFIG.`);
+  } else {
+    return;
+  }
+}
+
+let limit = 4096;
+
+let frameworkVarsBytes = 191;
+
+let outputValueAllowance = 100;
+
+export {
+  limit,
+  frameworkVarsBytes,
+  outputValueAllowance,
+  log,
+  check,
+}
+/* log Not a pure module */

package/tests/EventCollectorEntryPoint_OpsTest.res

@@ -107,7 +107,6 @@ let minimalConfig = (extras: array<(string, JSON.t)>): string =>
       ("schedulerQueueName", str("")),
       ("extensionPoints", JSON.Encode.array([])),
       ("extensions", JSON.Encode.array([])),
-      ("publishToAggregates", obj([])),
     ],
     extras,
   )
@@ -139,7 +138,6 @@ describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
     let c = EventCollectorEntryPoint_Ops.parseHandlerConfig(minimalConfig([]))
     expect(c.queueUrl)->toBe("q-url")
     expect(c.connectExtension->Option.isNone)->toBe(true) // absent → None
-    expect(c.readModelQueueUrls->Dict.keysToArray->Array.length)->toBe(0)
     expect(c.readModelNamesForSourceName->Dict.keysToArray->Array.length)->toBe(0)
   })
 
@@ -198,7 +196,6 @@ describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
             ]),
           ]),
         ),
-        ("publishToAggregates", obj([("Plugin", str("PTA_Plugin_QUEUE_URL"))])),
         (
           "readModelNamesForSourceName",
           obj([("Ordering.Orders", JSON.Encode.array([str("ProductDemands")]))]),
@@ -208,9 +205,21 @@ describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
     let ep = c.extensionPoints->Array.getUnsafe(0)
     expect(ep.eventTopicArn)->toBe("arn:ep")
     expect(ep.aggregateNames)->toEqual(["Plugin"])
-    expect(c.publishToAggregates->Dict.get("Plugin"))->toEqual(Some("PTA_Plugin_QUEUE_URL"))
     expect(c.readModelNamesForSourceName->Dict.get("Ordering.Orders"))->toEqual(
       Some(["ProductDemands"]),
     )
   })
+
+  // The target→env-var maps left HANDLER_CONFIG for queueUrls.json, so a config
+  // still carrying them must parse rather than trip the required-field check —
+  // that is what a Lambda running an older archive sends.
+  testSync("ignores publishToAggregates left over in HANDLER_CONFIG", () => {
+    let c = EventCollectorEntryPoint_Ops.parseHandlerConfig(
+      minimalConfig([
+        ("publishToAggregates", obj([("Plugin", str("PTA_Plugin_QUEUE_URL"))])),
+        ("readModelQueueUrls", obj([("ProductDemands", str("PRM_ProductDemands_QUEUE_URL"))])),
+      ]),
+    )
+    expect(c.queueUrl)->toBe("q-url")
+  })
 })

package/tests/EventCollectorEntryPoint_OpsTest.res.mjs

@@ -210,10 +210,6 @@ function minimalConfig(extras) {
     [
       "extensions",
       []
-    ],
-    [
-      "publishToAggregates",
-      Object.fromEntries([])
     ]
   ].concat(extras)));
 }
@@ -238,7 +234,6 @@ globalThis.describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
     let c = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([]));
     globalThis.expect(c.queueUrl).toBe("q-url");
     globalThis.expect(Stdlib_Option.isNone(c.connectExtension)).toBe(true);
-    globalThis.expect(Object.keys(c.readModelQueueUrls).length).toBe(0);
     globalThis.expect(Object.keys(c.readModelNamesForSourceName).length).toBe(0);
   });
   globalThis.test("connectExtension: JSON null (admin) maps to None; a record decodes", () => {
@@ -304,13 +299,6 @@ globalThis.describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
             ]
           ])]
       ],
-      [
-        "publishToAggregates",
-        Object.fromEntries([[
-            "Plugin",
-            "PTA_Plugin_QUEUE_URL"
-          ]])
-      ],
       [
         "readModelNamesForSourceName",
         Object.fromEntries([[
@@ -322,9 +310,27 @@ globalThis.describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
     let ep = c.extensionPoints[0];
     globalThis.expect(ep.eventTopicArn).toBe("arn:ep");
     globalThis.expect(ep.aggregateNames).toEqual(["Plugin"]);
-    globalThis.expect(c.publishToAggregates["Plugin"]).toEqual("PTA_Plugin_QUEUE_URL");
     globalThis.expect(c.readModelNamesForSourceName["Ordering.Orders"]).toEqual(["ProductDemands"]);
   });
+  globalThis.test("ignores publishToAggregates left over in HANDLER_CONFIG", () => {
+    let c = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([
+      [
+        "publishToAggregates",
+        Object.fromEntries([[
+            "Plugin",
+            "PTA_Plugin_QUEUE_URL"
+          ]])
+      ],
+      [
+        "readModelQueueUrls",
+        Object.fromEntries([[
+            "ProductDemands",
+            "PRM_ProductDemands_QUEUE_URL"
+          ]])
+      ]
+    ]));
+    globalThis.expect(c.queueUrl).toBe("q-url");
+  });
 });
 
 let project = EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow;

package/tests/Util_LambdaEnvBudgetTest.res

@@ -0,0 +1,78 @@
+// Guards the deploy-time check on a Lambda's 4KB environment.
+//
+// The check exists because the limit is enforced by AWS mid-`pulumi up`, on a
+// call that names a byte count and not the field that grew. The two cases worth
+// pinning are the ones that decide whether a deploy proceeds: an exact total
+// already over the limit must stop it, and an over-limit total that only appears
+// once the unresolved queue-URL vars are estimated must not — a wrong estimate
+// blocking a good deploy would be worse than the failure it prevents.
+
+open JestGlobals
+
+let budget = Util_LambdaEnvBudget.limit
+
+let throws = (f: unit => 'a): option<string> =>
+  try {
+    let _ = f()
+    None
+  } catch {
+  | exn => exn->JsExn.fromException->Option.flatMap(JsExn.message)
+  }
+
+describe("Util_LambdaEnvBudget.check", () => {
+  testSync("passes a small environment", () => {
+    let msg = throws(() =>
+      Util_LambdaEnvBudget.check(~lambdaName="Small", ~handlerConfigJson=`{"queueUrl":"q"}`)
+    )
+    expect(msg)->toEqual(None)
+  })
+
+  testSync("throws when HANDLER_CONFIG alone exceeds the limit", () => {
+    let big = `{"x":"` ++ String.repeat("a", budget) ++ `"}`
+    let msg = throws(() => Util_LambdaEnvBudget.check(~lambdaName="TooBig", ~handlerConfigJson=big))
+    expect(msg->Option.isSome)->toBe(true)
+    // Names the Lambda and points at the fix, not just the byte count.
+    expect(msg->Option.mapOr(false, m => m->String.includes("TooBig")))->toBe(true)
+    expect(msg->Option.mapOr(false, m => m->String.includes("extraStringAssets")))->toBe(true)
+  })
+
+  testSync("counts the queue-URL var names toward the exact total", () => {
+    // Sized so HANDLER_CONFIG alone fits and the var NAMES alone push it over —
+    // the names are known at check time, so this must throw rather than warn.
+    let keys = Array.make(~length=40, "")->Array.mapWithIndex((_, i) =>
+      `PTA_AVeryLongAggregateNameNumber${i->Int.toString}_QUEUE_URL`
+    )
+    let keyBytes = keys->Array.reduce(0, (acc, k) => acc + String.length(k))
+    let fixed = Util_LambdaEnvBudget.frameworkVarsBytes + String.length("HANDLER_CONFIG")
+    // Just past the limit on the exact total alone — the names are enough.
+    let json = String.repeat("a", budget - fixed - keyBytes + 1)
+    let msg = throws(() =>
+      Util_LambdaEnvBudget.check(
+        ~lambdaName="ManyTargets",
+        ~handlerConfigJson=json,
+        ~outputValuedKeys=keys,
+      )
+    )
+    expect(msg->Option.isSome)->toBe(true)
+  })
+
+  testSync("only estimating over the limit warns rather than throwing", () => {
+    // Exact total sits under the limit; it is the per-URL allowance that crosses
+    // it. The deploy must be allowed to proceed and find out.
+    let keys = Array.make(~length=20, "")->Array.mapWithIndex((_, i) => `PTA_A${i->Int.toString}_URL`)
+    let exact =
+      Util_LambdaEnvBudget.frameworkVarsBytes +
+      String.length("HANDLER_CONFIG") +
+      keys->Array.reduce(0, (acc, k) => acc + String.length(k))
+    let room = budget - exact - 100
+    let json = String.repeat("a", room)
+    let msg = throws(() =>
+      Util_LambdaEnvBudget.check(
+        ~lambdaName="Estimated",
+        ~handlerConfigJson=json,
+        ~outputValuedKeys=keys,
+      )
+    )
+    expect(msg)->toEqual(None)
+  })
+})

package/tests/Util_LambdaEnvBudgetTest.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../src/util/Util_LambdaEnvBudget.res.mjs";
+
+function throws(f) {
+  try {
+    f();
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message);
+  }
+}
+
+globalThis.describe("Util_LambdaEnvBudget.check", () => {
+  globalThis.test("passes a small environment", () => {
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("Small", `{"queueUrl":"q"}`, undefined));
+    globalThis.expect(msg).toEqual(undefined);
+  });
+  globalThis.test("throws when HANDLER_CONFIG alone exceeds the limit", () => {
+    let big = `{"x":"` + "a".repeat(Util_LambdaEnvBudget$ReventlessAws.limit) + `"}`;
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("TooBig", big, undefined));
+    globalThis.expect(Stdlib_Option.isSome(msg)).toBe(true);
+    globalThis.expect(Stdlib_Option.mapOr(msg, false, m => m.includes("TooBig"))).toBe(true);
+    globalThis.expect(Stdlib_Option.mapOr(msg, false, m => m.includes("extraStringAssets"))).toBe(true);
+  });
+  globalThis.test("counts the queue-URL var names toward the exact total", () => {
+    let keys = Stdlib_Array.make(40, "").map((param, i) => `PTA_AVeryLongAggregateNameNumber` + i.toString() + `_QUEUE_URL`);
+    let keyBytes = Stdlib_Array.reduce(keys, 0, (acc, k) => acc + k.length | 0);
+    let fixed = Util_LambdaEnvBudget$ReventlessAws.frameworkVarsBytes + "HANDLER_CONFIG".length | 0;
+    let json = "a".repeat(((Util_LambdaEnvBudget$ReventlessAws.limit - fixed | 0) - keyBytes | 0) + 1 | 0);
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("ManyTargets", json, keys));
+    globalThis.expect(Stdlib_Option.isSome(msg)).toBe(true);
+  });
+  globalThis.test("only estimating over the limit warns rather than throwing", () => {
+    let keys = Stdlib_Array.make(20, "").map((param, i) => `PTA_A` + i.toString() + `_URL`);
+    let exact = (Util_LambdaEnvBudget$ReventlessAws.frameworkVarsBytes + "HANDLER_CONFIG".length | 0) + Stdlib_Array.reduce(keys, 0, (acc, k) => acc + k.length | 0) | 0;
+    let room = (Util_LambdaEnvBudget$ReventlessAws.limit - exact | 0) - 100 | 0;
+    let json = "a".repeat(room);
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("Estimated", json, keys));
+    globalThis.expect(msg).toEqual(undefined);
+  });
+});
+
+let budget = Util_LambdaEnvBudget$ReventlessAws.limit;
+
+export {
+  budget,
+  throws,
+}
+/*  Not a pure module */