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

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.181 (2026-07-26)
+
+### Bug Fixes
+
+* **auto-ui:** don't hand a [@no](https://github.com/no)Api command variant a sibling's mutation field ([2640465](https://github.com/ReventlessDev/reventless-core/commit/264046509c5f5fd7f00f5d04ab977bbc2008098c)), closes [#2](https://github.com/ReventlessDev/reventless-core/issues/2)
+* **core:** decode the event envelope in OutboundTranslationSlice ([66008a4](https://github.com/ReventlessDev/reventless-core/commit/66008a4dff411c85470f60aac5424e7b3eda6f01))
+* **graphql:** give InboundTranslationSlice mutations a resolvable result type ([381b545](https://github.com/ReventlessDev/reventless-core/commit/381b5458c16797404cb8ed95fa853fb1e1ca4199))
+### Features
+
+* **auto-ui:** declare command target state via [@target](https://github.com/target)State ([5fc0374](https://github.com/ReventlessDev/reventless-core/commit/5fc03741a8816c57085b86a4ad7d595e3b690193)), closes [#5](https://github.com/ReventlessDev/reventless-core/issues/5)
+* **auto-ui:** declare field semantics + dashboard metrics ([@semantic](https://github.com/semantic), [@metric](https://github.com/metric)) ([d74ff77](https://github.com/ReventlessDev/reventless-core/commit/d74ff7721e18e8638a82931a370a549b304dac94)), closes [#4](https://github.com/ReventlessDev/reventless-core/issues/4)
+* **dcb:** emit decision-model cache hit/miss + delta metrics ([967fb7f](https://github.com/ReventlessDev/reventless-core/commit/967fb7fb42f00d22b9dd6f6261e2f5308a6e9516))
+
+
+# 3.0.0-alpha.180 (2026-07-24)
+
+### Features
+
+* **core:** Monitoring seam announces owning plugin/platform to backends ([79dd49a](https://github.com/ReventlessDev/reventless-core/commit/79dd49ae29feb95ed88c836cd8827c8e68978889))
+
+
 # 3.0.0-alpha.179 (2026-07-23)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.179",
+  "version": "3.0.0-alpha.181",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@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-node-streams": "1.1.0-alpha.13",
-    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@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.104",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.80"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.81"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.54"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.56"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Message.res

@@ -257,10 +257,11 @@ let decomposeMeta = meta =>
   ->Option.getOrThrow
   ->Dict.toArray
 
-let composeEventJson' = (id, meta, eventJson) =>
+let composeEventJson' = (id, meta, ~recordedAt, eventJson) =>
   [
     ("id", id->JSON.Encode.string),
     ("meta", meta->S.reverseConvertToJsonOrThrow(metaSchema)),
+    ("recordedAt", recordedAt->JSON.Encode.string),
     ("event", eventJson),
   ]
   ->Dict.fromArray

package/src/Message.res.mjs

@@ -203,7 +203,7 @@ function decomposeMeta(meta) {
   return Object.entries(Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)), undefined));
 }
 
-function composeEventJson$p(id, meta, eventJson) {
+function composeEventJson$p(id, meta, recordedAt, eventJson) {
   return Object.fromEntries([
     [
       "id",
@@ -213,6 +213,10 @@ function composeEventJson$p(id, meta, eventJson) {
       "meta",
       S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
     ],
+    [
+      "recordedAt",
+      recordedAt
+    ],
     [
       "event",
       eventJson

package/src/adapter/Monitoring/Monitoring.res

@@ -58,18 +58,26 @@ FunctionName or a PrometheusRule deployment selector, but unusable as a logical
 resource name). Because `onProvisioned` fires during resource creation inside the
 deploy program, a Pulumi-based backend can create monitoring resources in the
 same stack, parented naturally.
+
+`~plugin` / `~platform` are the OWNING plugin and platform of the unit, taken from the ambient
+`ResourceAttribution` context the plugin builder publishes during construction (the same source
+`AWS_Tags` uses). Both are `None` for substrate provisioned outside any plugin construct — the
+correct answer for platform-scope resources. A backend that names or routes its monitoring resources
+per plugin needs this: `~name` is only the component, and two plugins can own like-named components.
 */
 module type Backend = {
   let onProvisioned: (
     ~kind: unitKind,
     ~name: string,
     ~component: ReventlessInfra.Adapter.resource,
+    ~plugin: option<string>,
+    ~platform: option<string>,
   ) => unit
 }
 
 /** Default backend: does nothing. Active unless an extension calls `use`. */
 module Noop: Backend = {
-  let onProvisioned = (~kind as _, ~name as _, ~component as _) => ()
+  let onProvisioned = (~kind as _, ~name as _, ~component as _, ~plugin as _, ~platform as _) => ()
 }
 
 let backend: ref<module(Backend)> = ref(module(Noop: Backend))
@@ -92,5 +100,9 @@ let notify = (
   ~component: ReventlessInfra.Adapter.resource,
 ) => {
   module B = unpack(backend.contents)
-  B.onProvisioned(~kind, ~name, ~component)
+  // The owning plugin/platform come from the ambient context the plugin builder publishes
+  // (ResourceAttribution.enter) — populated exactly when this fires, so the call sites need not
+  // thread the names. `None` outside a plugin construct (platform substrate).
+  let {ResourceAttribution.plugin: plugin, platform} = ResourceAttribution.current.contents
+  B.onProvisioned(~kind, ~name, ~component, ~plugin, ~platform)
 }

package/src/adapter/Monitoring/Monitoring.res.mjs

@@ -1,7 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.res.mjs";
 
-function onProvisioned(param, param$1, param$2) {
+function onProvisioned(param, param$1, param$2, param$3, param$4) {
   
 }
 
@@ -19,7 +20,8 @@ function use(b) {
 
 function notify(kind, name, component) {
   let B = backend.contents;
-  B.onProvisioned(kind, name, component);
+  let match = ResourceAttribution$ReventlessCore.current.contents;
+  B.onProvisioned(kind, name, component, match.plugin, match.platform);
 }
 
 export {

package/src/admin/Platform_Admin_Structure.res

@@ -74,6 +74,7 @@ let activateCommand: commandDef = {
   mutationField: Api_Naming.adminField(~name="Plugin_Activate"),
   references: [],
   allowedStates: Some(["Inactive"]),
+  targetState: None,
   apiExposed: Some(true),
 }
 
@@ -85,6 +86,7 @@ let deactivateCommand: commandDef = {
   mutationField: Api_Naming.adminField(~name="Plugin_Deactivate"),
   references: [],
   allowedStates: Some(["Connected", "Disconnected"]),
+  targetState: None,
   apiExposed: Some(true),
 }
 

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -61,6 +61,7 @@ let activateCommand = {
   mutationField: activateCommand_mutationField,
   references: activateCommand_references,
   allowedStates: activateCommand_allowedStates,
+  targetState: undefined,
   apiExposed: activateCommand_apiExposed
 };
 
@@ -87,6 +88,7 @@ let deactivateCommand = {
   mutationField: deactivateCommand_mutationField,
   references: deactivateCommand_references,
   allowedStates: deactivateCommand_allowedStates,
+  targetState: undefined,
   apiExposed: deactivateCommand_apiExposed
 };
 

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -8,7 +8,7 @@ open Reventless.Plugin
 
 let sdlTypes: array<string> = [
   `type Platform_FieldReference {\n  fieldName: String!\n  entity: String!\n  plugin: String\n}`,
-  `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  apiExposed: Boolean\n}`,
+  `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}`,
@@ -54,6 +54,7 @@ let encodeCommandDef = (c: commandDef): JSON.t =>
       "allowedStates",
       c.allowedStates->Option.mapOr(JSON.Encode.null, encodeStrings),
     ),
+    ("targetState", c.targetState->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
     ("apiExposed", c.apiExposed->Option.mapOr(JSON.Encode.null, JSON.Encode.bool)),
   ])->JSON.Encode.object
 

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -6,7 +6,7 @@ import * as Plugin$ReventlessCore from "../plugin/component/Plugin.res.mjs";
 
 let sdlTypes = [
   `type Platform_FieldReference {\n  fieldName: String!\n  entity: String!\n  plugin: String\n}`,
-  `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  apiExposed: Boolean\n}`,
+  `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}`,
@@ -71,6 +71,10 @@ function encodeCommandDef(c) {
       "allowedStates",
       Stdlib_Option.mapOr(c.allowedStates, null, encodeStrings)
     ],
+    [
+      "targetState",
+      Stdlib_Option.mapOr(c.targetState, null, prim => prim)
+    ],
     [
       "apiExposed",
       Stdlib_Option.mapOr(c.apiExposed, null, prim => prim)

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res

@@ -3,7 +3,7 @@
 // No `open Reventless.Plugin`: it would shadow the state labels (panels/pages/...) brought in
 // by the projection's spec open. `manifest.<field>` resolves type-directed from the event's
 // uiFragmentManifest payload.
-let project = event =>
+let project = ({event}) =>
   switch event {
   | UiFragmentRegistered({pluginId, manifest, at}) => [
       Set(

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs

@@ -1,7 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 
-function project(event) {
+function project(param) {
+  let event = param.event;
   switch (event.TAG) {
     case "UiFragmentRegistered" :
       let at = event.at;

package/src/components/Api/ApiTargetStateHelpers.res

@@ -0,0 +1,20 @@
+// Read per-variant `targetState` metadata that the reventless-ppx
+// `@targetState("…")` attribute attaches to a command schema. Consumed by
+// `Plugin_Structure.toCommandDef` when building the `commandDef` records that
+// land in `Platform_ComponentDefinitions`, so AutoUI's board drag resolver can
+// move a row by a *declared* transition instead of a name-stem guess. Mirrors
+// `ApiAllowedStatesHelpers.getAllowedStates`.
+
+open ReventlessInfra.Api
+
+/** Returns the declared target state for a given command-variant name, or None
+    when the variant has no `@targetState` annotation (back-compat default —
+    the resolver falls back to its name-stem heuristic). */
+let getTargetState = (
+  commandSchema: S.t<unknown>,
+  ~variantName: string,
+): option<string> =>
+  switch commandSchema->S.Metadata.get(~id=targetStateId) {
+  | None => None
+  | Some(entries) => entries->Dict.get(variantName)
+  }

package/src/components/Api/ApiTargetStateHelpers.res.mjs

@@ -0,0 +1,16 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+function getTargetState(commandSchema, variantName) {
+  let entries = S.Metadata.get(commandSchema, Api$ReventlessInfra.targetStateId);
+  if (entries !== undefined) {
+    return entries[variantName];
+  }
+}
+
+export {
+  getTargetState,
+}
+/* S Not a pure module */

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -43,6 +43,7 @@ let rec fromSchemaType = (
   | ScalarBoolean => `Boolean${bang}`
   | ScalarBigInt => `String${bang}`
   | EntityId => `ID${bang}`
+  | DateTime => `String${bang}`
   | Nullable(inner) => fromSchemaType(~required=false, ~asInput, inner, collectedTypes, seenTypes)
   | ArrayOf(item) =>
     let itemType = fromSchemaType(~required=true, ~asInput, item, collectedTypes, seenTypes)

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -41,6 +41,7 @@ function fromSchemaType(_required, _asInputOpt, _st, collectedTypes, seenTypes)
           return `ID` + bang;
         case "ScalarString" :
         case "ScalarBigInt" :
+        case "DateTime" :
         case "Unknown" :
           return `String` + bang;
       }

package/src/components/Api/SchemaType.res

@@ -4,6 +4,7 @@ type rec schemaType =
   | ScalarBoolean
   | ScalarBigInt
   | EntityId
+  | DateTime
   | Nullable(schemaType)
   | ArrayOf(schemaType)
   | ObjectRef(string, dict<schemaType>)
@@ -11,6 +12,7 @@ type rec schemaType =
   | Unknown
 
 let isTagged = Reventless.DcbTag.isTagged
+let isDateTime = Reventless.DateTime.isDateTime
 
 let isIdFieldName = (name: string): bool => {
   let lower = String.toLowerCase(name)
@@ -30,6 +32,7 @@ let rec fromSury = (~parentName: string, ~fieldName: string, schema: S.t<unknown
   } else {
     switch schema {
     | String({const: ?Some(_)}) => ScalarString
+    | String(_) if isDateTime(schema) => DateTime
     | String(_) => isIdFieldName(fieldName) ? EntityId : ScalarString
     | Number(_) => ScalarNumber
     | Boolean(_) => ScalarBoolean

package/src/components/Api/SchemaType.res.mjs

@@ -3,6 +3,7 @@
 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 DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 
 function isIdFieldName(name) {
@@ -31,10 +32,14 @@ function fromSury(parentName, fieldName, schema) {
   }
   switch (schema.type) {
     case "string" :
-      if (schema.const !== undefined || !isIdFieldName(fieldName)) {
+      if (schema.const !== undefined) {
         return "ScalarString";
-      } else {
+      } else if (DateTime$Reventless.isDateTime(schema)) {
+        return "DateTime";
+      } else if (isIdFieldName(fieldName)) {
         return "EntityId";
+      } else {
+        return "ScalarString";
       }
     case "number" :
       return "ScalarNumber";
@@ -133,8 +138,11 @@ function fromSuryObject(typeName, schema) {
 
 let isTagged = DcbTag$Reventless.isTagged;
 
+let isDateTime = DateTime$Reventless.isDateTime;
+
 export {
   isTagged,
+  isDateTime,
   isIdFieldName,
   isIdsFieldName,
   fromSury,

package/src/components/Api/SuryToJsonSchema.res

@@ -68,6 +68,21 @@ let mergeAnnotations = (
     if spec.scanSort->Array.includes(fieldName) {
       obj->Dict.set("x-reventless-scanSort", JSON.Encode.bool(true))
     }
+    switch spec.semantic->Array.find(((field, _)) => field === fieldName) {
+    | Some((_, semanticId)) =>
+      obj->Dict.set("x-reventless-semantic", JSON.Encode.string(semanticId))
+    | None => ()
+    }
+    switch spec.metric->Array.find(((field, _)) => field === fieldName) {
+    | Some((_, m)) =>
+      // `x-reventless-metric: {aggregate, label}`. Omit an empty label so the
+      // UI derives one from the field name.
+      let entries = [("aggregate", JSON.Encode.string(m.aggregate))]
+      let entries =
+        m.label === "" ? entries : Array.concat(entries, [("label", JSON.Encode.string(m.label))])
+      obj->Dict.set("x-reventless-metric", JSON.Encode.object(Dict.fromArray(entries)))
+    | None => ()
+    }
     JSON.Encode.object(obj)
   }
 
@@ -80,6 +95,7 @@ let rec fromSchemaType = (st: SchemaType.schemaType): JSON.t =>
   | ScalarBoolean => jsonObject([("type", str("boolean"))])
   | ScalarBigInt => jsonObject([("type", str("integer"))])
   | EntityId => jsonObject([("type", str("string")), ("format", str("uuid"))])
+  | DateTime => jsonObject([("type", str("string")), ("format", str("date-time"))])
   | Nullable(inner) =>
     let innerSchema = fromSchemaType(inner)
     jsonObject([("oneOf", JSON.Encode.array([innerSchema, jsonObject([("type", str("null"))])]))])

package/src/components/Api/SuryToJsonSchema.res.mjs

@@ -62,6 +62,23 @@ function mergeAnnotations(fieldSchema, fieldName, spec) {
   if (spec.scanSort.includes(fieldName)) {
     obj["x-reventless-scanSort"] = true;
   }
+  let match$3 = spec.semantic.find(param => param[0] === fieldName);
+  if (match$3 !== undefined) {
+    obj["x-reventless-semantic"] = match$3[1];
+  }
+  let match$4 = spec.metric.find(param => param[0] === fieldName);
+  if (match$4 !== undefined) {
+    let m = match$4[1];
+    let entries = [[
+        "aggregate",
+        m.aggregate
+      ]];
+    let entries$1 = m.label === "" ? entries : entries.concat([[
+          "label",
+          m.label
+        ]]);
+    obj["x-reventless-metric"] = Object.fromEntries(entries$1);
+  }
   return obj;
 }
 
@@ -94,6 +111,17 @@ function fromSchemaType(st) {
             "uuid"
           ]
         ]);
+      case "DateTime" :
+        return Object.fromEntries([
+          [
+            "type",
+            "string"
+          ],
+          [
+            "format",
+            "date-time"
+          ]
+        ]);
       case "ScalarString" :
       case "Unknown" :
         return Object.fromEntries([[

package/src/components/Dcb/Dcb_Builder.res

@@ -718,11 +718,10 @@ module Make = (
                 | Some(receiveFn) =>
                   Effect.promise(async () => {
                     let result = await receiveFn(args)
-                    let response = switch result {
-                    | Ok(targetIds) =>
-                      targetIds->Array.map(JSON.Encode.string)->JSON.Encode.array
-                    | Error(msg) => msg->JSON.Encode.string
-                    }
+                    let response =
+                      result
+                      ->InboundTranslationSlice.receiveResultToOutcome
+                      ->CommandTopic.commandOutcomeToJson
                     response->Obj.magic
                   })
                 | None => baseHandler(event, ctx)

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

@@ -15,6 +15,7 @@ import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as DcbValidation$Reventless from "@reventlessdev/reventless-spec/src/components/DcbValidation.res.mjs";
 import * as Api_Naming$ReventlessCore from "../Api/Api_Naming.res.mjs";
+import * as CommandTopic$ReventlessCore from "../CommandTopic/CommandTopic.res.mjs";
 import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
 import * as RuntimeHints$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/RuntimeHints.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "../../plugin/component/Plugin_Helpers.res.mjs";
@@ -22,6 +23,7 @@ import * as ApiNoApiHelpers$ReventlessCore from "../Api/ApiNoApiHelpers.res.mjs"
 import * as Plugin_Structure$ReventlessCore from "../../plugin/component/Plugin_Structure.res.mjs";
 import * as DcbEventLog_Builder$ReventlessCore from "../DcbEventLog/DcbEventLog_Builder.res.mjs";
 import * as CommandTopic_Builder$ReventlessCore from "../CommandTopic/CommandTopic_Builder.res.mjs";
+import * as InboundTranslationSlice$ReventlessCore from "../InboundTranslationSlice/InboundTranslationSlice.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "../AutomationSlice/AutomationSlice_Callback.res.mjs";
 import * as CommandGenerator_Callback$ReventlessCore from "../CommandGenerator/CommandGenerator_Callback.res.mjs";
 import * as InboundTranslationSlice_Callback$ReventlessCore from "../InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
@@ -382,11 +384,7 @@ function Make(DcbEventLogStorage) {
             if (receiveFn !== undefined) {
               return Effect.promise(async () => {
                 let result = await receiveFn(args);
-                if (result.TAG === "Ok") {
-                  return result._0.map(prim => prim);
-                } else {
-                  return result._0;
-                }
+                return CommandTopic$ReventlessCore.commandOutcomeToJson(InboundTranslationSlice$ReventlessCore.receiveResultToOutcome(result));
               });
             } else {
               return baseHandler(event, ctx);

package/src/components/DcbEventLog/DcbEventLog_Operations.res

@@ -68,11 +68,16 @@ module Make = (Ops: Ops): T => {
       }
     }
 
+    // Storage stamped its own `recordedAt` at append but does not return it, so
+    // the topic envelope carries a publish-time stamp instead (a few ms later).
+    // StateViewSlice projections read this as `consumed.recordedAt`; the stored
+    // column remains authoritative for reads. Producer time is `meta.time`.
+    let recordedAt = Message.nowAsISOString()
     let _ = await Array.zip(rawEvents, finalRawEventsJson)
     ->Array.map(async ((rawEvent, eventJson)) => {
       let entityId =
         rawEvent.tags->Array.get(0)->Option.map(t => t.value)->Option.getOr(name)
-      let eventJson' = Message.composeEventJson'(entityId, rawEvent.meta, eventJson)
+      let eventJson' = Message.composeEventJson'(entityId, rawEvent.meta, ~recordedAt, eventJson)
       try await Ops.publishJson(serviceName, rawEvent.meta, eventJson') catch {
       | JsExn(err) =>
         let errMsg = err->JsExn.message->Option.getOr("unknown")

package/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs

@@ -41,10 +41,11 @@ function Make(Ops) {
     } else {
       finalRawEventsJson = rawEventsJson;
     }
+    let recordedAt = Message$ReventlessCore.nowAsISOString();
     await Promise.all(Stdlib_Array.zip(rawEvents, finalRawEventsJson).map(async param => {
       let rawEvent = param[0];
       let entityId = Stdlib_Option.getOr(Stdlib_Option.map(rawEvent.tags[0], t => t.value), name);
-      let eventJson$p = Message$ReventlessCore.composeEventJson$p(entityId, rawEvent.meta, param[1]);
+      let eventJson$p = Message$ReventlessCore.composeEventJson$p(entityId, rawEvent.meta, recordedAt, param[1]);
       try {
         return await Ops.publishJson(serviceName, rawEvent.meta, eventJson$p);
       } catch (raw_err) {

package/src/components/InboundTranslationSlice/InboundTranslationSlice.res

@@ -3,8 +3,33 @@ let componentType = ComponentType.InboundTranslationSlice
 type t = ReventlessInfra.InboundTranslationSlice.t
 type outputs = ReventlessInfra.InboundTranslationSlice.outputs
 type operations = ReventlessInfra.InboundTranslationSlice.operations
+type acceptedResult = ReventlessInfra.InboundTranslationSlice.acceptedResult
+type rejectedResult = ReventlessInfra.InboundTranslationSlice.rejectedResult
+type receiveResult = ReventlessInfra.InboundTranslationSlice.receiveResult
 type component = Component.t<t, outputs, operations>
 
+/**
+Map a `receive` outcome onto the `CommandResult` union the slice's mutation field
+declares, so both surfaces feed `CommandTopic.commandOutcomeToJson` rather than
+hand-rolling a second `__typename` writer.
+
+A translation can fan out across several targets; the mutation response reports
+the first target as `entityId` and the fan-out count as `eventCount`. The
+per-target detail stays queryable through the slice's audit read model. When the
+translation legitimately produced no command, `entityId` is omitted (encoding as
+`null`) rather than reporting a target that does not exist.
+*/
+let receiveResultToOutcome = (result: receiveResult): CommandTopic.commandOutcome =>
+  switch result {
+  | Ok({requestId, targetIds, commandCount}) =>
+    switch targetIds->Array.get(0) {
+    | Some(entityId) => Accepted({msgId: requestId, entityId, eventCount: commandCount})
+    | None => Accepted({msgId: requestId, eventCount: commandCount})
+    }
+  | Error({requestId, error}) =>
+    Rejected({msgId: requestId, errorCode: "TranslationFailed", errorDetail: Some(error)})
+  }
+
 let toResolvedOutputs = (
   outputs: outputs,
 ): Pulumi.Output.t<ReventlessInterop.InboundTranslationSlice.resolvedOutputs> =>

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

@@ -3,6 +3,36 @@
 import * as Pulumi from "@pulumi/pulumi";
 import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
 
+function receiveResultToOutcome(result) {
+  if (result.TAG === "Ok") {
+    let match = result._0;
+    let commandCount = match.commandCount;
+    let requestId = match.requestId;
+    let entityId = match.targetIds[0];
+    if (entityId !== undefined) {
+      return {
+        TAG: "Accepted",
+        msgId: requestId,
+        entityId: entityId,
+        eventCount: commandCount
+      };
+    } else {
+      return {
+        TAG: "Accepted",
+        msgId: requestId,
+        eventCount: commandCount
+      };
+    }
+  }
+  let match$1 = result._0;
+  return {
+    TAG: "Rejected",
+    msgId: match$1.requestId,
+    errorCode: "TranslationFailed",
+    errorDetail: match$1.error
+  };
+}
+
 function toResolvedOutputs(outputs) {
   return Pulumi.all([
     Adapter$ReventlessCore.resourcesToInterop(outputs.resources),
@@ -19,6 +49,7 @@ let componentType = "InboundTranslationSlice";
 
 export {
   componentType,
+  receiveResultToOutcome,
   toResolvedOutputs,
 }
 /* @pulumi/pulumi Not a pure module */