@reventlessdev/reventless-core 3.0.0-alpha.191 → 3.0.0-alpha.192

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 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.192 (2026-07-30)
+
+### Bug Fixes
+
+* **core,aws:** provision the side-effect handler Lambda, which never existed ([d07311e](https://github.com/ReventlessDev/reventless-core/commit/d07311e0cfc368e9b3d51596e775a58b55a2fc0e))
+* **core:** resolve each eventMapper before collecting, not after ([12060d8](https://github.com/ReventlessDev/reventless-core/commit/12060d84733e1636255be03c432f959139600dbf))
+### Features
+
+* **spec,core,local:** emit capabilities.json from the plugin build ([57a3276](https://github.com/ReventlessDev/reventless-core/commit/57a3276a6b02af93490a8b460e3aa158b7e0e0f8))
+* **spec,core:** derive the platform capability list — inference and generation (stage 3) ([8ab4d25](https://github.com/ReventlessDev/reventless-core/commit/8ab4d2504bd717487fbc87a0f5a053024c8258f9))
+
+
 # 3.0.0-alpha.191 (2026-07-29)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.191",
+  "version": "3.0.0-alpha.192",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
-    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
+    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.109",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.110",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.84"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.85"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin.res.mjs

@@ -247,6 +247,10 @@ function Make(RuntimeEnvironment) {
       createAggregatesWithoutEventMappers: Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers,
       finishAggregates: Builder_Helpers$ReventlessCore.finishAggregates,
       addEventMappers: Builder_Helpers$ReventlessCore.addEventMappers,
+      taskSideEffectGates: Builder_Helpers$ReventlessCore.taskSideEffectGates,
+      taskSideEffectFinishFns: Builder_Helpers$ReventlessCore.taskSideEffectFinishFns,
+      registerTaskSideEffectHandler: Builder_Helpers$ReventlessCore.registerTaskSideEffectHandler,
+      finishTasks: Builder_Helpers$ReventlessCore.finishTasks,
       readModelNamesForSourceName: Builder_Helpers$ReventlessCore.readModelNamesForSourceName,
       publishToReadModels: Builder_Helpers$ReventlessCore.publishToReadModels,
       finishReadModels: Builder_Helpers$ReventlessCore.finishReadModels,

package/src/admin/Platform_Admin_Structure.res

@@ -130,4 +130,5 @@ let structure: pluginStructure = {
   extensions: [],
   extensionPoints: None,
   requiredStores: None,
+  requiredStoreDeclarations: None,
 }

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -170,7 +170,8 @@ let structure = {
   inboundTranslationSlices: structure_inboundTranslationSlices,
   extensions: structure_extensions,
   extensionPoints: undefined,
-  requiredStores: undefined
+  requiredStores: undefined,
+  requiredStoreDeclarations: undefined
 };
 
 let pluginName = pluginId;

package/src/components/Aggregate/Aggregate.res

@@ -55,13 +55,13 @@ let toResolvedOutputs = (
       }
       resolved
     })
-  let eventMapperResolved = switch outputs.eventMapper {
-  | Some(emOutput) =>
-    emOutput
-    ->Pulumi.Output.flatMap(EventMapper.toResolvedOutputs)
-    ->Pulumi.Output.apply(resolved => Some(resolved))
-  | None => Pulumi.Output.make(None)
-  }
+  let eventMapperResolved =
+    outputs.eventMapper->Pulumi.Output.flatMap(em =>
+      switch em {
+      | Some(em) => em->EventMapper.toResolvedOutputs->Pulumi.Output.apply(r => Some(r))
+      | None => Pulumi.Output.make(None)
+      }
+    )
   (commandGeneratorResolved, commandTopicResolved, eventLogResolved, eventMapperResolved)
   ->Pulumi.Output.all4
   ->Pulumi.Output.apply(((commandGenerator, commandTopic, eventLog, eventMapper)) =>

package/src/components/Aggregate/Aggregate.res.mjs

@@ -39,8 +39,13 @@ function toResolvedOutputs(outputs) {
       resources: param[1]
     }
   }));
-  let emOutput = outputs.eventMapper;
-  let eventMapperResolved = emOutput !== undefined ? Output$Pulumi.flatMap(emOutput, EventMapper$ReventlessCore.toResolvedOutputs).apply(resolved => resolved) : Pulumi.output(undefined);
+  let eventMapperResolved = Output$Pulumi.flatMap(outputs.eventMapper, em => {
+    if (em !== undefined) {
+      return EventMapper$ReventlessCore.toResolvedOutputs(em).apply(r => r);
+    } else {
+      return Pulumi.output(undefined);
+    }
+  });
   return Pulumi.all([
     commandGeneratorResolved,
     commandTopicResolved,

package/src/components/Aggregate/Aggregate_Builder.res

@@ -58,7 +58,7 @@ module Make = (
       {
         ...aggregate->Component.outputs,
         eventMapper: eventMapper->Pulumi.Output.apply(eventMapper =>
-          eventMapper->Component.outputs
+          Some(eventMapper->Component.outputs)
         ),
       }
     } else {
@@ -175,6 +175,9 @@ module Make = (
       commandGenerator: commandGenerator->Component.wrappedOutputs,
       commandTopic: commandTopic->Component.wrappedOutputs,
       eventLog: eventLog->Component.outputs,
+      // Resolved-absent rather than an absent field: an aggregate without
+      // EventMappings still has to answer the question.
+      eventMapper: Pulumi.Output.make(None),
       addEventMapper: self->addEventMapperFn(~opts, ...),
     }
     self->Component.setOutputs(aggOutputs)

package/src/components/Aggregate/Aggregate_Builder.res.mjs

@@ -89,6 +89,7 @@ function Make(Spec) {
       let aggOutputs_commandGenerator = Component$ReventlessCore.wrappedOutputs(commandGenerator);
       let aggOutputs_commandTopic = Component$ReventlessCore.wrappedOutputs(commandTopic);
       let aggOutputs_eventLog = Component$ReventlessCore.outputs(eventLog);
+      let aggOutputs_eventMapper = Pulumi.output(undefined);
       let aggOutputs_addEventMapper = (none, none$1) => {
         if (EventMappings.mappings.length === 0) {
           return Component$ReventlessCore.outputs(extra);
@@ -97,15 +98,22 @@ function Make(Spec) {
           Component$ReventlessCore.operations(extra),
           Component$ReventlessCore.outputs(extra).commandTopic
         ]).apply(param => SpecificEventMapper.make(ComponentType$ReventlessCore.name(Spec.name, Aggregate$ReventlessCore.componentType), none, none$1, param[0].publishJsons, param[1].resources, undefined, undefined, opts));
-        let newrecord = {...Component$ReventlessCore.outputs(extra)};
-        newrecord.eventMapper = eventMapper.apply(Component$ReventlessCore.outputs);
-        return newrecord;
+        let init = Component$ReventlessCore.outputs(extra);
+        return {
+          name: init.name,
+          commandGenerator: init.commandGenerator,
+          commandTopic: init.commandTopic,
+          eventLog: init.eventLog,
+          eventMapper: eventMapper.apply(eventMapper => Component$ReventlessCore.outputs(eventMapper)),
+          addEventMapper: init.addEventMapper
+        };
       };
       let aggOutputs = {
         name: aggOutputs_name,
         commandGenerator: aggOutputs_commandGenerator,
         commandTopic: aggOutputs_commandTopic,
         eventLog: aggOutputs_eventLog,
+        eventMapper: aggOutputs_eventMapper,
         addEventMapper: aggOutputs_addEventMapper
       };
       return Component$ReventlessCore.setOutputs(extra, aggOutputs);

package/src/components/Builder_Helpers.res

@@ -58,16 +58,23 @@ let finishAggregates = (
   // to ensure forCommandTopic has registered specs before finish() runs.
   let allCommandTopicOutputs =
     allOutputs->Array.map(aggregateOutputs => aggregateOutputs.commandTopic)
-  let eventMapperOutputs =
-    allOutputs
-    ->Array.map(aggregateOutputs => aggregateOutputs.eventMapper)
-    ->Array.keepSome
+  let eventMapperOutputs = allOutputs->Array.map(aggregateOutputs => aggregateOutputs.eventMapper)
 
   let _ =
     (eventMapperOutputs->Pulumi.Output.all, allCommandTopicOutputs->Pulumi.Output.all)
     ->Pulumi.Output.all2
     ->Pulumi.Output.apply(((eventMapperOutputs, _)) =>
+      // Filtered after resolution, not before: the absent ones are now `None`
+      // inside a resolved array rather than missing fields.
+      //
+      // `eventCollector` here is a plain record, not an Output: `Output.all` above
+      // deeply unwrapped the contents of each element. That is fine because `all`
+      // accepts resolved values, but nothing in this block may call
+      // `EventMapper.toResolvedOutputs` — it expects unresolved fields and would
+      // throw `m.apply is not a function`. Resolve at the depth where the record is
+      // still unresolved instead, as `serializeEventMappersOutputs` does.
       eventMapperOutputs
+      ->Array.keepSome
       ->Array.map(eventMapperOutput => eventMapperOutput.eventCollector)
       ->Pulumi.Output.all
       ->Pulumi.Output.apply(_ =>
@@ -89,6 +96,32 @@ let addEventMappers = (
   aggregatesOutputs
 }
 
+// Side-effect handlers registered by Task_Builder, with the Output that tells us the
+// handler has reached its runtime builder. Registration happens inside an
+// `allCommandTopics` apply, so `make` returning is not enough — a synchronous
+// `finish()` would build the shared runtime before any handler had registered, or
+// worse, from only the first one.
+let taskSideEffectGates: array<Pulumi.Output.t<unit>> = []
+let taskSideEffectFinishFns: array<unit => unit> = []
+
+let registerTaskSideEffectHandler = (~gate, ~finish) => {
+  let _ = taskSideEffectGates->Array.push(gate)
+  let _ = taskSideEffectFinishFns->Array.push(finish)
+}
+
+// Provision side-effect handler runtimes once every task's handler is ready. Same
+// shape as `finishAggregates`: collect the gates, wait on all of them, then run the
+// finish functions. Adapters guard against repeat calls.
+let finishTasks = () =>
+  if taskSideEffectGates->Array.length > 0 {
+    let _ =
+      taskSideEffectGates
+      ->Pulumi.Output.all
+      ->Pulumi.Output.apply(_ =>
+        taskSideEffectFinishFns->Array.forEach(finishFn => finishFn())
+      )
+  }
+
 let readModelNamesForSourceName = Dict.make()
 let publishToReadModels = Dict.make()
 

package/src/components/Builder_Helpers.res.mjs

@@ -33,11 +33,11 @@ function createAggregatesWithoutEventMappers(aggregates, api, componentRuntime,
 function finishAggregates(aggregatesOutputs) {
   let allOutputs = Object.values(aggregatesOutputs);
   let allCommandTopicOutputs = allOutputs.map(aggregateOutputs => aggregateOutputs.commandTopic);
-  let eventMapperOutputs = Stdlib_Array.keepSome(allOutputs.map(aggregateOutputs => aggregateOutputs.eventMapper));
+  let eventMapperOutputs = allOutputs.map(aggregateOutputs => aggregateOutputs.eventMapper);
   Pulumi.all([
     Pulumi.all(eventMapperOutputs),
     Pulumi.all(allCommandTopicOutputs)
-  ]).apply(param => Pulumi.all(param[0].map(eventMapperOutput => eventMapperOutput.eventCollector)).apply(param => {
+  ]).apply(param => Pulumi.all(Stdlib_Array.keepSome(param[0]).map(eventMapperOutput => eventMapperOutput.eventCollector)).apply(param => {
     Object.values(aggregateFinishFns).forEach(finishFn => finishFn());
   }));
 }
@@ -48,6 +48,24 @@ function addEventMappers(allEventTopics, queryEngine) {
   return aggregatesOutputs;
 }
 
+let taskSideEffectGates = [];
+
+let taskSideEffectFinishFns = [];
+
+function registerTaskSideEffectHandler(gate, finish) {
+  taskSideEffectGates.push(gate);
+  taskSideEffectFinishFns.push(finish);
+}
+
+function finishTasks() {
+  if (taskSideEffectGates.length !== 0) {
+    Pulumi.all(taskSideEffectGates).apply(param => {
+      taskSideEffectFinishFns.forEach(finishFn => finishFn());
+    });
+    return;
+  }
+}
+
 let readModelNamesForSourceName = {};
 
 let publishToReadModels = {};
@@ -131,6 +149,10 @@ export {
   createAggregatesWithoutEventMappers,
   finishAggregates,
   addEventMappers,
+  taskSideEffectGates,
+  taskSideEffectFinishFns,
+  registerTaskSideEffectHandler,
+  finishTasks,
   readModelNamesForSourceName,
   publishToReadModels,
   finishReadModels,

package/src/components/SideEffectHandler/SideEffectHandler.res

@@ -32,4 +32,15 @@ module type T = {
     ~extraEnvVars: dict<Pulumi.Input.t<string>>=?,
     ~opts: Pulumi.ComponentResource.options=?,
   ) => component
+
+  /** Provision the runtime for every handler registered by `make`.
+   *
+   * Adapters that share one runtime across all side-effect handlers can only build
+   * it once every handler has registered, so nothing is provisioned by `make`
+   * alone. Every other component type has this seam
+   * (`ReadModel_Builder.finish`, `Aggregate_Builder.finish`, …); the side-effect
+   * handler went without one, which is why its Lambda was never created. Call it
+   * after the last handler is constructed — `Builder_Helpers.finishTasks` gates it
+   * on their readiness. Idempotent. */
+  let finish: unit => unit
 }

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res

@@ -122,4 +122,6 @@ module Make = (
       ~opts,
     )
   }
+
+  let finish = () => EventCollectorRuntimeBuilder.finish()
 }

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res.mjs

@@ -55,8 +55,10 @@ function Make(RuntimeEnvironment) {
         });
       }, opts);
     };
+    let finish = () => EventCollectorRuntimeBuilder.finish();
     return {
-      make: make
+      make: make,
+      finish: finish
     };
   }));
 }

package/src/components/Task/Task_Builder.res

@@ -93,6 +93,17 @@ module Make = (
         )
       )
 
+    // The handler's runtime is provisioned by `SpecificSideEffectHandler.finish()`,
+    // not by `make` — see `SideEffectHandler.T.finish`. Register it with the gate that
+    // says this handler has reached its runtime builder: `operations` is set at the end
+    // of the builder's construct, after `forEventCollector` has run.
+    sideEffectHandler->Option.forEach(handler =>
+      Builder_Helpers.registerTaskSideEffectHandler(
+        ~gate=handler->Component.operations->Pulumi.Output.apply(_ => ()),
+        ~finish=SpecificSideEffectHandler.finish,
+      )
+    )
+
     let taskActionsHandler = (taskActions, operations: option<SideEffectHandler.operations>) => {
       taskActions
       ->Array.map(async taskAction => {

package/src/components/Task/Task_Builder.res.mjs

@@ -12,6 +12,7 @@ import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as Util_Promise$ReventlessCore from "../../util/Util_Promise.res.mjs";
 import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
 import * as RuntimeHints$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/RuntimeHints.res.mjs";
+import * as Builder_Helpers$ReventlessCore from "../Builder_Helpers.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -40,6 +41,7 @@ function Make(Spec) {
       let publishCommands = (aggregateName, cmdJsons) => Stdlib_Option.getOrThrow(publishToAggregates[aggregateName], undefined)(cmdJsons);
       let config = Spec.setup(queryEngine, queryBucketName, opts);
       let sideEffectHandler = Stdlib_Option.map(config.sideEffects, sideEffects => SpecificSideEffectHandler.make(extra$1, sideEffects, Aggregate$ReventlessCore.allEventTopics(allAggregates), allCommandTopics, undefined, queryEngine, scheduler, resourceNaming, undefined, undefined, undefined, opts));
+      Stdlib_Option.forEach(sideEffectHandler, handler => Builder_Helpers$ReventlessCore.registerTaskSideEffectHandler(Component$ReventlessCore.operations(handler).apply(param => {}), SpecificSideEffectHandler.finish));
       let taskActionsHandler = (taskActions, operations) => Util_Promise$ReventlessCore.toUnit(Promise.all(taskActions.map(async taskAction => {
         switch (taskAction.TAG) {
           case "PublishCommands" :

package/src/plugin/component/Capability_Inference.res

@@ -0,0 +1,68 @@
+// Heuristic detection of fields that look like stored-object references but
+// carry no `@storageRef` declaration.
+//
+// Declarations are authoritative: `Plugin_Structure` collects them into
+// `requiredStores`, the capability manifest renders them, and the platform
+// provisions from the union. This module is the second rung — the UI's
+// field-name heuristics restated over the same schema walk — and it is a lint,
+// not a mechanism: a heuristic match produces a warning naming the field and
+// the annotation that would settle it, and never provisions anything. Guessing
+// is a poor basis for creating and destroying infrastructure; a field named
+// `imageUrl` is genuinely ambiguous between an uploaded object and an external
+// URL, and only its author can say which.
+
+/** One heuristic-only match: a field whose name says "stored object" on a
+    component whose schema does not declare a store for it. */
+type warning = {component: string, field: string}
+
+// The two name rules the UI's semantic layer applies, restated here so the
+// lint warns about exactly the fields the UI would silently upgrade to an
+// upload input if an endpoint happened to exist. Matched case-insensitively
+// and exactly (suffix rules aside): `customerFile` names a customer's file,
+// not necessarily a stored object.
+let refLikeNames = ["file", "attachment", "upload"]
+let refLikeSuffixes = ["storageref", "fileref", "attachmentref"]
+let imageLikeNames = ["image", "imageurl", "photo", "photourl", "avatar", "avatarurl", "thumbnail"]
+
+let nameMatches = (field: string): bool => {
+  let lower = field->String.toLowerCase
+  refLikeNames->Array.includes(lower) ||
+  imageLikeNames->Array.includes(lower) ||
+  refLikeSuffixes->Array.some(suffix => lower->String.endsWith(suffix))
+}
+
+let warningsFromProperties = (~component, properties: dict<S.t<unknown>>): array<warning> =>
+  properties
+  ->Dict.toArray
+  ->Array.filterMap(((field, fieldSchema)) =>
+    switch fieldSchema {
+    | String(_) if field != "TAG" &&
+      nameMatches(field) &&
+      Reventless.StorageRef.getStore(fieldSchema)->Option.isNone =>
+      Some({component, field})
+    | _ => None
+    }
+  )
+
+/** Scan one component schema — a command/event union or a state object — for
+    heuristic-only matches. The walk mirrors `Plugin_Structure`'s declared-store
+    walk over the same schemas, so a field is either collected there (declared)
+    or eligible to warn here, never both. */
+let scanSchema = (~component: string, schema: S.t<unknown>): array<warning> => {
+  let fromVariant = v =>
+    switch v {
+    | S.Object({properties}) => warningsFromProperties(~component, properties)
+    | _ => []
+    }
+  switch schema {
+  | Union({anyOf}) => anyOf->Array.flatMap(fromVariant)
+  | other => fromVariant(other)
+  }
+}
+
+/** The warning text: name the field, name the annotation that would settle it,
+    and say what to do when the heuristic is wrong. */
+let message = (w: warning): string =>
+  `${w.component}.${w.field} looks like a stored-object reference but declares no store — ` ++
+  `annotate it \`@storageRef("<store>")\` so the deployment provisions the store it needs, ` ++
+  `or rename the field if it holds an external URL. Heuristic matches are never provisioned.`

package/src/plugin/component/Capability_Inference.res.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+
+let refLikeNames = [
+  "file",
+  "attachment",
+  "upload"
+];
+
+let refLikeSuffixes = [
+  "storageref",
+  "fileref",
+  "attachmentref"
+];
+
+let imageLikeNames = [
+  "image",
+  "imageurl",
+  "photo",
+  "photourl",
+  "avatar",
+  "avatarurl",
+  "thumbnail"
+];
+
+function nameMatches(field) {
+  let lower = field.toLowerCase();
+  if (refLikeNames.includes(lower) || imageLikeNames.includes(lower)) {
+    return true;
+  } else {
+    return refLikeSuffixes.some(suffix => lower.endsWith(suffix));
+  }
+}
+
+function warningsFromProperties(component, properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldSchema = param[1];
+    let field = param[0];
+    if (fieldSchema.type === "string" && field !== "TAG" && nameMatches(field) && Stdlib_Option.isNone(StorageRef$Reventless.getStore(fieldSchema))) {
+      return {
+        component: component,
+        field: field
+      };
+    }
+  });
+}
+
+function scanSchema(component, schema) {
+  let fromVariant = v => {
+    if (v.type === "object") {
+      return warningsFromProperties(component, v.properties);
+    } else {
+      return [];
+    }
+  };
+  if (schema.type === "union") {
+    return schema.anyOf.flatMap(fromVariant);
+  } else {
+    return fromVariant(schema);
+  }
+}
+
+function message(w) {
+  return w.component + `.` + w.field + ` looks like a stored-object reference but declares no store — annotate it \`@storageRef("<store>")\` so the deployment provisions the store it needs, or rename the field if it holds an external URL. Heuristic matches are never provisioned.`;
+}
+
+export {
+  refLikeNames,
+  refLikeSuffixes,
+  imageLikeNames,
+  nameMatches,
+  warningsFromProperties,
+  scanSchema,
+  message,
+}
+/* StorageRef-Reventless Not a pure module */

package/src/plugin/component/Plugin_Helpers.res

@@ -434,6 +434,8 @@ let createTasks = (
         ~opts=Some(opts),
       ))
     )
+  // Every task is constructed, so every side-effect handler has registered.
+  finishTasks()
   tasksOutputs.contents
 }
 
@@ -1246,23 +1248,32 @@ let serializeTasksOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSO
 // Serialize event mappers from aggregates to JSON array for the "eventMappers" stack export.
 let serializeEventMappersOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSON.t> =>
   pluginOutputs.aggregates->Pulumi.Output.flatMap(aggregates =>
+    // Resolve each `eventMapper` through its own Output before collecting, and only
+    // then drop the absent ones. `Output.all` deeply unwraps the *contents* of its
+    // elements, so collecting first would hand `toResolvedOutputs` a record whose
+    // fields Pulumi has already resolved — see `serializePlainDictExport` above for
+    // the same hazard. Absence is carried as `None` through the collection instead.
     aggregates
     ->Dict.valuesToArray
-    ->Array.filterMap((agg: Aggregate.outputs) =>
-      agg.eventMapper->Option.map(eventMapperOutput =>
-        eventMapperOutput->Pulumi.Output.flatMap(em =>
+    ->Array.map((agg: Aggregate.outputs) =>
+      agg.eventMapper->Pulumi.Output.flatMap(em =>
+        switch em {
+        | Some(em) =>
           em
           ->EventMapper.toResolvedOutputs
           ->Pulumi.Output.apply(resolved =>
-            resolved->S.reverseConvertToJsonOrThrow(
-              ReventlessInterop.EventMapper.resolvedOutputsSchema,
+            Some(
+              resolved->S.reverseConvertToJsonOrThrow(
+                ReventlessInterop.EventMapper.resolvedOutputsSchema,
+              ),
             )
           )
-        )
+        | None => Pulumi.Output.make(None)
+        }
       )
     )
     ->Pulumi.Output.all
-    ->Pulumi.Output.apply(arr => arr->JSON.Encode.array)
+    ->Pulumi.Output.apply(arr => arr->Array.keepSome->JSON.Encode.array)
   )
 
 // Export platform admin component outputs as individual top-level Pulumi stack exports.

package/src/plugin/component/Plugin_Helpers.res.mjs

@@ -248,6 +248,7 @@ function createTasks(tasks, aggregatesOutputs, scheduler, schedulerRoleUrn, publ
     let bucketName = bucketNameOpt !== undefined ? bucketNameOpt : "Bucket";
     return ResourceQueryRuntime$ReventlessCore.bucketNameOfTaskExn(tasksOutputs.contents, taskName, bucketName);
   }, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, resourceNaming, aggregatesOutputs, componentRuntime[SpecificTask.Spec.name], opts)));
+  Builder_Helpers$ReventlessCore.finishTasks();
   return tasksOutputs.contents;
 }
 
@@ -627,7 +628,13 @@ function serializeTasksOutputs(pluginOutputs) {
 }
 
 function serializeEventMappersOutputs(pluginOutputs) {
-  return Output$Pulumi.flatMap(pluginOutputs.aggregates, aggregates => Pulumi.all(Stdlib_Array.filterMap(Object.values(aggregates), agg => Stdlib_Option.map(agg.eventMapper, eventMapperOutput => Output$Pulumi.flatMap(eventMapperOutput, em => EventMapper$ReventlessCore.toResolvedOutputs(em).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, EventMapper$ReventlessInterop.resolvedOutputsSchema)))))).apply(arr => arr));
+  return Output$Pulumi.flatMap(pluginOutputs.aggregates, aggregates => Pulumi.all(Object.values(aggregates).map(agg => Output$Pulumi.flatMap(agg.eventMapper, em => {
+    if (em !== undefined) {
+      return EventMapper$ReventlessCore.toResolvedOutputs(em).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, EventMapper$ReventlessInterop.resolvedOutputsSchema));
+    } else {
+      return Pulumi.output(undefined);
+    }
+  }))).apply(Stdlib_Array.keepSome));
 }
 
 function exportPlatformOutputs(extensionPointsOutputs, aggregatesOutputs, readModelsOutputs, dcbEventLogOutputs, stateChangeSlicesOutputs, stateViewSlicesOutputs, automationSlicesOutputs, outboundTranslationSlicesOutputs, inboundTranslationSlicesOutputs) {
@@ -913,6 +920,14 @@ let finishAggregates = Builder_Helpers$ReventlessCore.finishAggregates;
 
 let addEventMappers = Builder_Helpers$ReventlessCore.addEventMappers;
 
+let taskSideEffectGates = Builder_Helpers$ReventlessCore.taskSideEffectGates;
+
+let taskSideEffectFinishFns = Builder_Helpers$ReventlessCore.taskSideEffectFinishFns;
+
+let registerTaskSideEffectHandler = Builder_Helpers$ReventlessCore.registerTaskSideEffectHandler;
+
+let finishTasks = Builder_Helpers$ReventlessCore.finishTasks;
+
 let readModelNamesForSourceName = Builder_Helpers$ReventlessCore.readModelNamesForSourceName;
 
 let publishToReadModels = Builder_Helpers$ReventlessCore.publishToReadModels;
@@ -968,6 +983,10 @@ export {
   createAggregatesWithoutEventMappers,
   finishAggregates,
   addEventMappers,
+  taskSideEffectGates,
+  taskSideEffectFinishFns,
+  registerTaskSideEffectHandler,
+  finishTasks,
   readModelNamesForSourceName,
   publishToReadModels,
   finishReadModels,