@reventlessdev/reventless-core 3.0.0-alpha.180 → 3.0.0-alpha.181

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs

@@ -59,7 +59,11 @@ function Make(Spec) {
             };
             return {
               TAG: "Ok",
-              _0: []
+              _0: {
+                requestId: requestId,
+                targetIds: [],
+                commandCount: 0
+              }
             };
           }
           let msgs = {
@@ -101,7 +105,10 @@ function Make(Spec) {
             };
             return {
               TAG: "Error",
-              _0: msg$1
+              _0: {
+                requestId: requestId,
+                error: msg$1
+              }
             };
           }
           try {
@@ -116,7 +123,11 @@ function Make(Spec) {
             };
             return {
               TAG: "Ok",
-              _0: targetIds
+              _0: {
+                requestId: requestId,
+                targetIds: targetIds,
+                commandCount: pairs$1.length
+              }
             };
           } catch (raw_exn$1) {
             let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
@@ -129,7 +140,10 @@ function Make(Spec) {
             };
             return {
               TAG: "Error",
-              _0: msg$2
+              _0: {
+                requestId: requestId,
+                error: msg$2
+              }
             };
           }
         } else {
@@ -142,7 +156,10 @@ function Make(Spec) {
           };
           return {
             TAG: "Error",
-            _0: msg$3
+            _0: {
+              requestId: requestId,
+              error: msg$3
+            }
           };
         }
       } else {
@@ -155,7 +172,10 @@ function Make(Spec) {
         };
         return {
           TAG: "Error",
-          _0: msg$4
+          _0: {
+            requestId: requestId,
+            error: msg$4
+          }
         };
       }
     };

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res

@@ -3,8 +3,6 @@
 //
 // Follows the AutomationSlice_Builder pattern for adapter injection.
 
