@reventlessdev/reventless-core 3.0.0-alpha.215 → 3.0.0-alpha.216

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.216 (2026-08-08)
+
+### Features
+
+* **core,spec:** surface a write-side component's declared error types ([c9c2505](https://github.com/ReventlessDev/reventless-core/commit/c9c25057c70595fe27d73447c9aef9b451f86168))
+* **core:** add a runtime hook for command outcomes ([f2092a8](https://github.com/ReventlessDev/reventless-core/commit/f2092a8f9a8d8d7feee4f3de19bea7297a250cbd))
+
+
 # 3.0.0-alpha.215 (2026-08-08)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.215",
+  "version": "3.0.0-alpha.216",
   "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-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.2",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-node": "2.0.0-alpha.2",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.2",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.128",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.101"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.102"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin_Structure.res

@@ -98,6 +98,10 @@ let pluginAggregate: writableDef = {
   linkedViews: ["Plugins"],
   consistencyRead: None,
   events: [],
+  // Derived rather than left empty like `events` above: the two admin commands can
+  // be refused, and `[]` here would read as "this aggregate never rejects". Uses
+  // the same walk `Plugin_Structure` applies to every other write side.
+  errors: Plugin_Structure.extractErrorDefs(PluginSpec.errorSchema->S.castToUnknown),
   chapter: None,
 }
 

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -7,6 +7,8 @@ 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 Api_Naming$ReventlessCore from "../components/Api/Api_Naming.res.mjs";
+import * as PluginSpec$ReventlessCore from "../plugin/lifecycle/PluginSpec.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../plugin/component/Plugin_Structure.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../components/Api/SuryToJsonSchema.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "../plugin/api/PluginBaseFragment.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/PluginsReadModelSpec.res.mjs";
@@ -105,6 +107,8 @@ let pluginAggregate_linkedViews = ["Plugins"];
 
 let pluginAggregate_events = [];
 
+let pluginAggregate_errors = Plugin_Structure$ReventlessCore.extractErrorDefs(PluginSpec$ReventlessCore.errorSchema);
+
 let pluginAggregate = {
   name: "Plugin",
   commands: pluginAggregate_commands,
@@ -113,6 +117,7 @@ let pluginAggregate = {
   linkedViews: pluginAggregate_linkedViews,
   consistencyRead: undefined,
   events: pluginAggregate_events,
+  errors: pluginAggregate_errors,
   chapter: undefined
 };
 

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -20,7 +20,11 @@ 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  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  chapter: String\n}`,
+  // Same fields as Platform_EventDef, kept a distinct type because a refusal is not
+  // a fact: a caller selecting `errors` is asking what a command can be rejected
+  // with, and the two lists must stay independently evolvable.
+  `type Platform_ErrorDef {\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  errors: [Platform_ErrorDef!]!\n  chapter: 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  visibility: String\n  chapter: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
@@ -102,6 +106,13 @@ let encodeEventDef = (e: eventDef): JSON.t =>
     ("references", e.references->Array.map(encodeFieldReference)->JSON.Encode.array),
   ])->JSON.Encode.object
 
+let encodeErrorDef = (e: errorDef): JSON.t =>
+  Dict.fromArray([
+    ("name", JSON.Encode.string(e.name)),
+    ("schema", JSON.Encode.string(e.schema)),
+    ("references", e.references->Array.map(encodeFieldReference)->JSON.Encode.array),
+  ])->JSON.Encode.object
+
 let encodeWritableDef = (w: writableDef): JSON.t =>
   Dict.fromArray([
     ("name", JSON.Encode.string(w.name)),
@@ -115,6 +126,10 @@ let encodeWritableDef = (w: writableDef): JSON.t =>
     ("consumedEventTypes", encodeStrings(w.consumedEventTypes)),
     // Phase 6.3: emitted-event field schemas (None → [] on the wire).
     ("events", w.events->Array.map(encodeEventDef)->JSON.Encode.array),
+    // Declared errors — the refusals a caller has to handle. `[]` is the honest
+    // answer for a component that declares none; the structure is re-derived on
+    // every build, so it never stands in for "cannot say".
+    ("errors", w.errors->Array.map(encodeErrorDef)->JSON.Encode.array),
     ("chapter", w.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -8,7 +8,8 @@ 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  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  chapter: String\n}`,
+  `type Platform_ErrorDef {\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  errors: [Platform_ErrorDef!]!\n  chapter: 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  visibility: String\n  chapter: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
@@ -152,6 +153,23 @@ function encodeEventDef(e) {
   ]);
 }
 
+function encodeErrorDef(e) {
+  return Object.fromEntries([
+    [
+      "name",
+      e.name
+    ],
+    [
+      "schema",
+      e.schema
+    ],
+    [
+      "references",
+      e.references.map(encodeFieldReference)
+    ]
+  ]);
+}
+
 function encodeWritableDef(w) {
   return Object.fromEntries([
     [
@@ -182,6 +200,10 @@ function encodeWritableDef(w) {
       "events",
       w.events.map(encodeEventDef)
     ],
+    [
+      "errors",
+      w.errors.map(encodeErrorDef)
+    ],
     [
       "chapter",
       Stdlib_Option.mapOr(w.chapter, null, prim => prim)
@@ -341,6 +363,7 @@ export {
   isPublicQueryable,
   encodeQueryableDef,
   encodeEventDef,
+  encodeErrorDef,
   encodeWritableDef,
   encodeAutomationSliceDef,
   encodeOutboundTranslationSliceDef,

package/src/components/Aggregate/Aggregate_Callback.res

@@ -284,13 +284,25 @@ module Make = (
     outcomes->Array.map(((reference, outcome, _meta)) =>
       switch outcome {
       | CmdRejected({errorCode, errorDetail}) =>
-        CommandTopic_Helpers.reportRejected(reference, {errorCode, errorDetail})
+        CommandTopic_Helpers.reportRejected(
+          ~component=Spec.name,
+          ~cause=DomainRejection,
+          reference,
+          {errorCode, errorDetail},
+        )
         Ok(reference)
       | CmdOk(_) if appendSucceeded =>
-        CommandTopic_Helpers.reportAccepted(reference, {entityId, eventCount: appendedEventCount})
+        CommandTopic_Helpers.reportAccepted(
+          ~component=Spec.name,
+          reference,
+          {entityId, eventCount: appendedEventCount},
+        )
         Ok(reference)
       | CmdOk(_) =>
+        // The decision succeeded and the append did not — infrastructure, not the model.
         CommandTopic_Helpers.reportRejected(
+          ~component=Spec.name,
+          ~cause=InfrastructureFailure,
           reference,
           {errorCode: "AppendFailed", errorDetail: appendErrorDetail},
         )

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

@@ -200,7 +200,7 @@ function Make(Spec) {
         let reference = param[0];
         if (outcome.TAG === "CmdOk") {
           if (appendSucceeded) {
-            CommandTopic_Helpers$ReventlessCore.reportAccepted(reference, {
+            CommandTopic_Helpers$ReventlessCore.reportAccepted(Spec.name, reference, {
               entityId: entityId,
               eventCount: appendedEventCount
             });
@@ -209,7 +209,7 @@ function Make(Spec) {
               _0: reference
             };
           } else {
-            CommandTopic_Helpers$ReventlessCore.reportRejected(reference, {
+            CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "InfrastructureFailure", reference, {
               errorCode: "AppendFailed",
               errorDetail: appendErrorDetail
             });
@@ -219,7 +219,7 @@ function Make(Spec) {
             };
           }
         }
-        CommandTopic_Helpers$ReventlessCore.reportRejected(reference, {
+        CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "DomainRejection", reference, {
           errorCode: outcome.errorCode,
           errorDetail: outcome.errorDetail
         });

package/src/components/CommandTopic/CommandTopic.res.mjs

@@ -23,6 +23,14 @@ function filter(allCommandTopics, names) {
 
 let componentType = "CommandTopic";
 
+let commandOutcomeHook = CommandTopic_Helpers$ReventlessCore.commandOutcomeHook;
+
+let registerCommandOutcome = CommandTopic_Helpers$ReventlessCore.registerCommandOutcome;
+
+let clearCommandOutcome = CommandTopic_Helpers$ReventlessCore.clearCommandOutcome;
+
+let fireCommandOutcome = CommandTopic_Helpers$ReventlessCore.fireCommandOutcome;
+
 let acceptedResultChannel = CommandTopic_Helpers$ReventlessCore.acceptedResultChannel;
 
 let rejectedResultChannel = CommandTopic_Helpers$ReventlessCore.rejectedResultChannel;
@@ -50,6 +58,10 @@ let getHandlers = CommandTopic_Helpers$ReventlessCore.getHandlers;
 export {
   componentType,
   NotPublishedToChannel,
+  commandOutcomeHook,
+  registerCommandOutcome,
+  clearCommandOutcome,
+  fireCommandOutcome,
   acceptedResultChannel,
   rejectedResultChannel,
   reportAccepted,

package/src/components/CommandTopic/CommandTopic_Helpers.res

@@ -18,6 +18,71 @@ is the JSON-stringified error payload (or empty string for payload-less variants
 */
 type rejectedResult = {errorCode: string, errorDetail: string}
 
+/**
+Why a command was refused.
+
+`DomainRejection` is `Behavior.decide` returning `Error` — the model declining the command,
+which is the model working. `InfrastructureFailure` is the decision never landing: an event-log
+append that failed outright or exhausted its conflict retries. Both arrive on `reportRejected`,
+so without this a consumer would read a broken event log as a business rejection.
+*/
+type refusalCause = DomainRejection | InfrastructureFailure
+
+/**
+What became of one command. Constructors are prefixed to stay clear of `commandOutcome`'s
+`Accepted`/`Rejected` below — that type is the producer-facing result shape (and the GraphQL
+`CommandResult` union); this one is the observation, and carries the refusal cause it doesn't.
+*/
+type observedOutcome =
+  | OutcomeAccepted({entityId: option<string>, eventCount: int})
+  | OutcomeRejected({errorCode: string, errorDetail: string, cause: refusalCause})
+
+/** `reference` is the command's `meta.msgId` on every current transport. */
+type commandOutcomeReport = {
+  component: string,
+  reference: string,
+  outcome: observedOutcome,
+}
+
+type commandOutcomeHook = commandOutcomeReport => unit
+
+/**
+Module-level outcome hook, in the shape the `RuntimeExtension` cold-start seam already reaches
+— so an extension registers it from `onColdStart` alongside the interception and publish hooks,
+and no new registration path is needed. None = no-op (default).
+*/
+let commandOutcomeHook: ref<option<commandOutcomeHook>> = ref(None)
+
+let registerCommandOutcome = (hook: commandOutcomeHook) => {
+  commandOutcomeHook.contents = Some(hook)
+}
+
+let clearCommandOutcome = () => {
+  commandOutcomeHook.contents = None
+}
+
+// Fired from reportAccepted/reportRejected below, which both write-side kinds call
+// unconditionally — so this sees fire-and-forget dispatches too, not just the ones a
+// producer awaited on the side-channels.
+//
+// A throwing hook is logged and swallowed: the outcome it observes has already happened,
+// and letting an observer fail a completed command would make an extension an outage
+// (the same failure policy the cold-start seam settled on).
+let fireCommandOutcome = (~component: string, ~reference: string, outcome: observedOutcome) =>
+  commandOutcomeHook.contents->Option.forEach(hook =>
+    switch hook({component, reference, outcome}) {
+    | () => ()
+    | exception err =>
+      EffectLogger.logError(
+        ~comp=`CommandTopic(${component})`,
+        `command-outcome hook threw (ignored): ${err
+          ->JsExn.fromException
+          ->Option.flatMap(JsExn.message)
+          ->Option.getOr("unknown")}`,
+      )->Effect.runSync
+    }
+  )
+
 // Side-channel for publishJsonsAndWait result propagation.
 // Set by runInlineAndCollect before invoking the handler; cleared after.
 // Callback implementations call reportAccepted during inline dispatch.
@@ -28,11 +93,32 @@ let acceptedResultChannel: ref<option<(string, acceptedResult) => unit>> = ref(N
 // `Rejected` outcomes that carry the real error code and detail.
 let rejectedResultChannel: ref<option<(string, rejectedResult) => unit>> = ref(None)
 
-let reportAccepted = (reference: string, result: acceptedResult) =>
+// `~component` is the owning component's `Spec.name`: an outcome isn't interpretable without
+// knowing which component produced it, and the side-channel (keyed per inline dispatch) never
+// had to say. `~cause` is required rather than defaulted so a new rejection site has to state
+// which kind it is instead of silently reporting infrastructure as a domain decision.
+let reportAccepted = (~component: string, reference: string, result: acceptedResult) => {
   acceptedResultChannel.contents->Option.forEach(cb => cb(reference, result))
+  fireCommandOutcome(
+    ~component,
+    ~reference,
+    OutcomeAccepted({entityId: result.entityId, eventCount: result.eventCount}),
+  )
+}
 
-let reportRejected = (reference: string, result: rejectedResult) =>
+let reportRejected = (
+  ~component: string,
+  ~cause: refusalCause,
+  reference: string,
+  result: rejectedResult,
+) => {
   rejectedResultChannel.contents->Option.forEach(cb => cb(reference, result))
+  fireCommandOutcome(
+    ~component,
+    ~reference,
+    OutcomeRejected({errorCode: result.errorCode, errorDetail: result.errorDetail, cause}),
+  )
+}
 
 // Placed here (rather than CommandTopic.res) so runInlineAndCollect can use commandOutcome
 // without importing Adapter.res → @pulumi/pulumi. Re-exported by CommandTopic via include.

package/src/components/CommandTopic/CommandTopic_Helpers.res.mjs

@@ -1,11 +1,42 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+let commandOutcomeHook = {
+  contents: undefined
+};
+
+function registerCommandOutcome(hook) {
+  commandOutcomeHook.contents = hook;
+}
+
+function clearCommandOutcome() {
+  commandOutcomeHook.contents = undefined;
+}
+
+function fireCommandOutcome(component, reference, outcome) {
+  Stdlib_Option.forEach(commandOutcomeHook.contents, hook => {
+    try {
+      hook({
+        component: component,
+        reference: reference,
+        outcome: outcome
+      });
+      return;
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      return Effect.runSync(EffectLogger$ReventlessCore.logError(`CommandTopic(` + component + `)`, undefined, `command-outcome hook threw (ignored): ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown")));
+    }
+  });
+}
 
 let acceptedResultChannel = {
   contents: undefined
@@ -15,12 +46,23 @@ let rejectedResultChannel = {
   contents: undefined
 };
 
-function reportAccepted(reference, result) {
+function reportAccepted(component, reference, result) {
   Stdlib_Option.forEach(acceptedResultChannel.contents, cb => cb(reference, result));
+  fireCommandOutcome(component, reference, {
+    TAG: "OutcomeAccepted",
+    entityId: result.entityId,
+    eventCount: result.eventCount
+  });
 }
 
-function reportRejected(reference, result) {
+function reportRejected(component, cause, reference, result) {
   Stdlib_Option.forEach(rejectedResultChannel.contents, cb => cb(reference, result));
+  fireCommandOutcome(component, reference, {
+    TAG: "OutcomeRejected",
+    errorCode: result.errorCode,
+    errorDetail: result.errorDetail,
+    cause: cause
+  });
 }
 
 function commandOutcomeToJson(outcome) {
@@ -179,6 +221,10 @@ function getHandlers(typeName) {
 }
 
 export {
+  commandOutcomeHook,
+  registerCommandOutcome,
+  clearCommandOutcome,
+  fireCommandOutcome,
   acceptedResultChannel,
   rejectedResultChannel,
   reportAccepted,

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -322,6 +322,7 @@ module Make = (
             // No append, but the read snapshot is valid — cache it for the next command.
             cachePut((state, headPosition))
             CommandTopic_Helpers.reportAccepted(
+              ~component=Spec.name,
               cmdJson.meta.msgId,
               switch entityId {
               | Some(eid) => {entityId: eid, eventCount: 0}
@@ -373,6 +374,7 @@ module Make = (
                   // next command's delta read picks our events up from `headPosition`.
                   cachePut((state, headPosition))
                   CommandTopic_Helpers.reportAccepted(
+                    ~component=Spec.name,
                     cmdJson.meta.msgId,
                     switch entityId {
                     | Some(eid) => {entityId: eid, eventCount: rawEvents->Array.length}
@@ -412,7 +414,12 @@ module Make = (
                     if errorCode == "Conflict" {
                       Metrics.emitCount(~metric="AppendConflict", ~slice=Spec.name)
                     }
+                    // Both arms here are storage, not the model: a surfaced Conflict is
+                    // contention the retry loop couldn't absorb, and AppendFailed is the
+                    // store failing. `decide` had already said Ok.
                     CommandTopic_Helpers.reportRejected(
+                      ~component=Spec.name,
+                      ~cause=InfrastructureFailure,
                       cmdJson.meta.msgId,
                       {errorCode, errorDetail: errDetail},
                     )
@@ -433,7 +440,12 @@ module Make = (
               payloadDict->Dict.toArray->Array.length == 0
                 ? ""
                 : payloadDict->JSON.Encode.object->JSON.stringify
-            CommandTopic_Helpers.reportRejected(cmdJson.meta.msgId, {errorCode, errorDetail})
+            CommandTopic_Helpers.reportRejected(
+              ~component=Spec.name,
+              ~cause=DomainRejection,
+              cmdJson.meta.msgId,
+              {errorCode, errorDetail},
+            )
             EffectLogger.logError(
               ~comp,
               `decide rejected: ${errorCode} ${errorDetail}`,

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

@@ -173,7 +173,7 @@ function Make(Spec) {
                   state,
                   headPosition
                 ]);
-                CommandTopic_Helpers$ReventlessCore.reportAccepted(cmdJson.meta.msgId, entityId !== undefined ? ({
+                CommandTopic_Helpers$ReventlessCore.reportAccepted(Spec.name, cmdJson.meta.msgId, entityId !== undefined ? ({
                     entityId: entityId,
                     eventCount: 0
                   }) : ({
@@ -223,7 +223,7 @@ function Make(Spec) {
                     state,
                     headPosition
                   ]);
-                  CommandTopic_Helpers$ReventlessCore.reportAccepted(cmdJson.meta.msgId, entityId !== undefined ? ({
+                  CommandTopic_Helpers$ReventlessCore.reportAccepted(Spec.name, cmdJson.meta.msgId, entityId !== undefined ? ({
                       entityId: entityId,
                       eventCount: rawEvents.length
                     }) : ({
@@ -257,7 +257,7 @@ function Make(Spec) {
                   if (errorCode === "Conflict") {
                     Metrics$ReventlessCore.emitCount("AppendConflict", Spec.name, undefined);
                   }
-                  CommandTopic_Helpers$ReventlessCore.reportRejected(cmdJson.meta.msgId, {
+                  CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "InfrastructureFailure", cmdJson.meta.msgId, {
                     errorCode: errorCode,
                     errorDetail: errDetail
                   });
@@ -277,7 +277,7 @@ function Make(Spec) {
             let match = Message$ReventlessCore.splitMessage(errorJson);
             let payloadDict = match[1];
             let errorDetail = Object.entries(payloadDict).length === 0 ? "" : JSON.stringify(payloadDict);
-            CommandTopic_Helpers$ReventlessCore.reportRejected(cmdJson.meta.msgId, {
+            CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "DomainRejection", cmdJson.meta.msgId, {
               errorCode: errorCode,
               errorDetail: errorDetail
             });

package/src/plugin/component/Plugin_Builder.res

@@ -529,6 +529,7 @@ module Make = (
           {
             commandTypes: extractTypes(Scs.Spec.commandSchema),
             eventTypes: extractEventTypes(Scs.Spec.eventSchema->S.castToUnknown),
+            errorTypes: extractTypes(Scs.Spec.errorSchema),
             consumedEventTypes: extractEventTypes(Scs.Spec.consumedEventSchema->S.castToUnknown),
             chapter: ?chapterFor(Scs.Spec.name),
           },

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

@@ -373,6 +373,7 @@ function Make(Spec) {
           stateSchemas[Scs.Spec.name] = {
             commandTypes: DcbTag$Reventless.extractAllVariantNames(Scs.Spec.commandSchema),
             eventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.eventSchema),
+            errorTypes: DcbTag$Reventless.extractAllVariantNames(Scs.Spec.errorSchema),
             consumedEventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.consumedEventSchema),
             chapter: chapterByName[Scs.Spec.name]
           };