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

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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
+
+* **plugin:** the field a read model is named by ([c679bb9](https://github.com/ReventlessDev/reventless-core/commit/c679bb9f610be9947417174bc3dfceea38207ba0))
+### Features
+
+* **plugin:** why a read model is named by that field ([699ef8e](https://github.com/ReventlessDev/reventless-core/commit/699ef8e72f1b1d82fb04672739e5e4a8db61ae9a))
+
+
 # 3.0.0-alpha.190 (2026-07-28)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.190",
+  "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-fast-csv": "1.2.0-alpha.14",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
+    "@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/reventless-infra": "3.0.0-alpha.108",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.110",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.83"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.85"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin.res

@@ -252,7 +252,7 @@ module Make = (
       // pushed SDL — CreateResolver then loops on
       // `NotFoundException: No field named ...`.
       let registryKey = entry.specName->Option.getOr(entityName)
-      let (labelField, _searchableFields) = Plugin_Structure.labelFieldsFromStateSchema(
+      let label: Plugin_Structure.labelResolution = Plugin_Structure.labelFieldsFromStateSchema(
         ~entityName,
         entry.stateSchema,
       )
@@ -263,7 +263,7 @@ module Make = (
         pluralTypeName: entry.listFieldName,
         includeIdParam: entry.includeIdParam->Option.getOr(true),
         connectionSpec: entry.connectionSpec->Option.getOr(true),
-        labelField,
+        labelField: label.field,
         connectionFilterTypeName: entry.returnTypeName ++ "Filter",
       }
       Plugin_Helpers.queryFieldNamesRegistry->Dict.set(registryKey, qn)

package/src/admin/Platform_Admin.res.mjs

@@ -110,13 +110,13 @@ function Make(RuntimeEnvironment) {
         let prefix = "Platform_";
         let entityName = entry.returnTypeName.startsWith(prefix) ? entry.returnTypeName.slice(prefix.length, entry.returnTypeName.length) : entry.returnTypeName;
         let registryKey = Stdlib_Option.getOr(entry.specName, entityName);
-        let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(entityName, entry.stateSchema);
+        let label = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(entityName, entry.stateSchema);
         let qn_singleFieldName = entry.singleFieldName;
         let qn_listFieldName = entry.listFieldName;
         let qn_returnTypeName = entry.returnTypeName;
         let qn_pluralTypeName = entry.listFieldName;
         let qn_connectionFilterTypeName = entry.returnTypeName + "Filter";
-        let qn_labelField = match[0];
+        let qn_labelField = label.field;
         let qn_includeIdParam = Stdlib_Option.getOr(entry.includeIdParam, true);
         let qn_connectionSpec = Stdlib_Option.getOr(entry.connectionSpec, true);
         let qn = {
@@ -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

@@ -111,6 +111,9 @@ let pluginReadModel: queryableDef = {
   linkedWriteSide: ["Plugin"],
   labelField: "name",
   searchableFields: ["name"],
+  // Hand-rolled rather than resolved, but the rung is the same one
+  // `labelFieldsFromStateSchema` would report for a field literally named `name`.
+  labelFieldSource: Some("convention"),
   statusField: Some("status"),
   visibility: None,
   chapter: None,
@@ -127,4 +130,5 @@ let structure: pluginStructure = {
   extensions: [],
   extensionPoints: None,
   requiredStores: None,
+  requiredStoreDeclarations: None,
 }

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -126,6 +126,8 @@ let pluginReadModel_linkedWriteSide = ["Plugin"];
 
 let pluginReadModel_searchableFields = ["name"];
 
+let pluginReadModel_labelFieldSource = "convention";
+
 let pluginReadModel_statusField = "status";
 
 let pluginReadModel = {
@@ -136,6 +138,7 @@ let pluginReadModel = {
   linkedWriteSide: pluginReadModel_linkedWriteSide,
   labelField: "name",
   searchableFields: pluginReadModel_searchableFields,
+  labelFieldSource: pluginReadModel_labelFieldSource,
   statusField: pluginReadModel_statusField,
   visibility: undefined,
   chapter: undefined
@@ -167,7 +170,8 @@ let structure = {
   inboundTranslationSlices: structure_inboundTranslationSlices,
   extensions: structure_extensions,
   extensionPoints: undefined,
-  requiredStores: undefined
+  requiredStores: undefined,
+  requiredStoreDeclarations: undefined
 };
 
 let pluginName = pluginId;

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -11,7 +11,7 @@ let sdlTypes: array<string> = [
   `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  apiExposed: Boolean\n}`,
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n}`,
-  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  statusField: String\n}`,
+  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n}`,
@@ -72,6 +72,10 @@ let encodeQueryableDef = (r: queryableDef): JSON.t =>
     ("linkedWriteSide", encodeStrings(r.linkedWriteSide)),
     ("labelField", JSON.Encode.string(r.labelField)),
     ("searchableFields", encodeStrings(r.searchableFields)),
+    (
+      "labelFieldSource",
+      r.labelFieldSource->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+    ),
     ("statusField", r.statusField->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
     ("chapter", r.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -9,7 +9,7 @@ let sdlTypes = [
   `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  apiExposed: Boolean\n}`,
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n}`,
-  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  statusField: String\n}`,
+  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n}`,
@@ -116,6 +116,10 @@ function encodeQueryableDef(r) {
       "searchableFields",
       r.searchableFields.map(prim => prim)
     ],
+    [
+      "labelFieldSource",
+      Stdlib_Option.mapOr(r.labelFieldSource, null, prim => prim)
+    ],
     [
       "statusField",
       Stdlib_Option.mapOr(r.statusField, null, prim => prim)

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/Dcb/Dcb_Builder.res

@@ -526,13 +526,13 @@ module Make = (
           module(V: StateViewSlice.T),
         ) => {
           let qn = Api_Naming.queryFieldNamesForStateView(~plugin=name, ~viewName=V.Spec.name)
-          let (labelField, _searchableFields) = Plugin_Structure.labelFieldsFromStateSchema(
+          let label = Plugin_Structure.labelFieldsFromStateSchema(
             ~entityName=V.Spec.name,
             V.Spec.stateSchema->S.castToUnknown,
           )
           let qn = {
             ...qn,
-            labelField,
+            labelField: label.field,
             connectionFilterTypeName: qn.returnTypeName ++ "Filter",
           }
           let qn = switch V.Spec.subIdConfig {

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -276,13 +276,13 @@ function Make(DcbEventLogStorage) {
       }
       stateViewSlices.forEach(V => {
         let qn = Api_Naming$ReventlessCore.queryFieldNamesForStateView(name, V.Spec.name, undefined);
-        let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(V.Spec.name, V.Spec.stateSchema);
+        let label = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(V.Spec.name, V.Spec.stateSchema);
         let newrecord = {...qn};
-        newrecord.labelField = match[0];
+        newrecord.labelField = label.field;
         newrecord.connectionFilterTypeName = qn.returnTypeName + "Filter";
-        let match$1 = V.Spec.subIdConfig;
+        let match = V.Spec.subIdConfig;
         let qn$1;
-        if (match$1 !== undefined) {
+        if (match !== undefined) {
           let newrecord$1 = {...newrecord};
           newrecord$1.itemsFilterTypeName = newrecord.returnTypeName + "ItemsFilter";
           newrecord$1.itemsFieldName = newrecord.singleFieldName + "Items";

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.`