-let log = Logger.fromEnv()
-
 module Make = (
   RuntimeEnvironment: Runtime.Environment,
   QueryDbStorage: QueryDb_Adapter.Storage,
@@ -80,18 +78,25 @@ module Make = (
       )
 
       let dcbEventTopicOutputs: EventTopic.outputs = (dcbEventLog->Component.outputs).eventTopic
-      let allEventTopics = Dict.fromArray([(Spec.name, dcbEventTopicOutputs)])
-
-      // Resolve publishJsons so it's available for Phase 2
-      let publishJsonsRef: ref<option<ReventlessInfra.CommandTopic.publishJsons>> = ref(None)
-      let _ = publishJsons->Pulumi.Output.apply(pj => {
-        publishJsonsRef := Some(pj)
-      })
-
+      // Key the topic by the source-name convention AutomationSlice and
+      // Dcb_Builder use (`<pluginName>DcbEventLog`) rather than by this slice's
+      // own name. No backend routes on the key — local subscribes on
+      // `resource.name`, AWS reads `Dict.valuesToArray` — but channel specs are
+      // merged with `Dict.assign`, so slice-specific keys make one topic appear
+      // once per slice instead of collapsing to a single entry.
+      let dcbEventLogName =
+        (dcbEventLog->Component.toPulumiResource).name->Option.getOr("") ++ "DcbEventLog"
+      let allEventTopics = Dict.fromArray([(dcbEventLogName, dcbEventTopicOutputs)])
+
+      // Build the EventCollector inside an Output.all2 so both `queryDbOps` and
+      // `publishJsonsFn` are captured in the same closure. The jsonEventsHandler
+      // then has direct access to `publishJsonsFn` — avoids racing a
+      // side-effect-only `publishJsons.apply` against the first event arrival
+      // (which silently dropped Phase 2 in the AutomationSlice's previous shape).
       let eventCollector =
-        queryDb
-        ->Component.operations
-        ->Pulumi.Output.apply(queryDbOps => {
+        (queryDb->Component.operations, publishJsons)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((queryDbOps, publishJsonsFn)) => {
           let ec = SpecificEventCollector.make(
             ~name=Spec.name,
             ~eventTopics=allEventTopics,
@@ -104,7 +109,17 @@ module Make = (
             ->Stream.mapEffect(json =>
               Effect.sync(
                 () => {
-                  let (eventType, dataDict) = json->Message.splitMessage
+                  // Events arrive as `{id, meta, event}` envelopes (see
+                  // Message.composeEventJson'). The decoder works on the inner
+                  // `event` payload — TAG + fields at the top level — not the
+                  // wrapper. Splitting the wrapper yields eventType "Unknown",
+                  // which DcbDecode drops without warning.
+                  let rawEvent =
+                    json
+                    ->JSON.Decode.object
+                    ->Option.flatMap(d => d->Dict.get("event"))
+                    ->Option.getOr(json)
+                  let (eventType, dataDict) = rawEvent->Message.splitMessage
                   switch decoder.decode(~eventType, ~data=dataDict) {
                   | Some(event) => [event]
                   | None => []
@@ -126,29 +141,21 @@ module Make = (
                   // an inbound command whose downstream events fan back to this
                   // same topic, awaiting would self-deadlock the bus — same
                   // shape as AutomationSlice. Detach it; errors are logged.
-                  switch publishJsonsRef.contents {
-                  | Some(pj) =>
-                    let _ =
-                      Callback.phase2(pj)
-                      ->Promise.then(() => syncToQueryDb(queryDbOps))
-                      ->Promise.catch(exn => {
-                        let errMsg =
-                          exn
-                          ->JsExn.fromException
-                          ->Option.flatMap(JsExn.message)
-                          ->Option.getOr("unknown")
-                        EffectLogger.logError(
-                          ~comp=`OutboundTranslationSlice(${Spec.name})`,
-                          `detached phase 2 error: ${errMsg}`,
-                        )->Effect.runSync
-                        Promise.resolve()
-                      })
-                  | None =>
-                    log.error(
-                      ~comp=`OutboundTranslationSlice(${Spec.name})`,
-                      `publishJsons not yet resolved`,
-                    )
-                  }
+                  let _ =
+                    Callback.phase2(publishJsonsFn)
+                    ->Promise.then(() => syncToQueryDb(queryDbOps))
+                    ->Promise.catch(exn => {
+                      let errMsg =
+                        exn
+                        ->JsExn.fromException
+                        ->Option.flatMap(JsExn.message)
+                        ->Option.getOr("unknown")
+                      EffectLogger.logError(
+                        ~comp=`OutboundTranslationSlice(${Spec.name})`,
+                        `detached phase 2 error: ${errMsg}`,
+                      )->Effect.runSync
+                      Promise.resolve()
+                    })
                 },
               )
             )

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 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 Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
@@ -13,7 +14,6 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
-import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
@@ -24,8 +24,6 @@ import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventC
 import * as OutboundTranslationSlice$ReventlessCore from "./OutboundTranslationSlice.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "./OutboundTranslationSlice_Callback.res.mjs";
 
-let log = Logger$ReventlessCore.fromEnv();
-
 function Make(RuntimeEnvironment) {
   return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => {
     let Make = Spec => (Translation => {
@@ -64,23 +62,24 @@ function Make(RuntimeEnvironment) {
           name: Spec.name
         }, opts);
         let dcbEventTopicOutputs = Component$ReventlessCore.outputs(dcbEventLog).eventTopic;
+        let dcbEventLogName = Stdlib_Option.getOr(Component$ReventlessCore.toPulumiResource(dcbEventLog).__name, "") + "DcbEventLog";
         let allEventTopics = Object.fromEntries([[
-            Spec.name,
+            dcbEventLogName,
             dcbEventTopicOutputs
           ]]);
-        let publishJsonsRef = {
-          contents: undefined
-        };
-        publishJsons.apply(pj => {
-          publishJsonsRef.contents = pj;
-        });
-        let eventCollector = Component$ReventlessCore.operations(queryDb).apply(queryDbOps => {
+        let eventCollector = Pulumi.all([
+          Component$ReventlessCore.operations(queryDb),
+          publishJsons
+        ]).apply(param => {
+          let publishJsonsFn = param[1];
+          let queryDbOps = param[0];
           let ec = SpecificEventCollector.make(Spec.name, allEventTopics, {
             kind: "OutboundTranslationSlice",
             name: Spec.name
           }, opts);
           let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(Stream$1.flatMap(Stream$1.mapEffect(stream, json => Effect.sync(() => {
-            let match = Message$ReventlessCore.splitMessage(json);
+            let rawEvent = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["event"]), json);
+            let match = Message$ReventlessCore.splitMessage(rawEvent);
             let event = decoder.decode(match[0], match[1]);
             if (event !== undefined) {
               return [Primitive_option.valFromOption(event)];
@@ -90,17 +89,11 @@ function Make(RuntimeEnvironment) {
           })), events => Stream$1.fromIterable(events))), eventsArr => Effect.promise(async () => {
             Callback.phase1(eventsArr);
             await syncToQueryDb(queryDbOps);
-            let pj = publishJsonsRef.contents;
-            if (pj !== undefined) {
-              Stdlib_Promise.$$catch(Callback.phase2(pj).then(() => syncToQueryDb(queryDbOps)), exn => {
-                let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
-                Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `detached phase 2 error: ` + errMsg));
-                return Promise.resolve();
-              });
-              return;
-            } else {
-              return log.error(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `publishJsons not yet resolved`);
-            }
+            Stdlib_Promise.$$catch(Callback.phase2(publishJsonsFn).then(() => syncToQueryDb(queryDbOps)), exn => {
+              let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+              Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `detached phase 2 error: ` + errMsg));
+              return Promise.resolve();
+            });
           }));
           let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
           let resources = Component$ReventlessCore.outputs(queryDb).resources;
@@ -140,7 +133,6 @@ function Make(RuntimeEnvironment) {
 }
 
 export {
-  log,
   Make,
 }
-/* log Not a pure module */
+/* Stream Not a pure module */

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -227,6 +227,18 @@ module Make = (
     // only the delta the conflicting writer added rather than full history.
     let seed = ref(cacheGet())
 
+    // One hit/miss sample per command, keyed on whether the warm-instance cache
+    // seeded this command's decision read. If Miss dominates Hit for a slice, the
+    // flat-capacity cache is thrashing a wide entity set — the operator's cue to
+    // disable it. Paired with DcbDecisionModelDeltaEventCount (the delta size a
+    // hit actually read); both consumed by the reventless-aws metric filters.
+    Metrics.emitCount(
+      ~metric=seed.contents->Option.isSome
+        ? "DcbDecisionModelCacheHit"
+        : "DcbDecisionModelCacheMiss",
+      ~slice=Spec.name,
+    )
+
     let rec attempt = (~retries) => {
       let (baseState, afterPos) = switch seed.contents {
       | Some((state, head)) => (state, head)
@@ -279,14 +291,27 @@ module Make = (
           },
         ]),
       ))
-      ->Effect.tap(((_, _, reads)) =>
+      ->Effect.tap(((_, _, reads)) => {
+        // On a warm first attempt, record how many events the delta read
+        // returned — near-zero on a healthy hit; a large value means the entity
+        // churned between commands, so the cache saved little. Gated to the first
+        // attempt (retries at maxRetries) so each command yields at most one
+        // sample, aligned 1:1 with a CacheHit. Conflict-driven retry reads are
+        // covered by AppendRetry instead.
+        if cacheHit && retries == maxRetries {
+          Metrics.emitCount(
+            ~metric="DcbDecisionModelDeltaEventCount",
+            ~slice=Spec.name,
+            ~value=reads->Array.length,
+          )
+        }
         EffectLogger.logInfo(
           ~comp,
           `read${cacheHit ? " (cached, delta)" : ""}: ${reads->Array.length->Int.toString} event(s)${reads->Array.length == 0
               ? ""
               : ` [${reads->Array.join(", ")}]`}`,
         )
-      )
+      })
       ->Effect.flatMap(((state, headPosition, _)) =>
         EffectLogger.logDebug(
           ~comp,

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -101,6 +101,7 @@ function Make(Spec) {
       let seed = {
         contents: cacheGet()
       };
+      Metrics$ReventlessCore.emitCount(Stdlib_Option.isSome(seed.contents) ? "DcbDecisionModelCacheHit" : "DcbDecisionModelCacheMiss", Spec.name, undefined);
       let attempt = retries => {
         let match = seed.contents;
         let match$1 = match !== undefined ? [
@@ -152,6 +153,9 @@ function Make(Spec) {
           ];
         }), param => {
           let reads = param[2];
+          if (cacheHit && retries === 3) {
+            Metrics$ReventlessCore.emitCount("DcbDecisionModelDeltaEventCount", Spec.name, reads.length);
+          }
           return EffectLogger$ReventlessCore.logInfo(comp, undefined, `read` + (
             cacheHit ? " (cached, delta)" : ""
           ) + `: ` + reads.length.toString() + ` event(s)` + (

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -95,16 +95,30 @@ module Make = (
               let total = events->Array.length->Int.toString
               events
               ->Array.mapWithIndex((json, i) => {
-                let rawEvent =
-                  json
-                  ->JSON.Decode.object
-                  ->Option.flatMap(d => d->Dict.get("event"))
-                  ->Option.getOr(json)
+                let envelopeDict = json->JSON.Decode.object->Option.getOr(Dict.make())
+                let rawEvent = envelopeDict->Dict.get("event")->Option.getOr(json)
+                // Events arrive as `{id, meta, recordedAt, event}` envelopes
+                // (Message.composeEventJson' / ProjectionCheckpoint catch-up).
+                // Surface `meta` + `recordedAt` to the projection as `consumed`;
+                // fall back defensively so a malformed envelope never drops the event.
+                let meta = switch envelopeDict->Dict.get("meta") {
+                | Some(m) =>
+                  switch m->S.parseJsonOrThrow(Message.metaSchema) {
+                  | parsed => parsed
+                  | exception _ => Message.generateMeta(~service=Spec.name)
+                  }
+                | None => Message.generateMeta(~service=Spec.name)
+                }
+                let recordedAt =
+                  envelopeDict
+                  ->Dict.get("recordedAt")
+                  ->Option.flatMap(JSON.Decode.string)
+                  ->Option.getOr("")
                 let (eventType, dataDict) = rawEvent->Message.splitMessage
                 switch decoder.decode(~eventType, ~data=dataDict) {
                 | Some(event) =>
                   let actions =
-                    try Projection.project(event)
+                    try Projection.project({event, meta, recordedAt})
                     catch {
                     | exn =>
                       let errMsg =

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -80,7 +81,20 @@ function Make(RuntimeEnvironment) {
           let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(stream), events => {
             let total = events.length.toString();
             return Stdlib_Array.reduce(events.map((json, i) => {
-              let rawEvent = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["event"]), json);
+              let envelopeDict = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(json), {});
+              let rawEvent = Stdlib_Option.getOr(envelopeDict["event"], json);
+              let m = envelopeDict["meta"];
+              let meta;
+              if (m !== undefined) {
+                try {
+                  meta = S.parseJsonOrThrow(m, Message$ReventlessCore.metaSchema);
+                } catch (exn) {
+                  meta = Message$ReventlessCore.generateMeta(Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+                }
+              } else {
+                meta = Message$ReventlessCore.generateMeta(Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+              }
+              let recordedAt = Stdlib_Option.getOr(Stdlib_Option.flatMap(envelopeDict["recordedAt"], Stdlib_JSON.Decode.string), "");
               let match = Message$ReventlessCore.splitMessage(rawEvent);
               let dataDict = match[1];
               let eventType = match[0];
@@ -90,10 +104,14 @@ function Make(RuntimeEnvironment) {
               }
               let actions;
               try {
-                actions = Projection.project(Primitive_option.valFromOption(event));
+                actions = Projection.project({
+                  event: Primitive_option.valFromOption(event),
+                  meta: meta,
+                  recordedAt: recordedAt
+                });
               } catch (raw_exn) {
-                let exn = Primitive_exceptions.internalToException(raw_exn);
-                let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+                let exn$1 = Primitive_exceptions.internalToException(raw_exn);
+                let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");
                 Effect.runSync(EffectLogger$ReventlessCore.logError(comp, undefined, `project failed for ` + eventType + `: ` + errMsg));
                 actions = [];
               }
@@ -140,4 +158,4 @@ export {
   FrameworkProjection,
   Make,
 }
-/* Stream Not a pure module */
+/* S Not a pure module */

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -40,7 +40,7 @@ module Make = (
       | Some(event) =>
         idx := idx.contents + 1
         let id = raw.tags->Array.get(0)->Option.map(tag => tag.value)->Option.getOr("?")
-        let actions = Projection.project(event)
+        let actions = Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})
         let actionsStr = LogFormat.actionNames(actions)
         EffectLogger.logInfo(
           ~comp,

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -28,7 +28,11 @@ function Make(Spec) {
         let event = Primitive_option.valFromOption(decoded);
         idx.contents = idx.contents + 1 | 0;
         let id = Stdlib_Option.getOr(Stdlib_Option.map(raw.tags[0], tag => tag.value), "?");
-        let actions = Projection.project(event);
+        let actions = Projection.project({
+          event: event,
+          meta: raw.meta,
+          recordedAt: raw.recordedAt
+        });
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
         allActions.push(...actions);

package/src/plugin/component/Plugin_Helpers.res

@@ -932,7 +932,10 @@ type platformHooks = {
   // InboundTranslationSlice — phase 1: register SDL + stub.
   inboundMutationResolverHook?: (~fieldName: string, ~externalInputSchema: S.t<unknown>) => unit,
   // InboundTranslationSlice — phase 2: bind receive.
-  inboundMutationBindReceiveHook?: (~fieldName: string, ~receive: JSON.t => promise<result<array<string>, string>>) => unit,
+  inboundMutationBindReceiveHook?: (
+    ~fieldName: string,
+    ~receive: JSON.t => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
+  ) => unit,
   // GraphQL type definitions.
   schemaTypeRegistrationHook?: array<string> => unit,
   // Subscription infrastructure (AWS): wire StateTopic + EventLogSubscription Lambdas.

package/src/plugin/component/Plugin_Structure.res

@@ -171,6 +171,10 @@ let make = (
       // markAllowedStates). Look it up by variant name; back-compat
       // None when the variant lacks an @allowedStates annotation.
       let allowedStates = ApiAllowedStatesHelpers.getAllowedStates(parentSchema, ~variantName)
+      // Declared `@targetState` (the command's *to* status), read the same way
+      // as allowedStates. None ⇒ AutoUI's board resolver falls back to its
+      // name-stem heuristic.
+      let targetState = ApiTargetStateHelpers.getTargetState(parentSchema, ~variantName)
       // API-exposed iff the whole command isn't @noApi and this variant
       // isn't in its @noApi-variants set — mirrors the API-generation filter
       // (Plugin_Helpers / PluginBaseFragment). Drives the event-graph API badge.
@@ -185,9 +189,19 @@ let make = (
         schema: (v->S.toJSONSchema->Obj.magic: JSON.t)->JSON.stringify,
         level,
         aggregateIdField,
-        mutationField: mutationFieldFor(variantName),
+        // A non-exposed (`@noApi`) variant has no callable mutation field. For a
+        // single-exposed-command slice, `mutationFieldFor` resolves *every*
+        // variant — including the `@noApi` one — to the slice's one mutation
+        // field, so emitting it here would hand the non-exposed variant a
+        // sibling's callable-looking field (e.g. `ReopenOrder` →
+        // `Ordering_CancelOrder`). Emit an empty sentinel instead; the variant
+        // stays listed with `apiExposed: false` for the event-graph badge, but
+        // no consumer can mistake it for a callable field. Exposed variants are
+        // byte-identical.
+        mutationField: apiExposed ? mutationFieldFor(variantName) : "",
         references,
         allowedStates,
+        targetState,
         apiExposed: Some(apiExposed),
       }: Reventless.Plugin.commandDef)
     }

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

@@ -13,6 +13,7 @@ import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../../components/Api/SuryToJsonSchema.res.mjs";
+import * as ApiTargetStateHelpers$ReventlessCore from "../../components/Api/ApiTargetStateHelpers.res.mjs";
 import * as ApiAllowedStatesHelpers$ReventlessCore from "../../components/Api/ApiAllowedStatesHelpers.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -147,6 +148,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
         }));
       });
       let allowedStates = ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName);
+      let targetState = ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName);
       let apiExposed = false;
       if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
         let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
@@ -157,9 +159,10 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
         schema: JSON.stringify(S.toJSONSchema(v)),
         level: match[0],
         aggregateIdField: match[1],
-        mutationField: mutationFieldFor(variantName),
+        mutationField: apiExposed ? mutationFieldFor(variantName) : "",
         references: references,
         allowedStates: allowedStates,
+        targetState: targetState,
         apiExposed: apiExposed
       };
     };

package/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs

@@ -46,6 +46,8 @@ let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stat
   collapsed: [],
   scan: ["kind"],
   scanSort: [],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: "kind",
   visibility: undefined