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

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 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.217 (2026-08-08)
+
+### Bug Fixes
+
+* **core:** attribute resources built after a builder's construct returns ([67d6d9c](https://github.com/ReventlessDev/reventless-core/commit/67d6d9c0ff3ff1d38cd9e8ad43a4b86121abf827))
+### Features
+
+* **core:** let an extension switch query interception on, and provision it ([4523b10](https://github.com/ReventlessDev/reventless-core/commit/4523b10597f1a028eedccc42391b250b25a6ddd3))
+
+
+# 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.217",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "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-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-node": "2.0.0-alpha.2",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.2",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
-    "@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/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.128",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.102",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.30"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/ResourceAttribution.res

@@ -112,10 +112,28 @@ large, purely mechanical churn — so the plugin builder publishes them here for
 the duration of its construct, exactly as it already does for
 `Logger.currentPluginName`.
 
-Safe because deploy-time resource construction is synchronous (the framework
-forbids creating resources inside `Pulumi.Output.apply`), so everything built
-between `enter` and `restore` genuinely belongs to that plugin. Outside any
-plugin construct both are `None` — which is the correct answer for
+The `enter`/`restore` bracket covers what runs **synchronously** inside the
+builder's construct, and everything built there genuinely belongs to that plugin.
+
+It does not cover all of construct. Builders defer part of their work until every
+handler has registered, and they defer it by waiting on outputs — so that work
+runs from a `Pulumi.Output.apply` callback, after construct has returned and
+`restore` has already emptied the context. A resource created there would be
+attributed to nobody, and `None` is a *meaningful* value here: it means
+platform-scope substrate. So the miss does not read as a gap, it reads as a
+positive answer, and a consumer cannot tell the two apart.
+
+Deferred work therefore carries its own attribution. Capture the context while it
+is still published and reinstate it around the callback: `deferred` for a
+callback registered during construct and invoked later, and
+`ResourceAttribution_Deploytime.applyAttributed` / `flatMapAttributed` for a
+builder's own apply. Both restore afterwards, so several plugins' deferred work
+can run from one apply without leaking into each other.
+
+Everything Pulumi-shaped lives in that separate module, so this one stays
+importable from code that ends up in a Lambda bundle.
+
+Outside any plugin construct both are `None` — the correct answer for
 platform-scope substrate.
 */
 type context = {platform: option<string>, plugin: option<string>}
@@ -131,3 +149,41 @@ let enter = (~platform: string, ~plugin: string) => {
 
 /** Restore the context captured by `enter`. */
 let restore = (previous: context) => current := previous
+
+/** Re-enter a whole captured context — including an empty one, which `enter`
+    cannot express since it takes two required strings. Returns the previous
+    context, exactly as `enter` does. */
+let enterCaptured = (captured: context) => {
+  let previous = current.contents
+  current := captured
+  previous
+}
+
+/** Run `fn` under `captured`, then put the previous context back — including
+    when `fn` throws, so a failing deferred callback cannot strand the context
+    and mis-attribute everything built after it. */
+let within = (captured: context, fn: unit => 'a): 'a => {
+  let previous = enterCaptured(captured)
+  try {
+    let result = fn()
+    restore(previous)
+    result
+  } catch {
+  | e =>
+    restore(previous)
+    throw(e)
+  }
+}
+
+/** Capture the context now and wrap a callback so it runs under that context
+    whenever it is finally called. For work registered during construct but
+    executed later from an apply — a builder's deferred `finish`, whose whole
+    purpose is to run after every handler has registered.
+
+    Wrap at **registration**, not at the call site: the registries these
+    callbacks land in are module-level and shared by every plugin, so by the time
+    they run there is no single context that would be right for all of them. */
+let deferred = (fn: unit => 'a): (unit => 'a) => {
+  let captured = current.contents
+  () => within(captured, fn)
+}

package/src/ResourceAttribution.res.mjs

@@ -86,11 +86,37 @@ function restore(previous) {
   current.contents = previous;
 }
 
+function enterCaptured(captured) {
+  let previous = current.contents;
+  current.contents = captured;
+  return previous;
+}
+
+function within(captured, fn) {
+  let previous = enterCaptured(captured);
+  try {
+    let result = fn();
+    current.contents = previous;
+    return result;
+  } catch (e) {
+    current.contents = previous;
+    throw e;
+  }
+}
+
+function deferred(fn) {
+  let captured = current.contents;
+  return () => within(captured, fn);
+}
+
 export {
   Scope,
   Role,
   current,
   enter,
   restore,
+  enterCaptured,
+  within,
+  deferred,
 }
 /* No side effect */

package/src/adapter/QueryInterception/QueryInterception.res

@@ -0,0 +1,74 @@
+/**
+Deploy-time switch: an extension asks for query interception, and the framework
+provisions whatever that costs.
+
+`QueryDb_Callback.registerQueryInterceptor` is a runtime hook, and `RuntimeExtension`
+made it reachable inside a deployed runtime. On a DynamoDB-backed read model there
+was still nothing to reach: a top-level Query resolver talks to DynamoDB directly,
+so no code of ours runs on a read at all. Something has to put a runtime in front
+of the read, and that is a provisioning decision the extension cannot make for
+itself — an AppSync Lambda data source needs the api handle and a service role,
+both of which exist only inside the plugin build.
+
+So the split follows `Monitoring` and `EventLogProvisioning`: **the extension
+decides, the framework provisions.** An extension says only *that* interception
+should happen; it names no data source, no api and no role, and writes nothing
+provider-shaped. The framework already ships the handler
+(`QueryInterceptor_Lambda` on AWS), so there is nothing left for a caller to
+supply.
+
+**Off by default, and silent when off.** No registration means no interceptor
+runtime, no data source, unit resolvers exactly as before, and a byte-identical
+code archive — the same guarantee the cold-start seam makes.
+
+**It composes with `RuntimeExtension` without either knowing about the other.**
+The interceptor runtime is built through the standard runtime builder, so
+`Util_Bundle` bundles every registered extension's package into its archive and
+`makeFromCodeAsset` writes `RUNTIME_EXTENSIONS`. An extension that registers its
+interceptor in `onColdStart` is therefore carried into the interceptor runtime
+with no second registration.
+
+## What it costs, which is why it is opt-in
+
+Interception puts a Lambda invocation in front of **every read** on a
+DynamoDB-backed read model. Reads outrun writes by orders of magnitude, so this
+is the most expensive thing the framework can be asked to switch on. Two
+properties bound it:
+
+- **It is a property of the read-model backend, not of the cloud.** A
+  Postgres-backed read model already routes through a resolver Lambda, which
+  consults the same hook, so interception there costs nothing extra. Only the
+  DynamoDB direct-resolver path pays.
+- **It is the only place a read can be refused.** Anything cheaper — a log
+  subscription, a stream-fed counter — observes a read after the fact but cannot
+  deny it. Where the requirement is enforcement rather than observation, this
+  cost is the requirement's price rather than overhead.
+
+Granularity is per-deployment, deliberately: an operator asking "what does
+interception cost me" wants one answer, not one per component. Narrowing later is
+additive (a predicate on the registration); widening a per-component switch is
+not.
+
+See `docs/plans/done/query-interception-provisioning.md`.
+*/
+
+let enabled = ref(false)
+
+/**
+Switch query interception on for this deployment. Must run before the
+platform/plugin build in the deploy program (plain statement order — the switch is
+read lazily at each provisioning site), exactly like `Monitoring.use`.
+
+Registering the runtime interceptor itself stays separate and is the extension's
+job, through `QueryDb_Callback.registerQueryInterceptor` — typically from a
+`RuntimeExtension` cold-start hook. This call only provisions the path that lets
+that hook be consulted on a read.
+*/
+let use = () => enabled := true
+
+/** Whether interception was asked for. Consulted by the provisioning sites. */
+let isEnabled = () => enabled.contents
+
+/** Tests only — the switch is process-global, so a test that flips it must put it
+    back. */
+let reset = () => enabled := false

package/src/adapter/QueryInterception/QueryInterception.res.mjs

@@ -0,0 +1,26 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let enabled = {
+  contents: false
+};
+
+function use() {
+  enabled.contents = true;
+}
+
+function isEnabled() {
+  return enabled.contents;
+}
+
+function reset() {
+  enabled.contents = false;
+}
+
+export {
+  enabled,
+  use,
+  isEnabled,
+  reset,
+}
+/* No side effect */

package/src/adapter/ResourceAttribution_Deploytime.res

@@ -0,0 +1,43 @@
+/***
+Carrying `ResourceAttribution` across a `Pulumi.Output` boundary.
+
+Separate from `ResourceAttribution` itself on purpose: that module is read by
+code that ends up in a Lambda bundle, and importing the deploy-time engine there
+is a cold-start failure. Everything Pulumi-shaped lives here, where only
+deploy-time builders reach it — the same reason `AdapterDeploytime` sits apart
+from `Adapter`.
+
+Both helpers wrap `apply` / `flatMap` rather than the callback alone. Wrapping
+the callback would read more neatly, but it severs the type flow from the Output
+to the callback's parameters, and inference then fails on records the Output was
+the only thing constraining.
+*/
+
+/** `Pulumi.Output.apply` for a callback that CREATES RESOURCES.
+
+    An apply callback runs after the enclosing builder's construct has returned,
+    so the ambient attribution context — published for the duration of that
+    construct and unpublished at the end of it — is already empty by then, and
+    anything the callback provisions is attributed to nobody. That is not a gap
+    but a wrong answer: an empty plugin means platform-scope substrate.
+
+    This captures the context where the apply is *registered*, which is
+    synchronous inside construct, and reinstates it around the callback. Reach
+    for it wherever an apply body reaches a resource; plain `Pulumi.Output.apply`
+    stays right for a callback that only shapes data. */
+let applyAttributed = (output, callback) => {
+  let captured = ResourceAttribution.current.contents
+  output->Pulumi.Output.apply(resolved =>
+    captured->ResourceAttribution.within(() => callback(resolved))
+  )
+}
+
+/** `Pulumi.Output.flatMap` counterpart, for the same reason — a builder that
+    resolves one resource's outputs in order to build the next one defers just as
+    far. */
+let flatMapAttributed = (output, callback) => {
+  let captured = ResourceAttribution.current.contents
+  output->Pulumi.Output.flatMap(resolved =>
+    captured->ResourceAttribution.within(() => callback(resolved))
+  )
+}

package/src/adapter/ResourceAttribution_Deploytime.res.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "../ResourceAttribution.res.mjs";
+
+function applyAttributed(output, callback) {
+  let captured = ResourceAttribution$ReventlessCore.current.contents;
+  return output.apply(resolved => ResourceAttribution$ReventlessCore.within(captured, () => callback(resolved)));
+}
+
+function flatMapAttributed(output, callback) {
+  let captured = ResourceAttribution$ReventlessCore.current.contents;
+  return Output$Pulumi.flatMap(output, resolved => ResourceAttribution$ReventlessCore.within(captured, () => callback(resolved)));
+}
+
+export {
+  applyAttributed,
+  flatMapAttributed,
+}
+/* Output-Pulumi Not a pure module */

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/Builder_Helpers.res

@@ -42,7 +42,13 @@ let createAggregatesWithoutEventMappers = (
     let publishJsons =
       SpecificAggregate.operations(aggregate)->Pulumi.Output.apply(({publishJsons}) => publishJsons)
     publishToAggregates->Dict.set(SpecificAggregate.Spec.name, publishJsons)
-    aggregateFinishFns->Dict.set(SpecificAggregate.Spec.name, SpecificAggregate.finish)
+    // `finish` runs from an apply in `finishAggregates`, long after this
+    // construct returns — wrap it now, while the plugin is still the ambient
+    // one, so whatever it provisions is attributed to that plugin.
+    aggregateFinishFns->Dict.set(
+      SpecificAggregate.Spec.name,
+      ResourceAttribution.deferred(SpecificAggregate.finish),
+    )
     aggOutputs
   })
   ->Array.map(aggregate => {(aggregate.name, aggregate)})
@@ -106,7 +112,10 @@ let taskSideEffectFinishFns: array<unit => unit> = []
 
 let registerTaskSideEffectHandler = (~gate, ~finish) => {
   let _ = taskSideEffectGates->Array.push(gate)
-  let _ = taskSideEffectFinishFns->Array.push(finish)
+  // These arrays are module-level and shared by every plugin, so the context has
+  // to travel with each entry: by the time `finishTasks` runs them there is no
+  // one plugin that would be right for all of them.
+  let _ = taskSideEffectFinishFns->Array.push(ResourceAttribution.deferred(finish))
 }
 
 // Provision side-effect handler runtimes once every task's handler is ready. Same
@@ -179,7 +188,16 @@ let createReadModels = (
       rmOperations->Pulumi.Output.apply(({enqueueEvent}) => enqueueEvent),
     )
 
-    (SpecificReadModel.Spec.name, {outputs: rmOutputs, operations: rmOperations, finish: SpecificReadModel.finish})
+    // Deferred to `finishReadModels`, which runs it from an apply — wrap it here
+    // so the read model's runtime is attributed to the plugin building it.
+    (
+      SpecificReadModel.Spec.name,
+      {
+        outputs: rmOutputs,
+        operations: rmOperations,
+        finish: ResourceAttribution.deferred(SpecificReadModel.finish),
+      },
+    )
   })
   readModels->finishReadModels
   readModels->extractReadModelsOutputs

package/src/components/Builder_Helpers.res.mjs

@@ -4,6 +4,7 @@ import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as QueryDb$ReventlessCore from "./QueryDb/QueryDb.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "../ResourceAttribution.res.mjs";
 
 let addEventMapperFns = {};
 
@@ -22,7 +23,7 @@ function createAggregatesWithoutEventMappers(aggregates, api, componentRuntime,
     aggregateResources[SpecificAggregate.Spec.name] = resources;
     let publishJsons = SpecificAggregate.operations(aggregate).apply(param => param.publishJsons);
     publishToAggregates[SpecificAggregate.Spec.name] = publishJsons;
-    aggregateFinishFns[SpecificAggregate.Spec.name] = SpecificAggregate.finish;
+    aggregateFinishFns[SpecificAggregate.Spec.name] = ResourceAttribution$ReventlessCore.deferred(SpecificAggregate.finish);
     return aggOutputs;
   }).map(aggregate => [
     aggregate.name,
@@ -54,7 +55,7 @@ let taskSideEffectFinishFns = [];
 
 function registerTaskSideEffectHandler(gate, finish) {
   taskSideEffectGates.push(gate);
-  taskSideEffectFinishFns.push(finish);
+  taskSideEffectFinishFns.push(ResourceAttribution$ReventlessCore.deferred(finish));
 }
 
 function finishTasks() {
@@ -102,7 +103,7 @@ function createReadModels(readModels, api, apiRole, componentRuntime, allEventTo
       {
         outputs: rmOutputs,
         operations: rmOperations,
-        finish: SpecificReadModel.finish
+        finish: ResourceAttribution$ReventlessCore.deferred(SpecificReadModel.finish)
       }
     ];
   });

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,