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

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/ExtensionPoint/ExtensionPoint_Builder.res

@@ -63,7 +63,10 @@ module Make = (
 
     let (commandTopic, eventTopic, outgoingJsonEventsHandler) =
       commandTopicResources
-      ->Pulumi.Output.flatMap(commandTopicResources => {
+      // The extension point's runtime and its event topic are both built in
+      // here, once the command topic's resources resolve — i.e. after the
+      // plugin's construct has returned. Reinstate its attribution.
+      ->ResourceAttribution_Deploytime.flatMapAttributed(commandTopicResources => {
         module ExtensionPointCallback = ExtensionPoint_Callback.Make(
           {
             let publishToAggregates = publishToAggregates

package/src/components/ExtensionPoint/ExtensionPoint_Builder.res.mjs

@@ -15,6 +15,7 @@ import * as EventTopic_Builder$ReventlessCore from "../EventTopic/EventTopic_Bui
 import * as CommandTopic_Builder$ReventlessCore from "../CommandTopic/CommandTopic_Builder.res.mjs";
 import * as ExtensionPoint_Callback$ReventlessCore from "./ExtensionPoint_Callback.res.mjs";
 import * as ExtensionPoint_Operations$ReventlessCore from "./ExtensionPoint_Operations.res.mjs";
+import * as ResourceAttribution_Deploytime$ReventlessCore from "../../adapter/ResourceAttribution_Deploytime.res.mjs";
 
 function Make(Spec) {
   return Mappings => (RuntimeEnvironment => (CommandTopicChannel => (EventTopicAdapter => (ExtensionPointRuntimeBuilder => (Defaults => {
@@ -42,7 +43,7 @@ function Make(Spec) {
       }, opts);
       let aggregateNames = Stdlib_Array.filterMap(Mappings.mappings, Mapping => Stdlib_Option.map(Mapping.mapOutgoingEvent, param => Mapping.delegateName));
       let commandTopicResources = Adapter$ReventlessCore.resourcesToResolvedOutput(commandTopic.channel.resources);
-      let match = Output$Pulumi.unzip3(Output$Pulumi.flatMap(commandTopicResources, commandTopicResources => {
+      let match = Output$Pulumi.unzip3(ResourceAttribution_Deploytime$ReventlessCore.flatMapAttributed(commandTopicResources, commandTopicResources => {
         let ExtensionPointCallback = ExtensionPoint_Callback$ReventlessCore.Make({
           publishToAggregates: publishToAggregates,
           commandTopicResources: commandTopicResources,

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),
           },
@@ -647,7 +648,11 @@ module Make = (
         queryEngine,
       )
       ->Pulumi.Output.all6
-      ->Pulumi.Output.apply(((
+      // `applyAttributed`, not `apply`: this callback provisions real resources —
+      // extension points, tasks, the heartbeat, resolvers — and it runs after
+      // this construct has returned, when the ambient attribution context is
+      // already empty. It reinstates the plugin's context for the duration.
+      ->ResourceAttribution_Deploytime.applyAttributed(((
         (interstackAdminExtensionPoints, localAdminResolvedEP, _),
         aggregateResources,
         publishToAggregates,

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

@@ -36,6 +36,7 @@ import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.r
 import * as Plugin_EventQuerySchema$ReventlessCore from "./Plugin_EventQuerySchema.res.mjs";
 import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
 import * as Plugin_SubscriptionSchema$ReventlessCore from "./Plugin_SubscriptionSchema.res.mjs";
+import * as ResourceAttribution_Deploytime$ReventlessCore from "../../adapter/ResourceAttribution_Deploytime.res.mjs";
 
 function Make(Spec) {
   return ApiSpec => (FragmentProvider => (RuntimeEnvironment => (EventCollectorChannel => (QueryEngineAdapter => (PluginExtensionPointRemoteChannel => (HeartbeatRunner => (PluginRuntimeBuilder => (DcbEventLogStorage => (DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => {
@@ -373,6 +374,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]
           };
@@ -427,7 +429,7 @@ function Make(Spec) {
         let schemaPushed = pushSchema !== undefined ? pushSchema(extra$1, version, apiSchemaFragment) : Pulumi.output();
         let apiSchemaFragmentPayload = Plugin_Helpers$ReventlessCore.offloadPayload(apiSchemaFragment, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments");
         let structurePayload = Stdlib_Option.map(pluginStructure, s => Plugin_Helpers$ReventlessCore.offloadPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures"));
-        let builderOutputs = Pulumi.all([
+        let builderOutputs = ResourceAttribution_Deploytime$ReventlessCore.applyAttributed(Pulumi.all([
           Pulumi.all([
             interstackAdminExtensionPoints,
             localAdminResolvedEP,
@@ -438,7 +440,7 @@ function Make(Spec) {
           Pulumi.all(Plugin_Helpers$ReventlessCore.publishToReadModels),
           scheduler,
           queryEngine
-        ]).apply(param => {
+        ]), param => {
           let queryEngine = param[5];
           let scheduler = param[4];
           let publishToReadModels = param[3];

package/src/plugin/component/Plugin_Helpers.res

@@ -383,7 +383,10 @@ let createConnectPluginExtension = (
   ~opts,
 ) =>
   pluginDefinition
-  ->Pulumi.Output.apply(pluginDefinition => {
+  // Provisions the plugin's connect-extension and its event-collector runtime,
+  // so it needs the plugin's attribution reinstated — the apply runs after
+  // construct has emptied it.
+  ->ResourceAttribution_Deploytime.applyAttributed(pluginDefinition => {
     module ConnectPluginExtension = PluginConnectExtension_Builder.Make({
       let pluginDefinition = pluginDefinition
       let uiFragments = uiFragments
@@ -548,7 +551,9 @@ module MakeEventCollectorHelper = (
       resources,
     )
     ->Pulumi.Output.all5
-    ->Pulumi.Output.apply(((
+    // Builds the plugin's own event-collector runtime, so it needs the plugin's
+    // attribution reinstated — this callback runs after construct emptied it.
+    ->ResourceAttribution_Deploytime.applyAttributed(((
       pluginDefinition,
       connectExtData,
       extensionsHandlers,

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

@@ -58,6 +58,7 @@ import * as OutboundTranslationSlice$ReventlessInterop from "@reventlessdev/reve
 import * as PluginExtensionPoint_Plugin$ReventlessCore from "../connect/PluginExtensionPoint_Plugin.res.mjs";
 import * as PluginConnectExtension_Builder$ReventlessCore from "../connect/PluginConnectExtension_Builder.res.mjs";
 import * as PluginConnectExtension_Mapping$ReventlessCore from "../connect/PluginConnectExtension_Mapping.res.mjs";
+import * as ResourceAttribution_Deploytime$ReventlessCore from "../../adapter/ResourceAttribution_Deploytime.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -224,7 +225,7 @@ function extractExtensionDefinitions(extensionsOutputs) {
 }
 
 function createConnectPluginExtension(pluginDefinition, uiFragments, publishToPluginExtensionPoint, publishToAggregates, readModelNamesForSourceName, publishToReadModels, queryEngine, opts) {
-  return Output$Pulumi.unzip(pluginDefinition.apply(pluginDefinition => {
+  return Output$Pulumi.unzip(ResourceAttribution_Deploytime$ReventlessCore.applyAttributed(pluginDefinition, pluginDefinition => {
     let ConnectPluginExtension = PluginConnectExtension_Builder$ReventlessCore.Make({
       pluginDefinition: pluginDefinition,
       uiFragments: uiFragments
@@ -292,13 +293,13 @@ function MakeEventCollectorHelper(RuntimeEnvironment) {
           param[0],
           param[1]
         ]) : Pulumi.output(undefined);
-      return Pulumi.all([
+      return ResourceAttribution_Deploytime$ReventlessCore.applyAttributed(Pulumi.all([
         pluginDefinition,
         connectExtData,
         Pulumi.all(extensionsHandlers),
         Pulumi.all(extensionPointsHandlers),
         resources
-      ]).apply(param => {
+      ]), param => {
         let extensionsHandlers = param[2];
         let connectExtData = param[1];
         let pluginDefinition = param[0];

package/src/plugin/component/Plugin_Structure.res

@@ -157,6 +157,70 @@ let labelFieldsFromStateSchema = (
     }
   }
 
+// ── Per-variant event / error field extraction (Phase 6.3) ───────────────────
+// Mirrors toCommandDef/extractCommandDefs for emitted events: name (TAG const),
+// payload JSON Schema, and cross-entity references. Module-level rather than
+// inside `make` because the synthetic Platform_Admin structure — hand-written,
+// because its components never pass through `make` — has to derive its defs the
+// same way, and a second copy of this walk would be free to drift from this one.
+
+let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
+  let mkDef = (~variantName, ~properties) => {
+    let references =
+      properties
+      ->Dict.toArray
+      ->Array.filterMap(((fieldName, fieldSchema)) =>
+        Reventless.Reference.getTarget(fieldSchema)->Option.map(target => (
+          {
+            Reventless.Plugin.fieldName,
+            entity: target.entity,
+            plugin: target.plugin,
+          }: Reventless.Plugin.fieldReference
+        ))
+      )
+    ({
+      Reventless.Plugin.name: variantName,
+      // Derived for the same reason as `commandDef.schema`: an event's field
+      // markers are the write side's half of the same vocabulary.
+      schema: v->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
+      references,
+    }: Reventless.Plugin.eventDef)
+  }
+  switch v {
+  | Object({properties}) =>
+    properties
+    ->Dict.get("TAG")
+    ->Option.flatMap(tagSchema =>
+      switch tagSchema {
+      | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties))
+      | _ => None
+      }
+    )
+  // Payload-less event variants (`| Archived`) compile to a bare string literal.
+  // DCB-projection lookups can't WHERE-clause on them, so they stay out of
+  // producedEventTypes/consumedEventTypes; but the full `events` list carries them
+  // so the event graph can still draw the emitted (orphan) event node.
+  | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties=Dict.make()))
+  | _ => None
+  }
+}
+
+let extractEventDefs = (eventSchema: S.t<unknown>): array<Reventless.Plugin.eventDef> =>
+  switch eventSchema {
+  | Union({anyOf}) => anyOf->Array.filterMap(toEventDef)
+  | _ => toEventDef(eventSchema)->Option.mapOr([], def => [def])
+  }
+
+// Declared errors walk identically to emitted events — an error variant is a
+// variant, and the payload-less form (`| CategoryNotFound`) is the common case
+// the bare-string branch above already handles. Reusing the walk rather than
+// copying it keeps the two from drifting; only the def type differs, so that a
+// consumer (and the SDL) can tell a refusal from a fact.
+let extractErrorDefs = (errorSchema: S.t<unknown>): array<Reventless.Plugin.errorDef> =>
+  extractEventDefs(errorSchema)->Array.map(({name, schema, references}) => (
+    {name, schema, references}: Reventless.Plugin.errorDef
+  ))
+
 let make = (
   type api role,
   ~name: string,
@@ -330,57 +394,6 @@ let make = (
       ->Option.mapOr([], def => [def])
     }
 
-  // ── Per-variant event field extraction (Phase 6.3) ─────────────────────────
-  // Mirrors toCommandDef/extractCommandDefs for emitted events: name (TAG const),
-  // payload JSON Schema, and cross-entity references.
-
-  let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
-    let mkDef = (~variantName, ~properties) => {
-      let references =
-        properties
-        ->Dict.toArray
-        ->Array.filterMap(((fieldName, fieldSchema)) =>
-          Reventless.Reference.getTarget(fieldSchema)->Option.map(target => (
-            {
-              Reventless.Plugin.fieldName,
-              entity: target.entity,
-              plugin: target.plugin,
-            }: Reventless.Plugin.fieldReference
-          ))
-        )
-      ({
-        Reventless.Plugin.name: variantName,
-        // Derived for the same reason as `commandDef.schema` above: an event's
-        // field markers are the write side's half of the same vocabulary.
-        schema: v->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
-        references,
-      }: Reventless.Plugin.eventDef)
-    }
-    switch v {
-    | Object({properties}) =>
-      properties
-      ->Dict.get("TAG")
-      ->Option.flatMap(tagSchema =>
-        switch tagSchema {
-        | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties))
-        | _ => None
-        }
-      )
-    // Payload-less event variants (`| Archived`) compile to a bare string literal.
-    // DCB-projection lookups can't WHERE-clause on them, so they stay out of
-    // producedEventTypes/consumedEventTypes; but the full `events` list carries them
-    // so the event graph can still draw the emitted (orphan) event node.
-    | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties=Dict.make()))
-    | _ => None
-    }
-  }
-
-  let extractEventDefs = (eventSchema: S.t<unknown>): array<Reventless.Plugin.eventDef> =>
-    switch eventSchema {
-    | Union({anyOf}) => anyOf->Array.filterMap(toEventDef)
-    | _ => toEventDef(eventSchema)->Option.mapOr([], def => [def])
-    }
-
   // ── Per-component event type extraction ────────────────────────────────────
 
   let scsProduced =
@@ -704,6 +717,7 @@ let make = (
         linkedViews: linkedSvsFor(produced),
         consistencyRead: consistencyReadFor(consumed),
         events: extractEventDefs(SCS.Spec.eventSchema->S.castToUnknown),
+        errors: extractErrorDefs(SCS.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(SCS.Spec.name),
       }: Reventless.Plugin.writableDef)
     })
@@ -726,6 +740,7 @@ let make = (
         linkedViews: Array.concat(linkedSvsFor(produced), linkedReadModelsFor(A.Spec.name)),
         consistencyRead: None,
         events: extractEventDefs(A.Spec.eventSchema->S.castToUnknown),
+        errors: extractErrorDefs(A.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(A.Spec.name),
       }: Reventless.Plugin.writableDef)
     })