@reventlessdev/reventless-core 3.0.0-alpha.174 → 3.0.0-alpha.176

package/src/components/ReadModel/ReadModel_Builder.res

@@ -58,7 +58,12 @@ module Make = (
     let timeout = ReventlessInfra.RuntimeHints.resolveTimeout(runtime, ~default=30)
 
     module SpecificQueryDb = QueryDb_Builder.Make(Spec, QueryDbStorage, QueryDbResolvers)
-    let queryDb = SpecificQueryDb.make(~api, ~apiRole, ~opts)
+    let queryDb = SpecificQueryDb.make(
+      ~api,
+      ~apiRole,
+      ~owner={kind: ComponentType.ReadModel, name: Spec.name},
+      ~opts,
+    )
 
     let toProjectionOperations: SpecificQueryDb.operations => projectionOperations = ({
       load,
@@ -114,7 +119,12 @@ module Make = (
       ->Component.operations
       ->Pulumi.Output.apply(operations => {
         let eventTopics = allEventTopics->EventTopic.filter(sourceNames)
-        let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+        let eventCollector = SpecificEventCollector.make(
+          ~name,
+          ~eventTopics,
+          ~owner={kind: ComponentType.ReadModel, name: Spec.name},
+          ~opts,
+        )
 
         module Callback = ReadModel_Callback.Make(
           Spec,

package/src/components/ReadModel/ReadModel_Builder.res.mjs

@@ -27,7 +27,10 @@ function Make(Spec) {
       let memorySize = RuntimeHints$ReventlessInfra.resolveMemory(runtime, 1024);
       let timeout = RuntimeHints$ReventlessInfra.resolveTimeout(runtime, 30);
       let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make(Spec)(QueryDbStorage)(QueryDbResolvers);
-      let queryDb = SpecificQueryDb.make(api, apiRole, undefined, opts);
+      let queryDb = SpecificQueryDb.make(api, apiRole, undefined, {
+        kind: "ReadModel",
+        name: Spec.name
+      }, opts);
       let toProjectionOperations = param => {
         let deleteBatch = param.deleteBatch;
         let $$delete = param.delete;
@@ -64,7 +67,10 @@ function Make(Spec) {
       let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
       let eventCollector = Component$ReventlessCore.operations(queryDb).apply(operations => {
         let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, sourceNames);
-        let eventCollector = SpecificEventCollector.make(name, eventTopics, opts);
+        let eventCollector = SpecificEventCollector.make(name, eventTopics, {
+          kind: "ReadModel",
+          name: Spec.name
+        }, opts);
         let operations$1 = toProjectionOperations(operations);
         let Callback = ReadModel_Callback$ReventlessCore.Make(Spec)(Mappings)({
           ReadModelSpec: Spec,

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res

@@ -27,7 +27,12 @@ module Make = (
       ->Belt.Set.String.fromArray
 
     let eventTopics = allEventTopics->EventTopic.filter(aggregateNames)
-    let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+    let eventCollector = SpecificEventCollector.make(
+      ~name,
+      ~eventTopics,
+      ~owner={kind: ComponentType.SideEffectHandler, name},
+      ~opts,
+    )
 
     module Callback = SideEffectHandler_Callback.Make({
       let sideEffects = sideEffects

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res.mjs

@@ -24,7 +24,10 @@ function Make(RuntimeEnvironment) {
         };
         let aggregateNames = Belt_SetString.fromArray(sideEffects.map(SideEffect => SideEffect.Source.name));
         let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, aggregateNames);
-        let eventCollector = SpecificEventCollector.make(extra$1, eventTopics, opts);
+        let eventCollector = SpecificEventCollector.make(extra$1, eventTopics, {
+          kind: "SideEffectHandler",
+          name: extra$1
+        }, opts);
         let Callback = SideEffectHandler_Callback$ReventlessCore.Make({
           sideEffects: sideEffects,
           queryEngine: queryEngine

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -63,7 +63,12 @@ module Make = (
       let memorySize = ReventlessInfra.RuntimeHints.resolveMemory(runtime, ~default=1024)
       let timeout = ReventlessInfra.RuntimeHints.resolveTimeout(runtime, ~default=30)
 
-      let queryDb = SpecificQueryDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~opts)
+      let queryDb = SpecificQueryDb.make(
+        ~api=Api.api(),
+        ~apiRole=Api.apiRole(),
+        ~owner={kind: ComponentType.StateViewSlice, name: Spec.name},
+        ~opts,
+      )
 
       let dcbEventTopicOutputs: EventTopic.outputs = (dcbEventLog->Component.outputs).eventTopic
       let allEventTopics = Dict.fromArray([(Spec.name, dcbEventTopicOutputs)])
@@ -74,7 +79,12 @@ module Make = (
         ->Pulumi.Output.apply(queryDbOps => {
           let projectionOps = toProjectionOps(queryDbOps)
 
-          let ec = SpecificEventCollector.make(~name=Spec.name, ~eventTopics=allEventTopics, ~opts)
+          let ec = SpecificEventCollector.make(
+            ~name=Spec.name,
+            ~eventTopics=allEventTopics,
+            ~owner={kind: ComponentType.StateViewSlice, name: Spec.name},
+            ~opts,
+          )
 
           let comp = `StateViewSlice(${Spec.name})`
 

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

@@ -61,7 +61,10 @@ function Make(RuntimeEnvironment) {
         };
         let memorySize = RuntimeHints$ReventlessInfra.resolveMemory(runtime, 1024);
         let timeout = RuntimeHints$ReventlessInfra.resolveTimeout(runtime, 30);
-        let queryDb = SpecificQueryDb.make(Api.api(), Api.apiRole(), undefined, opts);
+        let queryDb = SpecificQueryDb.make(Api.api(), Api.apiRole(), undefined, {
+          kind: "StateViewSlice",
+          name: Spec.name
+        }, opts);
         let dcbEventTopicOutputs = Component$ReventlessCore.outputs(dcbEventLog).eventTopic;
         let allEventTopics = Object.fromEntries([[
             Spec.name,
@@ -69,7 +72,10 @@ function Make(RuntimeEnvironment) {
           ]]);
         let eventCollector = Component$ReventlessCore.operations(queryDb).apply(queryDbOps => {
           let projectionOps = toProjectionOps(queryDbOps);
-          let ec = SpecificEventCollector.make(Spec.name, allEventTopics, opts);
+          let ec = SpecificEventCollector.make(Spec.name, allEventTopics, {
+            kind: "StateViewSlice",
+            name: Spec.name
+          }, opts);
           let comp = `StateViewSlice(` + Spec.name + `)`;
           let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(stream), events => {
             let total = events.length.toString();

package/src/plugin/component/Plugin_Builder.res

@@ -67,6 +67,11 @@ module Make = (
     let _prevPluginName = Logger.currentPluginName.contents
     Logger.currentPluginName := Some(name)
 
+    // Publish the owning plugin/platform for resource attribution, so adapters
+    // creating infrastructure below this point can tag it without every adapter
+    // signature having to carry the two names. Restored at the end of construct.
+    let _prevAttribution = ResourceAttribution.enter(~platform=Spec.platformName, ~plugin=name)
+
     // Register every component → plugin so runtime logs (fired after construct
     // returns) can resolve a comp like `StateChangeSlice(AddProduct)` to its
     // owning plugin via `Logger.componentPluginRegistry`. Also register the
@@ -570,8 +575,8 @@ module Make = (
     let builderOutputs = {
       // Resolve admin extension point data — from Interstack (AWS cross-stack reference).
       let interstackAdminExtensionPoints =
-        Interstack.coreStackReference->Option.mapOr(Pulumi.Output.make(None), coreStack =>
-          coreStack->Pulumi.StackReference.getOutput("extensionPoints")
+        Interstack.platformStackReference->Option.mapOr(Pulumi.Output.make(None), platformStack =>
+          platformStack->Pulumi.StackReference.getOutput("extensionPoints")
         )
 
       // Derive local admin extension point resolved data (passed from makePlatform).
@@ -975,6 +980,7 @@ module Make = (
       )
 
     Logger.currentPluginName := _prevPluginName
+    ResourceAttribution.restore(_prevAttribution)
   }
 
   let makeAutoUIManifest = (

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

@@ -31,6 +31,7 @@ import * as AdapterDeploytime$ReventlessCore from "../../adapter/AdapterDeployti
 import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
 import * as ExtensionPoint$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/ExtensionPoint.res.mjs";
 import * as Heartbeat_Builder$ReventlessCore from "../../components/Heartbeat/Heartbeat_Builder.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.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";
 
@@ -121,6 +122,7 @@ function Make(Spec) {
       return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Plugin$ReventlessCore.componentType), name, (extra, extra$1) => {
         let _prevPluginName = Logger$ReventlessCore.currentPluginName.contents;
         Logger$ReventlessCore.currentPluginName.contents = extra$1;
+        let _prevAttribution = ResourceAttribution$ReventlessCore.enter(Spec.platformName, extra$1);
         Logger$ReventlessCore.registerComponentPlugin(extra$1, extra$1);
         aggregates.forEach(M => Logger$ReventlessCore.registerComponentPlugin(M.Spec.name, extra$1));
         readModels.forEach(R => Logger$ReventlessCore.registerComponentPlugin(R.Spec.name, extra$1));
@@ -397,7 +399,7 @@ function Make(Spec) {
             components: components
           });
         }
-        let interstackAdminExtensionPoints = Stdlib_Option.mapOr(Interstack$ReventlessCore.coreStackReference, Pulumi.output(undefined), coreStack => coreStack.getOutput("extensionPoints"));
+        let interstackAdminExtensionPoints = Stdlib_Option.mapOr(Interstack$ReventlessCore.platformStackReference, Pulumi.output(undefined), platformStack => platformStack.getOutput("extensionPoints"));
         let localAdminResolvedEP = Output$Pulumi.flatMap(Spec.hooks.adminExtensionPoints.contents, eps => {
           let ep = eps[PluginExtensionPointSpec$ReventlessInfra.name];
           if (ep !== undefined) {
@@ -626,6 +628,7 @@ function Make(Spec) {
         Component$ReventlessCore.setOutputs(extra, pluginOutputs);
         Plugin_Helpers$ReventlessCore.interopMetaOutput.contents = builderOutputs.apply(outputs => S.reverseConvertToJsonOrThrow(Plugin_Helpers$ReventlessCore.toInteropMeta(outputs), ExportMeta$ReventlessInterop.schema));
         Logger$ReventlessCore.currentPluginName.contents = _prevPluginName;
+        return ResourceAttribution$ReventlessCore.restore(_prevAttribution);
       }, opts);
     };
     return {

package/src/plugin/component/Plugin_Helpers.res

@@ -449,7 +449,7 @@ module MakeEventCollectorHelper = (
     EventCollectorChannel,
   )
   let make = (~name, ~eventTopics, ~opts) => {
-    let eventCollector = PluginEventCollector.make(~name, ~eventTopics, ~opts)
+    let eventCollector = PluginEventCollector.make(~name, ~eventTopics, ~owner={kind: ComponentType.Plugin, name}, ~opts)
     let eventCollectorOutputs = eventCollector->Component.outputs
     // pluginDefinition.eventCollector must identify the EC's inbound queue
     // ARN — admin's `manageSubscriptions` uses it as the subscription target

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

@@ -255,7 +255,10 @@ function MakeEventCollectorHelper(RuntimeEnvironment) {
   return EventCollectorChannel => (PluginRuntimeBuilder => {
     let PluginEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
     let make = (name, eventTopics, opts) => {
-      let eventCollector = PluginEventCollector.make(name, eventTopics, opts);
+      let eventCollector = PluginEventCollector.make(name, eventTopics, {
+        kind: "Plugin",
+        name: name
+      }, opts);
       let eventCollectorOutputs = Component$ReventlessCore.outputs(eventCollector);
       let resources = eventCollectorOutputs.resources;
       let r = resources[resources.length - 1 | 0];

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -47,7 +47,7 @@ module Make = (Spec: Spec) => {
       switch jsons {
       | [] =>
         EffectLogger.logWarn(
-          ~comp="Core.Plugin",
+          ~comp=PluginExtensionPointSpec.name,
           `ForwardCommand: Couldn't find Plugin with ExtensionPoint ${extensionPointName}`,
         )->Effect.runSync
       | plugins =>
@@ -66,28 +66,31 @@ module Make = (Spec: Spec) => {
             ) {
             | _ =>
               EffectLogger.logInfo(
-                ~comp="Core.Plugin",
+                ~comp=PluginExtensionPointSpec.name,
                 `ForwardCommand: published command to ${plugin.name} ${extensionPoint.commandTopic}`,
               )->Effect.runSync
             | exception err =>
               let errMsg =
                 err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
               EffectLogger.logError(
-                ~comp="Core.Plugin",
+                ~comp=PluginExtensionPointSpec.name,
                 `ForwardCommand: Error on publish command: ${errMsg}`,
               )->Effect.runSync
             }
 
           | None =>
             EffectLogger.logWarn(
-              ~comp="Core.Plugin",
+              ~comp=PluginExtensionPointSpec.name,
               `ForwardCommand: Couldn't find ExtensionPoint ${extensionPointName} in ${plugin.name}`,
             )->Effect.runSync
           }
         | exception err =>
           let errMsg =
             err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
-          EffectLogger.logError(~comp="Core.Plugin", `ForwardCommand: Couldn't decode Plugin: ${errMsg}`)->Effect.runSync
+          EffectLogger.logError(
+            ~comp=PluginExtensionPointSpec.name,
+            `ForwardCommand: Couldn't decode Plugin: ${errMsg}`,
+          )->Effect.runSync
         }
       }
     }
@@ -105,7 +108,7 @@ module Make = (Spec: Spec) => {
         rate: timeout->ScheduleOps.minutesFromNow,
         payload: {
           Message.id,
-          meta: Message.generateMeta(~service="Core.Plugin", ~user="Scheduler"),
+          meta: Message.generateMeta(~service=PluginExtensionPointSpec.name, ~user="Scheduler"),
           command: PluginExtensionPointSpec.DisconnectPlugin,
         }
         ->Message.encodeCommand'(S.string, PluginExtensionPointSpec.commandSchema)
@@ -155,7 +158,10 @@ module Make = (Spec: Spec) => {
           PublishCommand(Plugin.name(id), Delegate.Heartbeat(Plugin.version(id))),
           // Re-arm the disconnect schedule with an interval-scaled grace so a
           // single late beat doesn't trip a spurious disconnect (see disconnectGrace).
-          HandleDirective(directiveHandler, CreateDisconnectSchedule(id, disconnectGrace(interval))),
+          HandleDirective(
+            directiveHandler,
+            CreateDisconnectSchedule(id, disconnectGrace(interval)),
+          ),
         ]
       | RedetectPlugin(interval) => [
           // Deploy-time re-detect: drive Redetect (not Heartbeat) so an already-connected
@@ -163,7 +169,10 @@ module Make = (Spec: Spec) => {
           // re-arm the disconnect schedule exactly like a heartbeat so liveness tracking
           // continues from the deploy moment.
           PublishCommand(Plugin.name(id), Delegate.Redetect(Plugin.version(id))),
-          HandleDirective(directiveHandler, CreateDisconnectSchedule(id, disconnectGrace(interval))),
+          HandleDirective(
+            directiveHandler,
+            CreateDisconnectSchedule(id, disconnectGrace(interval)),
+          ),
         ]
       | ConnectPlugin(pluginDefinition) =>
         // Validate protocol versions declared by the connecting plugin.
@@ -172,7 +181,7 @@ module Make = (Spec: Spec) => {
         let protocolErrors =
           pluginDefinition.extensionProtocols->Array.flatMap(proto =>
             ReventlessInterop.Compat.validateProtocol(
-              ~host=ReventlessInterop.CompatMatrix.corePlugin,
+              ~host=ReventlessInterop.CompatMatrix.platformPlugin,
               ~extensionPointName=proto.extensionPointName,
               ~commandVersion=proto.commandVersion,
               ~eventVersion=proto.eventVersion,
@@ -180,7 +189,7 @@ module Make = (Spec: Spec) => {
           )
         let reportAction = if protocolErrors->Array.length > 0 {
           EffectLogger.logWarn(
-            ~comp="Core.Plugin",
+            ~comp=PluginExtensionPointSpec.name,
             `Protocol version mismatch for plugin ${pluginDefinition.id}: ${protocolErrors
               ->JSON.stringifyAny
               ->Option.getOr("[]")}`,
@@ -197,7 +206,9 @@ module Make = (Spec: Spec) => {
           PublishCommand(Plugin.name(id), Delegate.Disconnect(Plugin.version(id))),
           HandleDirective(directiveHandler, DeleteDisconnectSchedule(id)),
         ]
-      | ForwardCommand(forwardCommand) => [HandleDirective(directiveHandler, ForwardCommand(forwardCommand))]
+      | ForwardCommand(forwardCommand) => [
+          HandleDirective(directiveHandler, ForwardCommand(forwardCommand)),
+        ]
       // Routed to the UiFragmentRegistry slice by the sibling UI-fragment mapping, not the
       // Plugin aggregate — a no-op here.
       | RegisterUiFragment(_) => []
@@ -212,7 +223,10 @@ module Make = (Spec: Spec) => {
         // definition publish with `def.id` (= name@version), preserving the prior
         // cross-plugin wire id.
         | Delegate.VersionDetected(version) => [
-            PublishEvent(Plugin.makeId(id, version), PluginExtensionPointSpec.UnknownPluginDetected),
+            PublishEvent(
+              Plugin.makeId(id, version),
+              PluginExtensionPointSpec.UnknownPluginDetected,
+            ),
           ]
         | VersionConnected(pluginDefinition)
         | VersionPromoted(pluginDefinition) => [

package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs

@@ -43,7 +43,7 @@ function Make(Spec) {
       ]
     ], 1000);
     if (jsons.length === 0) {
-      return Effect.runSync(EffectLogger$ReventlessCore.logWarn("Core.Plugin", undefined, `ForwardCommand: Couldn't find Plugin with ExtensionPoint ` + extensionPointName));
+      return Effect.runSync(EffectLogger$ReventlessCore.logWarn(PluginExtensionPointSpec$ReventlessInfra.name, undefined, `ForwardCommand: Couldn't find Plugin with ExtensionPoint ` + extensionPointName));
     }
     let plugin = jsons[0];
     let exit = 0;
@@ -54,12 +54,12 @@ function Make(Spec) {
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
       let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
-      return Effect.runSync(EffectLogger$ReventlessCore.logError("Core.Plugin", undefined, `ForwardCommand: Couldn't decode Plugin: ` + errMsg));
+      return Effect.runSync(EffectLogger$ReventlessCore.logError(PluginExtensionPointSpec$ReventlessInfra.name, undefined, `ForwardCommand: Couldn't decode Plugin: ` + errMsg));
     }
     if (exit === 1) {
       let extensionPoint = plugin$1.extensionPoints.find(extensionPoint => extensionPoint.name === extensionPointName);
       if (extensionPoint === undefined) {
-        return Effect.runSync(EffectLogger$ReventlessCore.logWarn("Core.Plugin", undefined, `ForwardCommand: Couldn't find ExtensionPoint ` + extensionPointName + ` in ` + plugin$1.name));
+        return Effect.runSync(EffectLogger$ReventlessCore.logWarn(PluginExtensionPointSpec$ReventlessInfra.name, undefined, `ForwardCommand: Couldn't find ExtensionPoint ` + extensionPointName + ` in ` + plugin$1.name));
       }
       let exit$1 = 0;
       let val;
@@ -69,10 +69,10 @@ function Make(Spec) {
       } catch (raw_err$1) {
         let err$1 = Primitive_exceptions.internalToException(raw_err$1);
         let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err$1), Stdlib_JsExn.message), "unknown");
-        return Effect.runSync(EffectLogger$ReventlessCore.logError("Core.Plugin", undefined, `ForwardCommand: Error on publish command: ` + errMsg$1));
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(PluginExtensionPointSpec$ReventlessInfra.name, undefined, `ForwardCommand: Error on publish command: ` + errMsg$1));
       }
       if (exit$1 === 2) {
-        return Effect.runSync(EffectLogger$ReventlessCore.logInfo("Core.Plugin", undefined, `ForwardCommand: published command to ` + plugin$1.name + ` ` + extensionPoint.commandTopic));
+        return Effect.runSync(EffectLogger$ReventlessCore.logInfo(PluginExtensionPointSpec$ReventlessInfra.name, undefined, `ForwardCommand: published command to ` + plugin$1.name + ` ` + extensionPoint.commandTopic));
       }
     }
   };
@@ -85,7 +85,7 @@ function Make(Spec) {
           rate: ScheduleOps$ReventlessCore.minutesFromNow(directive._1),
           payload: JSON.stringify(Message$ReventlessCore.encodeCommand$p({
             id: id,
-            meta: Message$ReventlessCore.generateMeta("Core.Plugin", undefined, "Scheduler", undefined, undefined, undefined, undefined, undefined),
+            meta: Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, undefined, "Scheduler", undefined, undefined, undefined, undefined, undefined),
             command: "DisconnectPlugin"
           }, S.string, PluginExtensionPointSpec$ReventlessInfra.commandSchema))
         });
@@ -162,8 +162,8 @@ function Make(Spec) {
         ];
       case "ConnectPlugin" :
         let pluginDefinition = cmd._0;
-        let protocolErrors = pluginDefinition.extensionProtocols.flatMap(proto => Compat$ReventlessInterop.validateProtocol(CompatMatrix$ReventlessInterop.corePlugin, proto.extensionPointName, proto.commandVersion, proto.eventVersion));
-        let reportAction = protocolErrors.length !== 0 ? (Effect.runSync(EffectLogger$ReventlessCore.logWarn("Core.Plugin", undefined, `Protocol version mismatch for plugin ` + pluginDefinition.id + `: ` + Stdlib_Option.getOr(JSON.stringify(protocolErrors), "[]"))), [{
+        let protocolErrors = pluginDefinition.extensionProtocols.flatMap(proto => Compat$ReventlessInterop.validateProtocol(CompatMatrix$ReventlessInterop.platformPlugin, proto.extensionPointName, proto.commandVersion, proto.eventVersion));
+        let reportAction = protocolErrors.length !== 0 ? (Effect.runSync(EffectLogger$ReventlessCore.logWarn(PluginExtensionPointSpec$ReventlessInfra.name, undefined, `Protocol version mismatch for plugin ` + pluginDefinition.id + `: ` + Stdlib_Option.getOr(JSON.stringify(protocolErrors), "[]"))), [{
               TAG: "PublishCommand",
               _0: Plugin$ReventlessCore.name(id),
               _1: {

package/src/util/Interstack.res

@@ -1,4 +1,4 @@
-let coreStackReference =
+let platformStackReference =
   Pulumi.Config.make(Some("platform"))
   ->Pulumi.Config.get("stack")
   ->Option.map(stack =>

package/src/util/Interstack.res.mjs

@@ -10,7 +10,7 @@ import * as Query$ReventlessInterop from "@reventlessdev/reventless-interop/src/
 import * as EventMapper$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/EventMapper.res.mjs";
 import * as ExtensionPoint$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/ExtensionPoint.res.mjs";
 
-let coreStackReference = Stdlib_Option.map(new Pulumi.Config("platform").get("stack"), stack => new Pulumi.StackReference(stack + "-interstack", {
+let platformStackReference = Stdlib_Option.map(new Pulumi.Config("platform").get("stack"), stack => new Pulumi.StackReference(stack + "-interstack", {
   name: stack
 }));
 
@@ -115,7 +115,7 @@ let mergeEventMappers = DefaultEventMapperQuery.mergeWith;
 let mergeExtensionPoints = DefaultExtensionPointQuery.mergeWith;
 
 export {
-  coreStackReference,
+  platformStackReference,
   stackDependenciesTasks,
   stackDependenciesEventMappers,
   stackDependenciesExtensionPoints,
@@ -123,4 +123,4 @@ export {
   mergeEventMappers,
   mergeExtensionPoints,
 }
-/* coreStackReference Not a pure module */
+/* platformStackReference Not a pure module */

package/src/util/Interstack.resi

@@ -1,4 +1,4 @@
-let coreStackReference: option<Pulumi.StackReference.t>
+let platformStackReference: option<Pulumi.StackReference.t>
 
 let stackDependenciesTasks: Pulumi.Output.t<
   array<result<ReventlessInterop.Task.resolvedOutputs, ReventlessInterop.Compat.error>>,

package/src/util/Util_StackRefs.res

@@ -1,9 +1,9 @@
 let stackRefs: dict<Pulumi.StackReference.t> = Dict.make()
 
-let coreStackName = Pulumi.Config.make(Some("platform"))->Pulumi.Config.get("stack")
+let platformStackName = Pulumi.Config.make(Some("platform"))->Pulumi.Config.get("stack")
 
 let stackName = pluginName =>
-  coreStackName->Option.map(name => {
+  platformStackName->Option.map(name => {
     let parts = name->String.split("/")
     parts->Array.set(1, pluginName)
     parts->Array.joinUnsafe("/")

package/src/util/Util_StackRefs.res.mjs

@@ -6,10 +6,10 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 
 let stackRefs = {};
 
-let coreStackName = new Pulumi.Config("platform").get("stack");
+let platformStackName = new Pulumi.Config("platform").get("stack");
 
 function stackName(pluginName) {
-  return Stdlib_Option.map(coreStackName, name => {
+  return Stdlib_Option.map(platformStackName, name => {
     let parts = name.split("/");
     parts[1] = pluginName;
     return parts.join("/");
@@ -32,8 +32,8 @@ function get(pluginName) {
 
 export {
   stackRefs,
-  coreStackName,
+  platformStackName,
   stackName,
   get,
 }
-/* coreStackName Not a pure module */
+/* platformStackName Not a pure module */

package/tests/ResourceAttributionTest.res

@@ -0,0 +1,70 @@
+open JestGlobals
+
+// The attribution vocabulary is the shared contract between the AWS tag renderer
+// and the Kubernetes label renderer. These guard the wire spellings (which land
+// in deployed resource metadata and in downstream inventories) and the ambient
+// context's save/restore discipline, which is what keeps a plugin's resources
+// from being attributed to whichever plugin was constructed before it.
+
+module Attribution = ResourceAttribution
+
+describe("ResourceAttribution.Scope — wire spellings", () => {
+  testSync("scopes render lower-case", () => {
+    expect(
+      [Attribution.Scope.Component, Plugin, Platform]->Array.map(Attribution.Scope.toString),
+    )->toEqual(["component", "plugin", "platform"])
+  })
+})
+
+describe("ResourceAttribution.Role — wire spellings", () => {
+  testSync("piece roles render as their constructor name", () => {
+    expect(
+      [Attribution.Role.EventLog, QueryDb, Runtime, DeadLetter]->Array.map(
+        Attribution.Role.toString,
+      ),
+    )->toEqual(["EventLog", "QueryDb", "Runtime", "DeadLetter"])
+  })
+
+  testSync("Other carries the caller's name verbatim", () => {
+    expect(Attribution.Role.Other("ChangeFeed")->Attribution.Role.toString)->toBe("ChangeFeed")
+  })
+
+  testSync("platform-level things are Platform, not Core", () => {
+    // `Core` predates the platform/plugin split and names nothing the framework
+    // builds; it also reads as the built-in core PLUGIN, which is a different
+    // thing. Platform substrate is attributed to `Platform`, matching
+    // `reventless:platform` and `Scope.Platform`.
+    expect(ComponentType.Platform->ComponentType.toString)->toBe("Platform")
+    expect(ComponentType.ofString("Platform"))->toEqual(Some(ComponentType.Platform))
+  })
+
+  testSync("a role is NOT a component kind — Runtime has no ComponentType twin", () => {
+    // The whole point of splitting role from kind: `Runtime` is a deployment
+    // piece, not something the domain model can be. If this ever resolves, the
+    // two vocabularies have started to merge again.
+    expect(ComponentType.ofString("Runtime"))->toEqual(None)
+  })
+})
+
+describe("ResourceAttribution — ambient plugin context", () => {
+  testSync("outside any plugin construct, nothing is attributed", () => {
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+    expect(Attribution.current.contents.platform)->toEqual(None)
+  })
+
+  testSync("enter publishes the plugin and platform under construction", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Ordering")
+    expect(Attribution.current.contents.plugin)->toEqual(Some("Ordering"))
+    expect(Attribution.current.contents.platform)->toEqual(Some("online-shop"))
+    Attribution.restore(previous)
+  })
+
+  testSync("restore unwinds to the previous context, so plugins don't leak", () => {
+    let outer = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let inner = Attribution.enter(~platform="online-shop", ~plugin="Ordering")
+    Attribution.restore(inner)
+    expect(Attribution.current.contents.plugin)->toEqual(Some("Catalog"))
+    Attribution.restore(outer)
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+  })
+})

package/tests/aggregate/AggregateCacheTest.res

@@ -166,7 +166,7 @@ module TestOps = {
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     // Never called — satisfies module type only
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/aggregate/AggregateConflictTest.res

@@ -126,7 +126,7 @@ module TestOps = {
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/aggregate/AggregateFixtures.res

@@ -142,7 +142,7 @@ module TestOps = {
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     // Never called — satisfies module type only
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/aggregate/AggregateSnapshotTest.res

@@ -188,7 +188,7 @@ module MakeOps = (B: {let name: string}) => {
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/eventlog/EventLogFixtures.res

@@ -84,7 +84,7 @@ module MockEventTopic: EventTopic.T
     publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream,
   }
   type component = Component.t<EventTopic.t, EventTopic.outputs, operations>
-  let make = (~name as _, ~storageResources as _, ~opts as _=?): component => Obj.magic(0)
+  let make = (~name as _, ~storageResources as _, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
 }
 
 let mockEventTopicOps: MockEventTopic.operations = {