@reventlessdev/reventless-spec 3.0.0-alpha.76 → 3.0.0-alpha.78

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.78 (2026-07-16)
+
+### Features
+
+* **aws:** consume per-component runtime hints; fold into shared command Lambdas ([7ba2485](https://github.com/ReventlessDev/reventless-core/commit/7ba248579f2472f2fc847b26033927199353f3e6))
+* **core:** thread per-component runtime hints from plugin.json (spec/infra/core/local) ([a94f419](https://github.com/ReventlessDev/reventless-core/commit/a94f4199c4ac7eeeb24dd0a71d58fb73c1e514e6))
+
+
+# 3.0.0-alpha.77 (2026-07-15)
+
+### Performance Improvements
+
+* **spec:** reverse-convert DcbTag extraction instead of stringify round-trip ([4311c7b](https://github.com/ReventlessDev/reventless-core/commit/4311c7b863f99e582911ced529d77dca7cc36381))
+
+
 # 3.0.0-alpha.76 (2026-07-12)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.76",
+  "version": "3.0.0-alpha.78",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -21,11 +21,11 @@
     "sury-ppx": "11.0.0-alpha.2"
   },
   "devDependencies": {
-    "rescript": "^12.3.0",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.7"
+    "rescript": "12.3.0",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.8"
   },
   "peerDependencies": {
-    "rescript": "^12.3.0"
+    "rescript": "12.3.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/components/DcbTag.res

@@ -399,7 +399,11 @@ let extractTagsFromJson = (schema: S.t<unknown>, json: JSON.t): array<tag> =>
 /**
 Extracts DCB tags from a typed event value using its sury schema.
 
-Serializes the value to JSON first, then delegates to `extractTagsFromJson`.
+Reverse-converts the value to JSON through its schema, then delegates to
+`extractTagsFromJson`. Using the schema-aware reverse convert (instead of a
+`JSON.stringifyAny -> parseOrThrow` string round-trip) avoids serializing the
+whole event to a string per message and emits the schema's serialized field
+keys — so `@as`-renamed tagged fields are found by the same-schema walker.
 
 @example
 ```rescript
@@ -410,10 +414,8 @@ let tags = DcbTag.extractTags(
 // [{key: "categoryId", value: "cat-1"}]
 ```
 */
-let extractTags = (schema: S.t<'a>, value: 'a): array<tag> => {
-  let json = value->JSON.stringifyAny->Option.getOrThrow->JSON.parseOrThrow
-  extractTagsFromJson(schema->toUnknownSchema, json)
-}
+let extractTags = (schema: S.t<'a>, value: 'a): array<tag> =>
+  extractTagsFromJson(schema->toUnknownSchema, value->S.reverseConvertToJsonOrThrow(schema))
 
 // --- Extract variant constructor names from a tagged union schema ---
 // For a variant type like `type event = ItemCreated({...}) | ItemRenamed({...})`,
@@ -596,10 +598,8 @@ let tags = DcbTag.extractTagsExpanded(
 // [{key: "orderId", value: "ord-1"}, {key: "productIds", value: "p1"}, {key: "productIds", value: "p2"}]
 ```
 */
-let extractTagsExpanded = (schema: S.t<'a>, value: 'a): array<tag> => {
-  let json = value->JSON.stringifyAny->Option.getOrThrow->JSON.parseOrThrow
-  extractTagsFromJsonExpanded(schema->toUnknownSchema, json)
-}
+let extractTagsExpanded = (schema: S.t<'a>, value: 'a): array<tag> =>
+  extractTagsFromJsonExpanded(schema->toUnknownSchema, value->S.reverseConvertToJsonOrThrow(schema))
 
 // --- Automatic query construction from command schema ---
 

package/src/components/DcbTag.res.mjs

@@ -202,8 +202,7 @@ function extractTagsFromJson(schema, json) {
 }
 
 function extractTags(schema, value) {
-  let json = JSON.parse(Stdlib_Option.getOrThrow(JSON.stringify(value), undefined));
-  return extractTagsFromJson(schema, json);
+  return extractTagsFromJson(schema, S.reverseConvertToJsonOrThrow(value, schema));
 }
 
 function extractVariantNames(schema) {
@@ -345,8 +344,7 @@ function extractTagsFromJsonExpanded(schema, json) {
 }
 
 function extractTagsExpanded(schema, value) {
-  let json = JSON.parse(Stdlib_Option.getOrThrow(JSON.stringify(value), undefined));
-  return extractTagsFromJsonExpanded(schema, json);
+  return extractTagsFromJsonExpanded(schema, S.reverseConvertToJsonOrThrow(value, schema));
 }
 
 function hasTaggedArrayFields(schema) {

package/src/components/Plugin.res

@@ -368,23 +368,6 @@ type pluginStructure = {
 
 let pluginStructureOptionSchema = _jsNullable(pluginStructureSchema, ())
 
-// ── Event graph types (cross-plugin component graph) ──────────────────────────
-
-@schema
-type graphNode = {pluginName: string, componentName: string, kind: string}
-
-@schema
-type graphEdge = {
-  source: graphNode,
-  target: graphNode,
-  mechanism: string,
-  viaEvents: array<string>,
-  implicit: bool,
-}
-
-@schema
-type platformEventGraph = {nodes: array<graphNode>, edges: array<graphEdge>}
-
 /**
 The self-description of a deployed plugin, persisted in the plugin's event store.
 

package/src/components/Plugin.res.mjs

@@ -190,25 +190,6 @@ let pluginStructureSchema = S.schema(s => ({
 
 let pluginStructureOptionSchema = SuryResMjs.js_nullable(pluginStructureSchema);
 
-let graphNodeSchema = S.schema(s => ({
-  pluginName: s.m(S.string),
-  componentName: s.m(S.string),
-  kind: s.m(S.string)
-}));
-
-let graphEdgeSchema = S.schema(s => ({
-  source: s.m(graphNodeSchema),
-  target: s.m(graphNodeSchema),
-  mechanism: s.m(S.string),
-  viaEvents: s.m(S.array(S.string)),
-  implicit: s.m(S.bool)
-}));
-
-let platformEventGraphSchema = S.schema(s => ({
-  nodes: s.m(S.array(graphNodeSchema)),
-  edges: s.m(S.array(graphEdgeSchema))
-}));
-
 let pluginDefinitionSchema = S.schema(s => ({
   id: s.m(S.string),
   name: s.m(S.string),
@@ -262,9 +243,6 @@ export {
   extensionPointDefArrayOptionSchema,
   pluginStructureSchema,
   pluginStructureOptionSchema,
-  graphNodeSchema,
-  graphEdgeSchema,
-  platformEventGraphSchema,
   pluginDefinitionSchema,
 }
 /* pluginKindSchema Not a pure module */

package/src/generator/Codegen.res

@@ -249,6 +249,86 @@ let renderExtensionMakeParam = (extensions: array<string>): option<string> =>
     Some("      ~extensions=[" ++ entries->Array.join(", ") ++ "],")
   }
 
+// ── Per-component runtime hints (plugin.json `runtime` block) ─────────────────
+// Emits `~componentRuntime=Dict.fromArray([("Customers", {memorySize: Some(2048),
+// timeout: None}), …])` into `Platform.Plugin.make(...)`. Only emitted when the
+// plugin declares a `runtime` block, so plugins without one keep a byte-identical
+// generated Plugin.res.
+
+let renderRuntimeHints = (h: Config.runtimeHints): string => {
+  let optInt = (o: option<int>) =>
+    switch o {
+    | Some(n) => "Some(" ++ n->Int.toString ++ ")"
+    | None => "None"
+    }
+  // Qualify the first field with the full module path so the record type resolves
+  // at the `Dict.fromArray([...])` call site (type-directed disambiguation does not
+  // propagate through the tuple/dict, so a bare `{memorySize, …}` has no type in scope).
+  "{ReventlessInfra.RuntimeHints.memorySize: " ++
+  optInt(h.memorySize) ++
+  ", timeout: " ++
+  optInt(h.timeout) ++ "}"
+}
+
+// Every component name reachable from the resolved plugin — the valid keys for
+// the plugin.json `runtime` block. Mirrors the module names emitted above.
+let collectComponentNames = (resolved: Pairing.resolved): array<string> =>
+  Array.flat([
+    resolved.aggregates->Array.map(({spec}) => spec),
+    resolved.readModels->Array.map(({readModel}) => readModel),
+    resolved.stateChangeSlices,
+    resolved.stateViewSlices,
+    resolved.stateViewSlicesStream,
+    resolved.automationSlices,
+    resolved.outboundTranslationSlices,
+    resolved.inboundTranslationSlices,
+    resolved.tasks,
+    resolved.extensions,
+    resolved.extensionPoints->Array.map(({group, mappings}) =>
+      switch group {
+      | Some(g) => g
+      | None => epModuleName(mappings->Array.getUnsafe(0))
+      }
+    ),
+  ])
+
+// Typo protection: a `runtime` key that names no component is a warning, not a
+// silent no-op. The override is still emitted (harmless — the deploy loop simply
+// never looks it up).
+let validateComponentRuntimeKeys = (
+  ~resolved: Pairing.resolved,
+  ~componentRuntime: dict<Config.runtimeHints>,
+): unit => {
+  let known = collectComponentNames(resolved)
+  componentRuntime
+  ->Dict.keysToArray
+  ->Array.forEach(name =>
+    if !(known->Array.includes(name)) {
+      Console.warn(
+        "Generator: plugin.json `runtime` override for `" ++
+        name ++
+        "` matches no component in this plugin. Known components: " ++
+        known->Array.join(", "),
+      )
+    }
+  )
+}
+
+let renderComponentRuntimeParam = (
+  componentRuntime: dict<Config.runtimeHints>,
+): option<string> => {
+  let entries = componentRuntime->Dict.toArray
+  if entries->Array.length === 0 {
+    None
+  } else {
+    let rendered =
+      entries
+      ->Array.map(((name, hints)) => "(\"" ++ name ++ "\", " ++ renderRuntimeHints(hints) ++ ")")
+      ->Array.join(", ")
+    Some("      ~componentRuntime=Dict.fromArray([" ++ rendered ++ "]),")
+  }
+}
+
 let renderTaskMakeParam = (tasks: array<string>): option<string> =>
   if tasks->Array.length === 0 {
     None
@@ -705,8 +785,14 @@ let renderComposition = (
           ->Array.join(", ") ++ "],",
         )
       : None,
+    // Per-component runtime hints from plugin.json `runtime` (only emitted when
+    // present, so plugins without one keep a byte-identical generated Plugin.res).
+    renderComponentRuntimeParam(config.componentRuntime),
   ]
 
+  // Typo protection: warn on `runtime` keys that name no discovered component.
+  validateComponentRuntimeKeys(~resolved, ~componentRuntime=config.componentRuntime)
+
   makeParams->Array.filterMap(x => x)->Array.forEach(line => lines->Array.push(line))
   switch uiFragmentsParam {
   | Some(uiLines) => uiLines->Array.forEach(line => lines->Array.push(line))

package/src/generator/Codegen.res.mjs

@@ -178,6 +178,59 @@ function renderExtensionMakeParam(extensions) {
   return "      ~extensions=[" + entries.join(", ") + "],";
 }
 
+function renderRuntimeHints(h) {
+  let optInt = o => {
+    if (o !== undefined) {
+      return "Some(" + o.toString() + ")";
+    } else {
+      return "None";
+    }
+  };
+  return "{ReventlessInfra.RuntimeHints.memorySize: " + optInt(h.memorySize) + ", timeout: " + optInt(h.timeout) + "}";
+}
+
+function collectComponentNames(resolved) {
+  return [
+    resolved.aggregates.map(param => param.spec),
+    resolved.readModels.map(param => param.readModel),
+    resolved.stateChangeSlices,
+    resolved.stateViewSlices,
+    resolved.stateViewSlicesStream,
+    resolved.automationSlices,
+    resolved.outboundTranslationSlices,
+    resolved.inboundTranslationSlices,
+    resolved.tasks,
+    resolved.extensions,
+    resolved.extensionPoints.map(param => {
+      let group = param.group;
+      if (group !== undefined) {
+        return group;
+      } else {
+        return stripSuffix(param.mappings[0], "Mapping");
+      }
+    })
+  ].flat();
+}
+
+function validateComponentRuntimeKeys(resolved, componentRuntime) {
+  let known = collectComponentNames(resolved);
+  Object.keys(componentRuntime).forEach(name => {
+    if (!known.includes(name)) {
+      console.warn("Generator: plugin.json `runtime` override for `" + name + "` matches no component in this plugin. Known components: " + known.join(", "));
+      return;
+    }
+  });
+}
+
+function renderComponentRuntimeParam(componentRuntime) {
+  let entries = Object.entries(componentRuntime);
+  if (entries.length === 0) {
+    return;
+  }
+  let rendered = entries.map(param => "(\"" + param[0] + "\", " + renderRuntimeHints(param[1]) + ")").join(", ");
+  return "      ~componentRuntime=Dict.fromArray([" + rendered + "]),";
+}
+
 function renderTaskMakeParam(tasks) {
   if (tasks.length === 0) {
     return;
@@ -438,8 +491,10 @@ function renderComposition(config, resolved, componentChapters) {
     renderMakeParam("outboundTranslationSlices", resolved.outboundTranslationSlices, "Slice"),
     renderMakeParam("inboundTranslationSlices", resolved.inboundTranslationSlices, "Slice"),
     hasPluginStructure ? "      ~pluginStructure=pluginStructure," : undefined,
-    resolved.systemCallableComponents.length !== 0 ? "      ~systemCallableComponents=[" + resolved.systemCallableComponents.map(n => "\"" + n + "\"").join(", ") + "]," : undefined
+    resolved.systemCallableComponents.length !== 0 ? "      ~systemCallableComponents=[" + resolved.systemCallableComponents.map(n => "\"" + n + "\"").join(", ") + "]," : undefined,
+    renderComponentRuntimeParam(config.componentRuntime)
   ];
+  validateComponentRuntimeKeys(resolved, config.componentRuntime);
   Stdlib_Array.filterMap(makeParams, x => x).forEach(line => {
     lines.push(line);
   });
@@ -493,6 +548,10 @@ export {
   renderAggregateMakeParam,
   renderEpMakeParam,
   renderExtensionMakeParam,
+  renderRuntimeHints,
+  collectComponentNames,
+  validateComponentRuntimeKeys,
+  renderComponentRuntimeParam,
   renderTaskMakeParam,
   renderPluginStructureCall,
   validateUniqueSpecStems,

package/src/generator/Config.res

@@ -3,10 +3,22 @@
 
 type variant = Composition | Aws({compositionNamespace: string})
 
+// Per-component runtime resource hints, parsed from the optional `runtime`
+// block in plugin.json and keyed by component name. Both fields are optional;
+// an omitted field falls through to the per-kind builder default. See
+// docs/plans/configurable-component-runtime-resources.md.
+type runtimeHints = {
+  memorySize: option<int>,
+  timeout: option<int>,
+}
+
 type config = {
   name: string,
   heartbeatInterval: int,
   exclude: array<string>,
+  // Keyed by component name (e.g. "Customers", "PlaceOrder"). Empty when the
+  // plugin.json has no `runtime` block.
+  componentRuntime: dict<runtimeHints>,
   variant: variant,
 }
 
@@ -41,6 +53,31 @@ let getStrArrayField = (json: JSON.t, key: string): option<array<string>> =>
   ->Option.flatMap(JSON.Decode.array)
   ->Option.map(arr => arr->Array.filterMap(JSON.Decode.string))
 
+// Parse the optional `runtime` object: each key is a component name, each value
+// an object with optional `memorySize` / `timeout` ints. A missing block yields
+// an empty dict; a non-object entry is skipped.
+let getComponentRuntime = (json: JSON.t): dict<runtimeHints> => {
+  let result: dict<runtimeHints> = Dict.make()
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("runtime"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.forEach(runtimeObj =>
+    runtimeObj
+    ->Dict.toArray
+    ->Array.forEach(((componentName, entry)) =>
+      result->Dict.set(
+        componentName,
+        {
+          memorySize: getIntField(entry, "memorySize"),
+          timeout: getIntField(entry, "timeout"),
+        },
+      )
+    )
+  )
+  result
+}
+
 let read = (~srcDir: string): config => {
   // Read package.json `name` from the parent of srcDir
   let packageJsonPath = Generator_Node.join([Generator_Node.dirname(srcDir), "package.json"])
@@ -63,6 +100,7 @@ let read = (~srcDir: string): config => {
     ->Option.flatMap(j => getIntField(j, "heartbeatInterval"))
     ->Option.getOr(5),
     exclude: pluginJson->Option.flatMap(j => getStrArrayField(j, "exclude"))->Option.getOr([]),
+    componentRuntime: pluginJson->Option.map(getComponentRuntime)->Option.getOr(Dict.make()),
     variant: Composition,
   }
 }

package/src/generator/Config.res.mjs

@@ -27,6 +27,20 @@ function getStrArrayField(json, key) {
   return Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.array), arr => Stdlib_Array.filterMap(arr, Stdlib_JSON.Decode.string));
 }
 
+function getComponentRuntime(json) {
+  let result = {};
+  Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["runtime"]), Stdlib_JSON.Decode.object), runtimeObj => {
+    Object.entries(runtimeObj).forEach(param => {
+      let entry = param[1];
+      result[param[0]] = {
+        memorySize: getIntField(entry, "memorySize"),
+        timeout: getIntField(entry, "timeout")
+      };
+    });
+  });
+  return result;
+}
+
 function read(srcDir) {
   let packageJsonPath = Nodepath.join(Nodepath.dirname(srcDir), "package.json");
   let packageJsonName = Stdlib_Option.flatMap(readJson(packageJsonPath), j => getStrField(j, "name"));
@@ -36,6 +50,7 @@ function read(srcDir) {
     name: PluginName$Reventless.resolve(Stdlib_Option.flatMap(pluginJson, j => getStrField(j, "name")), packageJsonName),
     heartbeatInterval: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getIntField(j, "heartbeatInterval")), 5),
     exclude: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getStrArrayField(j, "exclude")), []),
+    componentRuntime: Stdlib_Option.getOr(Stdlib_Option.map(pluginJson, getComponentRuntime), {}),
     variant: "Composition"
   };
 }
@@ -48,6 +63,7 @@ export {
   getStrField,
   getIntField,
   getStrArrayField,
+  getComponentRuntime,
   read,
 }
 /* node:fs Not a pure module */

package/src/generator/PluginGenerator.res.mjs

@@ -46,10 +46,12 @@ if (srcDirArg === "") {
   let config_name = init.name;
   let config_heartbeatInterval = init.heartbeatInterval;
   let config_exclude = init.exclude;
+  let config_componentRuntime = init.componentRuntime;
   let config = {
     name: config_name,
     heartbeatInterval: config_heartbeatInterval,
     exclude: config_exclude,
+    componentRuntime: config_componentRuntime,
     variant: variant
   };
   let discovered = Discovery$Reventless.scan(srcDir, config_exclude);