@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/component/Plugin_Helpers.res

@@ -0,0 +1,1730 @@
+let log = Logger.fromEnv()
+
+// Wrapper to safely store Pulumi Output values as option fields.
+// Pulumi Outputs are JS Proxies; wrapping them directly in Some() triggers
+// the BS_PRIVATE_NESTED_SOME_NONE sentinel bug.  Storing as {val: x} avoids
+// this because the plain record has no BS_PRIVATE_NESTED_SOME_NONE property.
+type hookedValue<'a> = {val: 'a}
+
+// Local-only intermediate type used by Plugin_Builder during construction.
+// All fields use Pulumi.Output.t-wrapped component output types because they
+// originate from freshly-built local components (not deserialized stack exports).
+// Cross-stack consumers use ReventlessInterop.Plugin.resolvedOutputs instead.
+type builderOutputs = {
+  id: string,
+  version: string,
+  heartbeatInterval: int,
+  eventCollector: EventCollector.outputs,
+  extensionPoints: dict<ExtensionPoint.outputs>,
+  extensions: dict<Extension.outputs>,
+  aggregates: dict<Aggregate.outputs>,
+  stateChangeSlices: dict<StateChangeSlice.outputs>,
+  stateViewSlices: dict<StateViewSlice.outputs>,
+  automationSlices: dict<AutomationSlice.outputs>,
+  outboundTranslationSlices: dict<OutboundTranslationSlice.outputs>,
+  inboundTranslationSlices: dict<InboundTranslationSlice.outputs>,
+  readModels: dict<ReadModel.outputs>,
+  tasks: dict<Task.outputs>,
+  resolvers: array<ReventlessInfra.Adapter.resource>,
+  heartbeat: Heartbeat.outputs,
+  dcbEventLog: option<DcbEventLog.outputs>,
+  uiFragments: option<Reventless.Plugin.uiFragmentManifest>,
+}
+
+let getRemoteStorageResources = (pluginName, queryDbName) =>
+  switch Util_StackRefs.get(pluginName)->Option.map(stackRef => {
+    // Read the "readModels" top-level export directly (no longer nested under "plugin").
+    let readModelsOutput: Pulumi.Output.t<option<JSON.t>> =
+      stackRef->Pulumi.StackReference.getOutput("readModels")
+
+    readModelsOutput->Pulumi.Output.apply(readModelsOpt =>
+      switch readModelsOpt {
+      | Some(rawReadModels) =>
+        switch rawReadModels->JSON.Decode.object {
+        | Some(dict) =>
+          switch dict->Dict.get(queryDbName) {
+          | Some(rawReadModel) =>
+            try {
+              let readModel =
+                rawReadModel->S.parseOrThrow(ReventlessInterop.ReadModel.resolvedOutputsSchema)
+              readModel.queryDb.resources->Adapter.fromInteropResources
+            } catch {
+            | exn =>
+              let msg =
+                exn
+                ->JsExn.fromException
+                ->Option.flatMap(JsExn.message)
+                ->Option.getOr("parse error")
+              log.error(
+                ~comp="Plugin_Helpers",
+                `getRemoteStorageResources: failed to parse readModel ${queryDbName} from ${pluginName}: ${msg}`,
+              )
+              []
+            }
+          | None => []
+          }
+        | None => []
+        }
+      | None => []
+      }
+    )
+  }) {
+  | Some(resources) => resources
+  | None =>
+    let known = Util_StackRefs.stackRefs->Dict.keysToArray->Array.join(",")
+    log.error(
+      ~comp="Plugin_Helpers",
+      `getRemoteStorageResources: plugin ${pluginName} not found (check platform.stack config) known=[${known}]`,
+    )
+    []->Pulumi.Output.make
+  }
+
+let getStorageResources = (allQueryDbs, pluginName, queryDbName) =>
+  switch pluginName {
+  | None => Util_QueryDb.getLocalStorageResources(allQueryDbs, queryDbName)->Pulumi.Output.make
+  | Some(pluginName) => getRemoteStorageResources(pluginName, queryDbName)
+  }
+
+// ---------------------------------------------------------------------------
+// Plugin EventCollector context registry.
+//
+// Adapter runtime entry points (e.g. AdminEventCollectorEntryPoint.mjs) read
+// HANDLER_CONFIG to reconstruct Plugin_Callback at cold start. The JSON payload
+// is assembled at deploy time inside `forPluginEventCollector` (AWS), but the
+// plugin-specific data (pluginDefinition, the auto-included Connect extension
+// entry, the admin EP cmd-topic URL the extension publishes to) is only known
+// inside `Plugin_Helpers.connect` / `Platform_Admin.connect` where the relevant
+// Outputs have resolved.
+//
+// The registry bridges that gap: core's connect helpers register the per-plugin
+// context here keyed by EventCollector component name; the AWS adapter reads it
+// when building the Lambda's HANDLER_CONFIG. Adapters that don't need it (in-
+// memory) simply ignore the ref.
+//
+// moduleUrl strings are hardcoded framework-internal paths (Admin Plugin EP +
+// PluginConnectExtension only — both ship from reventless-core/-infra). When
+// user-declared extensions land, propagate Blueprint.moduleUrl through the
+// registry too — likely by extending `Plugin_Helpers.createExtensions` to
+// capture each blueprint's moduleUrl into its returned tuple.
+// ---------------------------------------------------------------------------
+
+type extensionPointEntry = {
+  specModule: string,
+  mappingsModule: string,
+  eventTopicArn: Pulumi.Output.t<string>,
+  aggregateNames: array<string>,
+}
+
+type connectExtensionEntry = {
+  specModule: string,
+  mappingsModule: string,
+  extensionPointName: string,
+}
+
+// User-declared extension entry — one per merged extension group (multiple
+// `*_Extension.res` files targeting the same EP combine into one component).
+type extensionEntry = {
+  name: string,
+  specModule: string,
+  mappingsModule: string,
+  // npm specifier of the Delegate spec (aggregate / slice). The bundled Plugin
+  // EventCollector entry point dynamic-imports this at cold start to
+  // reconstruct `Mapping.Delegate` before handing the full mapping to
+  // ExtensionMapping.Make.
+  delegateModule: string,
+  extensionPointName: string,
+  // Subset of top-level publishToAggregates this extension publishes to —
+  // derived from Extension.outputs.aggregateNames.
+  aggregateNames: array<string>,
+  // RMs this extension's mapping may enqueue events into directly. Derived
+  // from readModelNamesForSourceName by reverse lookup on the extension's
+  // EP name (the source carried on incoming events).
+  readModelNames: array<string>,
+}
+
+type eventCollectorContext = {
+  // Pre-serialised JSON of the pluginDefinition (sury-encoded then JSON.stringify).
+  // Output because it's assembled from resolved component outputs at deploy time.
+  pluginDefinitionJson: Pulumi.Output.t<string>,
+  // Outgoing EPs whose events this Lambda's mapping handles. Admin Lambda: 1
+  // entry (its own Plugin EP). Plugin Lambda: 0 (plugins don't process their own
+  // EP outgoing events here).
+  extensionPoints: array<extensionPointEntry>,
+  // The auto-included PluginConnectExtension entry. Some for plugins; None for
+  // the admin Lambda (the admin IS the Plugin EP, doesn't consume it).
+  connectExtension: option<connectExtensionEntry>,
+  // User-declared extensions on this plugin. Empty for the admin Lambda.
+  extensions: array<extensionEntry>,
+  // SQS URL of the admin's Plugin EP command topic — where extensions publish
+  // ConnectPlugin commands via `publishToPluginExtensionPoint`. Empty string
+  // for admin (no extensions consume it).
+  pluginExtensionPointCmdTopicUrl: Pulumi.Output.t<string>,
+  // aggregateName → cmd-topic SQS URL. Includes every aggregate / DCB slice
+  // any user extension publishes to plus the admin's Plugin aggregate when
+  // ConnectExtension is wired.
+  publishToAggregates: dict<Pulumi.Output.t<string>>,
+  // rmName → RM EventCollector SQS URL. Populated only for RMs that user
+  // extensions feed directly via Extension_Operations.publishToReadModels.
+  readModelQueueUrls: dict<Pulumi.Output.t<string>>,
+  // Inversion of RM.sourceNames — sourceServiceName → [rmName]. Same dict
+  // surface used by Builder_Helpers; serialised verbatim into HANDLER_CONFIG.
+  readModelNamesForSourceName: dict<array<string>>,
+}
+
+let eventCollectorContextRef: ref<dict<eventCollectorContext>> = ref(Dict.make())
+
+let registerEventCollectorContext = (~componentName: string, ~context: eventCollectorContext) =>
+  eventCollectorContextRef.contents->Dict.set(componentName, context)
+
+// Framework-internal module URLs for the auto-Connect path — package specifiers
+// the bundled EventCollector resolves (NOT file URLs). The two mapping specifiers
+// are sourced from each module's `@@reventless.spec`-injected `moduleUrl`
+// (derived from the file path, so they survive folder moves) rather than
+// hardcoded. The spec specifier lives in reventless-infra (whose own `moduleUrl`
+// is an `import.meta.url` file URL, the wrong form here), so it stays an explicit
+// package specifier.
+// User-declared extensions will eventually need to propagate their own URLs
+// via createExtensions; this scope only covers the built-in Plugin EP + Connect.
+let adminPluginExtensionPointSpecModule =
+  "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs"
+let adminPluginExtensionPointMappingsModule = PluginExtensionPoint_Plugin.moduleUrl
+// Runtime-safe mapping module (not the `_Builder` variant, which the Lambda layer
+// strips because it pulls Pulumi via `include Extension_Builder.Make(...)`).
+let pluginConnectExtensionMappingsModule = PluginConnectExtension_Mapping.moduleUrl
+
+type jsonEventsHandler = Plugin_Callback.jsonEventsHandler
+type jsonEventsHandlers = {
+  outgoing?: jsonEventsHandler,
+  incoming?: jsonEventsHandler,
+}
+let getIncomingJsonEventsHandler = jsonEventsHandlers => jsonEventsHandlers.incoming
+let getOutgoingJsonEventsHandler = jsonEventsHandlers => jsonEventsHandlers.outgoing
+
+let serviceNameToJsonEventsHandlers: (
+  array<'o>,
+  'o => array<string>,
+  array<jsonEventsHandlers>,
+  jsonEventsHandlers => option<jsonEventsHandler>,
+) => dict<array<jsonEventsHandler>> = (outputs, getServiceNames, handlers, getEventHandler) => {
+  let dict = Dict.make()
+  Array.zip(outputs, handlers)->Array.forEach(((outputs, jsonEventsHandlers)) => {
+    jsonEventsHandlers
+    ->getEventHandler
+    ->Option.forEach(jsonEventsHandler =>
+      outputs
+      ->getServiceNames
+      ->Array.forEach(
+        serviceName =>
+          switch dict->Dict.get(serviceName) {
+          | Some(jsonEventsHandlers) =>
+            Dict.set(dict, serviceName, jsonEventsHandlers->Array.concat([jsonEventsHandler]))
+          | None => Dict.set(dict, serviceName, [jsonEventsHandler])
+          },
+      )
+    )
+  })
+  dict
+}
+
+include Builder_Helpers
+
+module ApiNoApi = ApiNoApiHelpers
+
+let isNoApi = ApiNoApi.isNoApi
+let getExcludedVariants = ApiNoApi.getExcludedVariants
+let filterNoApiVariants = ApiNoApi.filterNoApiVariants
+
+// Side-output of `createExtensions`: per merged-group registry data the
+// adapter entry point reconstructs Extension_Operations from. Lives next to
+// the existing `extensionsOutputs` / `extensionsHandlers` arrays — same
+// indexing.
+type extensionRegistryInfo = {
+  specModule: string,
+  mappingsModule: string,
+  delegateModule: string,
+}
+
+let createExtensions = (
+  extensions: array<module(ReventlessInfra.Extension.Blueprint)>,
+  ~pluginName,
+  ~publishToPluginExtensionPoint,
+  ~publishToAggregates,
+  ~publishToReadModels,
+  ~queryEngine,
+  ~opts,
+) => {
+  // Group blueprints by extension point name for auto-merge.
+  let groups: dict<array<module(ReventlessInfra.Extension.Blueprint)>> = Dict.make()
+  extensions->Array.forEach(bp => {
+    let module(BP: ReventlessInfra.Extension.Blueprint) = bp
+    let epName = BP.Spec.name
+    switch groups->Dict.get(epName) {
+    | Some(existing) => existing->Array.push(bp)
+    | None => groups->Dict.set(epName, [bp])
+    }
+  })
+
+  // For each EP group: merge mappings, build Extension component.
+  let triples = groups
+  ->Dict.toArray
+  ->Array.map(((_epName, blueprints)) => {
+    // Use the first blueprint's Spec as the canonical type.
+    let module(First: ReventlessInfra.Extension.Blueprint) = blueprints->Array.getUnsafe(0)
+
+    // Merge all mappings arrays. Blueprints for the same EP have the same Spec
+    // at runtime — use Obj.magic to unify the existential Mapping types.
+    let allMappings: array<module(First.Mapping)> =
+      blueprints->Array.flatMap(bp => {
+        let module(BP: ReventlessInfra.Extension.Blueprint) = bp
+        (BP.mappings: array<module(BP.Mapping)>)->Obj.magic
+      })
+
+    // Build the Extension component with pluginName as the extension name.
+    module Spec = First.Spec
+    module Mappings: Extension.Mappings with module Spec := Spec = {
+      module type Mapping = ReventlessInfra.ExtensionMapping.T
+        with module ExtensionPoint := Spec
+      let name = pluginName
+      let moduleUrl = First.moduleUrl
+      let mappings: array<module(Mapping)> = allMappings->Obj.magic
+    }
+    module ExtensionMaker = Extension_Builder.Make(Spec, Mappings)
+
+    let extension = ExtensionMaker.make(
+      ~publishToPluginExtensionPoint,
+      ~publishToAggregates,
+      ~readModelNamesForSourceName,
+      ~publishToReadModels,
+      ~queryEngine,
+      ~opts=Some(opts),
+    )
+    let ops: Pulumi.Output.t<Extension.operations> =
+      ExtensionMaker.operations(extension)->Obj.magic
+    let registryInfo: extensionRegistryInfo = {
+      // EP spec module URL (e.g. OrderingSpec/.../Orders_ExtensionPoint.res.mjs)
+      specModule: Spec.moduleUrl,
+      // User extension file URL — the .res.mjs declaring `module Mapping`.
+      // The bundled Plugin EventCollector entry point dynamic-imports this to
+      // pick up mapIncomingEvent / mapOutgoingEvent. Multi-blueprint merges
+      // still surface one path here so the runtime has one known module to
+      // import; the entry point regroups by extensionPointName.
+      mappingsModule: First.moduleUrl,
+      // Delegate spec URL (aggregate / slice the extension delegates to).
+      // The entry point dynamic-imports this to reconstruct
+      // `Mapping.Delegate` before handing the full mapping to ExtensionMapping.Make.
+      delegateModule: First.delegateModuleUrl,
+    }
+    (
+      ExtensionMaker.outputs(extension),
+      ops->Pulumi.Output.apply(({outgoingJsonEventsHandler, incomingJsonEventsHandler}) => {
+        incoming: incomingJsonEventsHandler,
+        outgoing: outgoingJsonEventsHandler,
+      }),
+      registryInfo,
+    )
+  })
+  let outputs = triples->Array.map(((o, _, _)) => o)
+  let handlers = triples->Array.map(((_, h, _)) => h)
+  let registryInfos = triples->Array.map(((_, _, r)) => r)
+  (outputs, handlers, registryInfos)
+}
+
+let extractExtensionPointDefinitions = (extensionPointsOutputs: array<ExtensionPoint.outputs>) =>
+  extensionPointsOutputs
+  ->Array.map(extensionPointOutputs =>
+    (
+      extensionPointOutputs.commandTopic->Pulumi.Output.flatMap(({resources}) =>
+        switch resources->Array.get(0) {
+        | Some(r) => r.id
+        | None => Pulumi.Output.make("")
+        }
+      ),
+      extensionPointOutputs.eventTopic->Pulumi.Output.flatMap(({resources}) =>
+        switch resources->Array.get(0) {
+        | Some(r) => r.id
+        | None => Pulumi.Output.make("")
+        }
+      ),
+    )
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((commandTopicChannelId, eventTopicPublisherId)) => {
+      Reventless.Plugin.name: extensionPointOutputs.name,
+      commandTopic: commandTopicChannelId,
+      eventTopic: eventTopicPublisherId,
+    })
+  )
+  ->Pulumi.Output.all
+
+// `dcbSources` lists cross-plugin DCB EventLog names this extension consumes.
+// Empty for now: the current Extension model is mono-source (single EP Spec).
+// Future work will populate this by walking extension blueprint mappings for
+// `Source { name = "<peer>DcbEventLog" }` declarations.
+let extractExtensionDefinitions = (extensionsOutputs: array<Extension.outputs>) =>
+  extensionsOutputs->Array.map(extensionOutputs => {
+    Reventless.Plugin.name: extensionOutputs.name,
+    extensionPointName: extensionOutputs.extensionPointName,
+    dcbSources: [],
+  })
+
+let createConnectPluginExtension = (
+  ~pluginDefinition,
+  ~publishToPluginExtensionPoint,
+  ~publishToAggregates,
+  ~readModelNamesForSourceName,
+  ~publishToReadModels,
+  ~queryEngine,
+  ~opts,
+) =>
+  pluginDefinition
+  ->Pulumi.Output.apply(pluginDefinition => {
+    module ConnectPluginExtension = PluginConnectExtension_Builder.Make({
+      let pluginDefinition = pluginDefinition
+    })
+    let connectPluginExtension = ConnectPluginExtension.make(
+      ~publishToPluginExtensionPoint,
+      ~publishToAggregates,
+      ~readModelNamesForSourceName,
+      ~publishToReadModels,
+      ~queryEngine,
+      ~opts=Some(opts),
+    )
+    let connectPluginExtensionOutputs = connectPluginExtension->Component.outputs
+    let connectPluginExtensionIncomingEventHandler =
+      connectPluginExtension
+      ->Component.operations
+      ->Pulumi.Output.apply(({incomingJsonEventsHandler}) => incomingJsonEventsHandler)
+
+    (connectPluginExtensionOutputs, connectPluginExtensionIncomingEventHandler)
+  })
+  ->Pulumi.Output.unzip
+
+let tasksOutputs = ref([])
+
+let createTasks = (
+  tasks,
+  ~aggregatesOutputs,
+  ~scheduler,
+  ~schedulerRoleUrn,
+  ~publishToAggregates,
+  ~queryEngine,
+  ~resourceNaming,
+  ~opts,
+) => {
+  tasksOutputs :=
+    tasks->Array.map((module(SpecificTask: ReventlessInfra.Task.T)) =>
+      SpecificTask.outputs(SpecificTask.make(
+        ~queryBucketName=(~taskName, ~bucketName="Bucket") =>
+          ResourceQueryRuntime.bucketNameOfTaskExn(tasksOutputs.contents, ~taskName, ~bucketName),
+        ~scheduler,
+        ~schedulerRoleUrn,
+        ~publishToAggregates,
+        ~queryEngine,
+        ~resourceNaming,
+        ~allAggregates=aggregatesOutputs,
+        ~opts=Some(opts),
+      ))
+    )
+  tasksOutputs.contents
+}
+
+module MakeEventCollectorHelper = (
+  RuntimeEnvironment: Runtime.Environment,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  PluginRuntimeBuilder: PluginRuntime_Builder.T
+    with module EventCollectorChannel = EventCollectorChannel,
+) => {
+  module PluginEventCollector = EventCollector_Builder.Make(
+    RuntimeEnvironment,
+    EventCollectorChannel,
+  )
+  let make = (~name, ~eventTopics, ~opts) => {
+    let eventCollector = PluginEventCollector.make(~name, ~eventTopics, ~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
+    // (SNS topic → SQS endpoint). The AWS SQS EventCollectorChannel appends
+    // the queue resource AFTER the upstream event-topic resources in its
+    // `channel.resources` list, so the queue is always the last element.
+    // Earlier this picked `resources[0]`, which silently selected the first
+    // subscribed event topic (e.g. a DCB EventLog DynamoDB stream ARN) and
+    // produced "Invalid parameter: SQS endpoint ARN" errors at subscribe
+    // time. In-memory adapters don't use this field (no SNS), so the choice
+    // there is moot.
+    let resources = eventCollectorOutputs.resources
+    let eventCollectorUrn = switch resources->Array.get(resources->Array.length - 1) {
+    | Some(r) => r.urn
+    | None => Pulumi.Output.make("")
+    }
+
+    (eventCollector, eventCollectorOutputs, eventCollectorUrn)
+  }
+
+  // Unified connect — handles both with-admin and without-admin cases.
+  // When ~pluginExtensionPointUnwrapped is provided, admin extension point
+  // resources and ConnectPluginExtension handlers are wired.  Otherwise falls
+  // back to a simplified path (no admin extension point resources, empty
+  // incoming connect extension handlers).
+  let connect = (
+    ~eventCollector: EventCollector.component,
+    ~eventTopics: EventTopic.allOutputs,
+    ~extensionPointsOutputs: array<ExtensionPoint.outputs>,
+    ~extensionsOutputs: array<Extension.outputs>,
+    ~pluginExtensionPointUnwrapped: option<ReventlessInterop.ExtensionPoint.resolvedOutputs>=?,
+    ~pluginDefinition,
+    ~connectPluginExtensionIncomingEventHandler: option<Pulumi.Output.t<Pulumi.Output.t<Plugin_Callback.jsonEventsHandler>>>=?,
+    ~extensionsHandlers,
+    ~extensionPointsHandlers,
+    ~connectPluginExtensionOutputs: option<Pulumi.Output.t<Extension.outputs>>=?,
+    // Per-extension registry metadata (parallel to extensionsOutputs / extensionsHandlers).
+    // Empty when there are no user extensions or when the caller doesn't need
+    // bundled-handler reconstruction (e.g. Platform_Admin path).
+    ~extensionRegistryInfos: array<extensionRegistryInfo>=[],
+    // Per-extension-point registry metadata (parallel to extensionPointsOutputs /
+    // extensionPointsHandlers). Carries spec + mapping module URLs the
+    // EventCollector entry point dynamic-imports to publish outgoing events.
+    // Empty when there are no user extension points (e.g. Platform_Admin path).
+    ~extensionPointRegistryInfos: array<Builder_Helpers.extensionPointRegistryInfo>=[],
+    // aggregateName → cmd-topic SQS URL. Includes every aggregate / DCB slice
+    // that a user extension may publish to. The full plugin dict is fine —
+    // the runtime filters to ext.aggregateNames when invoking each extension.
+    ~aggregateQueueUrls: dict<Pulumi.Output.t<string>>=Dict.make(),
+    // rmName → RM EventCollector SQS URL. Populated only for RMs that
+    // user extensions may enqueue events into directly. Plugin RMs fed
+    // through the normal EventTopic → EventColl subscription path don't
+    // need entries here.
+    ~readModelQueueUrls: dict<Pulumi.Output.t<string>>=Dict.make(),
+    // The global readModelNamesForSourceName inversion (sourceName → [rmName]).
+    // Plain dict — no Pulumi outputs because it's pure name metadata.
+    ~readModelNamesForSourceName: dict<array<string>>=Dict.make(),
+  ) => {
+    let resources =
+      extensionPointsOutputs
+      ->Array.map(extensionPoint => extensionPoint.eventTopic)
+      ->Pulumi.Output.all
+      ->Pulumi.Output.apply(eventTopics => {
+        let base =
+          eventTopics
+          ->Array.map(eventTopic => eventTopic.resources)
+          ->Array.flat
+        switch pluginExtensionPointUnwrapped {
+        | Some(unwrapped) =>
+          base->Array.concat(unwrapped.commandTopic.resources->Adapter.fromInteropResources)
+        | None => base
+        }
+      })
+
+    // Resolve ConnectPluginExtension data (or provide defaults for no-Core path)
+    let connectExtData =
+      switch (connectPluginExtensionIncomingEventHandler, connectPluginExtensionOutputs) {
+      | (Some(handler), Some(outputs)) =>
+        (handler->Pulumi.Output.unwrap, outputs)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((h, o)) => Some((h, o)))
+      | _ => Pulumi.Output.make(None)
+      }
+
+    (
+      pluginDefinition,
+      connectExtData,
+      extensionsHandlers->Pulumi.Output.all,
+      extensionPointsHandlers->Pulumi.Output.all,
+      resources,
+    )
+    ->Pulumi.Output.all5
+    ->Pulumi.Output.apply(((
+      pluginDefinition,
+      connectExtData,
+      extensionsHandlers,
+      extensionPointsHandlers,
+      resources,
+    )) => {
+      let incomingConnectExtensionEventHandlers = switch connectExtData {
+      | Some((handler, outputs)) =>
+        serviceNameToJsonEventsHandlers(
+          [outputs],
+          outputs => [outputs.extensionPointName],
+          [{incoming: handler}],
+          getIncomingJsonEventsHandler,
+        )
+      | None => Dict.make()
+      }
+      module Callback = Plugin_Callback.Make({
+        let pluginDefinition = pluginDefinition
+        let outgoingExtensionPointEventHandlers = serviceNameToJsonEventsHandlers(
+          extensionPointsOutputs,
+          outputs => outputs.aggregateNames,
+          extensionPointsHandlers->Array.map(extensionPointsHandler => {
+            outgoing: extensionPointsHandler,
+          }),
+          getOutgoingJsonEventsHandler,
+        )
+        let incomingConnectExtensionEventHandlers = incomingConnectExtensionEventHandlers
+        let outgoingExtensionEventHandlers = serviceNameToJsonEventsHandlers(
+          extensionsOutputs,
+          outputs => outputs.aggregateNames,
+          extensionsHandlers,
+          getOutgoingJsonEventsHandler,
+        )
+        let incomingExtensionEventHandlers = serviceNameToJsonEventsHandlers(
+          extensionsOutputs,
+          outputs => [outputs.extensionPointName],
+          extensionsHandlers,
+          getIncomingJsonEventsHandler,
+        )
+      })
+      let handler = PluginEventCollector.makeHandler(
+        ~eventCollector,
+        ~jsonEventsHandler=Callback.handleJsonEvents,
+      )
+
+      // Register the runtime context the adapter entry point reconstructs from
+      // HANDLER_CONFIG. AWS reads this in forPluginEventCollector; in-memory
+      // adapters ignore it and stay on the Output-bound Callback above.
+      let ecResource = eventCollector->Component.toPulumiResource
+      let ecName =
+        ecResource.name->ComponentType.nameOpt(EventCollector.componentType)
+      let pluginDefinitionJson =
+        pluginDefinition
+        ->S.reverseConvertToJsonOrThrow(Reventless.Plugin.pluginDefinitionSchema)
+        ->JSON.stringify
+        ->Pulumi.Output.make
+      let pluginExtensionPointCmdTopicUrl = switch pluginExtensionPointUnwrapped {
+      | Some(unwrapped) =>
+        switch unwrapped.commandTopic.resources->Array.get(0) {
+        | Some(r) => Pulumi.Output.make(r.id)
+        | None => Pulumi.Output.make("")
+        }
+      | None => Pulumi.Output.make("")
+      }
+      let connectExtension = switch connectExtData {
+      | Some(_) =>
+        Some({
+          specModule: adminPluginExtensionPointSpecModule,
+          mappingsModule: pluginConnectExtensionMappingsModule,
+          extensionPointName: ReventlessInfra.PluginExtensionPointSpec.name,
+        })
+      | None => None
+      }
+      // Build the user-extension registry entries. Each entry pairs
+      // Extension.outputs (name/EP name/aggregate names) with the matching
+      // moduleUrls captured by createExtensions. Skipped if the parallel
+      // arrays don't match length — defensive against future refactors.
+      let extensions: array<extensionEntry> = if (
+        extensionsOutputs->Array.length == extensionRegistryInfos->Array.length
+      ) {
+        extensionsOutputs->Array.mapWithIndex((output, i) => {
+          let info = extensionRegistryInfos->Array.getUnsafe(i)
+          let rmNames =
+            readModelNamesForSourceName
+            ->Dict.get(output.extensionPointName)
+            ->Option.getOr([])
+          {
+            name: output.name,
+            specModule: info.specModule,
+            mappingsModule: info.mappingsModule,
+            delegateModule: info.delegateModule,
+            extensionPointName: output.extensionPointName,
+            aggregateNames: output.aggregateNames,
+            readModelNames: rmNames,
+          }
+        })
+      } else {
+        []
+      }
+      // Connect always publishes to the admin's Plugin aggregate. When
+      // user extensions are wired, merge their aggregate URLs in as well —
+      // the runtime filters per extension.
+      let mergedAggregateUrls = Dict.make()
+      aggregateQueueUrls
+      ->Dict.toArray
+      ->Array.forEach(((k, v)) => mergedAggregateUrls->Dict.set(k, v))
+      switch connectExtData {
+      | Some(_) =>
+        // Plugin aggregate cmd-topic URL = the admin's Plugin EP cmd topic
+        // (Connect routes ConnectPlugin through the EP). Look it up if not
+        // already supplied by the caller.
+        switch mergedAggregateUrls->Dict.get(ReventlessCore.PluginSpec.name) {
+        | Some(_) => ()
+        | None => mergedAggregateUrls->Dict.set(ReventlessCore.PluginSpec.name, pluginExtensionPointCmdTopicUrl)
+        }
+      | None => ()
+      }
+      // Build the extension-point registry entries (mirrors the user-extension
+      // pattern above). Pairs Pulumi outputs (name / eventTopic / aggregateNames)
+      // with the moduleUrls captured by createExtensionPoints. Skipped if the
+      // parallel arrays don't match length — defensive against future refactors.
+      let extensionPointEntries: array<extensionPointEntry> = if (
+        extensionPointsOutputs->Array.length == extensionPointRegistryInfos->Array.length
+      ) {
+        extensionPointsOutputs->Array.mapWithIndex((output, i) => {
+          let info = extensionPointRegistryInfos->Array.getUnsafe(i)
+          let eventTopicArn =
+            output.eventTopic->Pulumi.Output.flatMap(({resources}) =>
+              switch resources->Array.get(0) {
+              | Some(r) => r.id
+              | None => Pulumi.Output.make("")
+              }
+            )
+          {
+            specModule: info.specModule,
+            mappingsModule: info.mappingsModule,
+            eventTopicArn,
+            aggregateNames: output.aggregateNames,
+          }
+        })
+      } else {
+        []
+      }
+      registerEventCollectorContext(
+        ~componentName=ecName,
+        ~context={
+          pluginDefinitionJson,
+          extensionPoints: extensionPointEntries,
+          connectExtension,
+          extensions,
+          pluginExtensionPointCmdTopicUrl,
+          publishToAggregates: mergedAggregateUrls,
+          readModelQueueUrls,
+          readModelNamesForSourceName,
+        },
+      )
+
+      eventCollector->PluginRuntimeBuilder.forPluginEventCollector(
+        ~handler,
+        ~eventTopics,
+        ~resources,
+      )
+
+      let _ = switch (eventCollector->Component.outputs).resources->Array.get(0) {
+      | Some(r) => r.urn->Pulumi.Output.apply(urn => pluginDefinition.eventCollector = urn)
+      | None => Pulumi.Output.make()
+      }
+    })
+  }
+}
+
+
+// ---------------------------------------------------------------------------
+// Shared schema type and plugin-built hook — re-exported from Plugin_Callbacks
+// (runtime-safe, no Pulumi imports) for backward compatibility.
+// ---------------------------------------------------------------------------
+include Plugin_BuiltHook
+
+// ---------------------------------------------------------------------------
+// Plugin-deployed hook — fires inside Output.apply after all component
+// resources have resolved, providing fully resolved resource data.
+// ---------------------------------------------------------------------------
+type pluginDeployedSubComponent = {
+  role: string,
+  resources: array<ReventlessInterop.Resource.t>,
+}
+
+type pluginDeployedComponent = {
+  name: string,
+  kind: string,
+  schema: pluginDeployedSchema,
+  resources: array<ReventlessInterop.Resource.t>,
+  subComponents: array<pluginDeployedSubComponent>,
+}
+
+type extensionWiring = {
+  extensionName: string,
+  extensionPointName: string,
+  providerPlugin: string,
+  providerVersion: string,
+  subscriberPlugin: string,
+  subscriberVersion: string,
+}
+
+type pluginDeployedInfo = {
+  name: string,
+  version: string,
+  environment: string,
+  stackName: string,
+  deployedAt: string,
+  actor: string,
+  deploymentId: string,
+  kind?: pluginKind,
+  displayName?: string,
+  vendor?: string,
+  architectureType?: architectureType,
+  components: array<pluginDeployedComponent>,
+  extensionWirings: array<extensionWiring>,
+}
+
+let onPluginDeployedHook: ref<option<pluginDeployedInfo => promise<unit>>> = ref(None)
+
+let registerOnPluginDeployed = (hook: pluginDeployedInfo => promise<unit>) => {
+  onPluginDeployedHook.contents = Some(hook)
+}
+
+let clearOnPluginDeployed = () => {
+  onPluginDeployedHook.contents = None
+}
+
+// ---------------------------------------------------------------------------
+// Platform-deployed hook — fires after deployPlatform / makePlatform
+// completes, providing platform-level metadata with resolved values.
+// ---------------------------------------------------------------------------
+type platformDeployedInfo = {
+  name: string,
+  environment: string,
+  region: string,
+  // Domain API — handles application mutations from plugin stacks.
+  domainApiEndpoint: string,
+  domainApiRoleArn: string,
+  // Platform API — handles Platform_Sync* and admin mutations.
+  // Equals domainApiEndpoint/domainApiRoleArn in unified (non-split) mode.
+  platformApiEndpoint: string,
+  platformApiRoleArn: string,
+  adminResources: array<ReventlessInterop.Resource.t>,
+}
+
+let onPlatformDeployedHook: ref<option<platformDeployedInfo => unit>> = ref(None)
+
+let lastPlatformDeployedInfo: ref<option<platformDeployedInfo>> = ref(None)
+
+let registerOnPlatformDeployed = (hook: platformDeployedInfo => unit) => {
+  onPlatformDeployedHook.contents = Some(hook)
+}
+
+let firePlatformDeployedHook = (info: platformDeployedInfo) => {
+  lastPlatformDeployedInfo.contents = Some(info)
+  switch onPlatformDeployedHook.contents {
+  | Some(hook) => hook(info)
+  | None => ()
+  }
+}
+
+let replayPlatformDeployedHook = () => {
+  switch (onPlatformDeployedHook.contents, lastPlatformDeployedInfo.contents) {
+  | (Some(hook), Some(info)) => hook(info)
+  | _ => ()
+  }
+}
+
+let clearOnPlatformDeployed = () => {
+  onPlatformDeployedHook.contents = None
+  lastPlatformDeployedInfo.contents = None
+}
+
+// Resolver error hook has moved to Plugin_ResolverError to keep it on the
+// runtime-safe import chain (CommandGenerator_Callback runs in Lambda; this
+// module pulls in Pulumi for deploy-time helpers).
+
+// ---------------------------------------------------------------------------
+// Shared parameter types for hooks that carry structured data.
+// ---------------------------------------------------------------------------
+type mutationKind = Aggregate | Dcb
+
+type inboundAppSyncResolverParams = {
+  runtime: Runtime.environment<unknown>,
+  fieldNames: array<string>,
+  externalInputSchemas: array<S.t<unknown>>,
+  opts: Pulumi.ComponentResource.options,
+}
+
+type dcbAppSyncResolverParams = {
+  runtime: Runtime.environment<unknown>,
+  fieldNames: array<string>,
+  tags: array<string>,
+  opts: Pulumi.ComponentResource.options,
+}
+
+// ---------------------------------------------------------------------------
+// Query field names registry — populated by Plugin_Builder during construct()
+// to map QueryDb component names → plugin-prefixed GraphQL query field names.
+// Read by QueryDbResolvers_GraphQL.make() to align resolver SDL with fragment SDL.
+// ---------------------------------------------------------------------------
+let queryFieldNamesRegistry: dict<Api_Naming.queryNames> = Dict.make()
+
+// ---------------------------------------------------------------------------
+// State schema registry — populated alongside queryFieldNamesRegistry so that
+// the in-memory QueryDb resolver can derive the same `serverCapability`
+// (filter / orderBy fields) the FragmentGenerator computed at SDL emission
+// time. Keyed by Spec.name like queryFieldNamesRegistry.
+// ---------------------------------------------------------------------------
+let stateSchemaRegistry: dict<S.t<unknown>> = Dict.make()
+
+// ---------------------------------------------------------------------------
+// Aggregate mutation field names registry — populated by Plugin_Builder during
+// construct() to map aggregate Spec.name → plugin-prefixed mutation field names.
+// Read by CommandGenerator_Builder.connect() to provide plugin-prefixed mutation field names.
+// ---------------------------------------------------------------------------
+let aggregateMutationFieldsRegistry: dict<array<string>> = Dict.make()
+
+// ---------------------------------------------------------------------------
+// MCP schema registration params type — shared by platformHooks and callers.
+// ---------------------------------------------------------------------------
+type mcpRegistrationParams = {
+  pluginName: string,
+  mutationEntries: array<ReventlessInfra.Api.mutationSchemaEntry>,
+  queryEntries: array<ReventlessInfra.Api.querySchemaEntry>,
+  eventLogEntries: array<ReventlessInfra.Api.eventLogSchemaEntry>,
+  /** Subscription SDL field strings from the plugin fragment (Sources A, B, C).
+      Used by the in-memory platform to register yoga WebSocket subscription resolvers. */
+  subscriptionFields: array<string>,
+}
+
+// Subscription infrastructure hook params — fired after allQueryDbs and allEventTopics
+// are assembled inside builderOutputs.  Lets the AWS platform wire StateTopic and
+// EventLogSubscription Lambdas without touching reventless-core.
+type subscriptionInfraParams = {
+  allQueryDbs: ReventlessInfra.QueryDb.allOutputs,
+  allEventTopics: dict<ReventlessInfra.EventTopic.outputs>,
+  eventLogEntries: array<ReventlessInfra.Api.eventLogSchemaEntry>,
+  opts: Pulumi.ComponentResource.options,
+}
+
+// ---------------------------------------------------------------------------
+// platformHooks — platform callbacks and coordination state passed to builder
+// functors as a record.
+//
+// Optional fields (field?): callbacks set at record creation; absent = None.
+// Required ref field: adminExtensionPoints — a mutable cell set by makePlatform
+// after Admin.construct() returns, read by Plugin_Builder to wire the local
+// admin connection path (in-memory). Initialized to an empty dict output;
+// AWS platforms leave it empty and fall back to Interstack instead.
+//
+// `noHooks` is the "no callbacks" default, with adminExtensionPoints starting
+// as an empty dict output.
+// ---------------------------------------------------------------------------
+type platformHooks = {
+  // ── In-memory GraphQL mutation registration ────────────────────────────
+  // Phase 1: register SDL + resolver stub synchronously.
+  // `commandAuthorization` is the `command => permission` function from the
+  // aggregate / slice Spec; the resolver evaluates it per-request against
+  // `ctx.identity` to enforce per-constructor authorization rules.
+  mutationResolverHook?: (
+    ~kind: mutationKind,
+    ~fields: array<string>,
+    ~commandSchema: S.t<unknown>,
+    ~commandAuthorization: unknown => Reventless.Authorization.permission,
+  ) => unit,
+  // Phase 2: bind generateCommand inside Output.apply.
+  mutationBindHook?: (~field: string, ~generateCommand: CommandGenerator.commandGenerator) => unit,
+  // InboundTranslationSlice — phase 1: register SDL + stub.
+  inboundMutationResolverHook?: (~fieldName: string, ~externalInputSchema: S.t<unknown>) => unit,
+  // InboundTranslationSlice — phase 2: bind receive.
+  inboundMutationBindReceiveHook?: (~fieldName: string, ~receive: JSON.t => promise<result<array<string>, string>>) => unit,
+  // GraphQL type definitions.
+  schemaTypeRegistrationHook?: array<string> => unit,
+  // Subscription infrastructure (AWS): wire StateTopic + EventLogSubscription Lambdas.
+  // Fired inside builderOutputs after allQueryDbs and allEventTopics are assembled.
+  subscriptionInfraHook?: subscriptionInfraParams => unit,
+  // MCP tools and resources.
+  mcpSchemaRegistrationHook?: mcpRegistrationParams => unit,
+  // ── AppSync resolver creation (AWS) ───────────────────────────────────
+  preResolversSchemaHook?: (~name: string, ~version: string, Reventless.Plugin.apiSchemaFragment) => Pulumi.Output.t<unit>,
+  // Admin equivalent of preResolversSchemaHook. Set by AWS platforms to push
+  // the admin SDL to the Platform (split mode) or Domain (unified mode) API.
+  // Platform_Admin.construct invokes this with a barrier that resolves once the
+  // admin AppSync DataSources are ready, and gates admin createResolvers on the
+  // returned Output so resolver CreateResolver calls don't race the API-level
+  // schema-creation lock. Mirrors Plugin_Builder's schemaPushed gating at
+  // Plugin_Builder.res:452-466. The hook owns SDL construction (no fragment
+  // arg — the admin SDL is platform-defined, not per-plugin).
+  preAdminResolversSchemaHook?: (~adminBarrier: Pulumi.Output.t<unit>) => Pulumi.Output.t<unit>,
+  inboundAppSyncResolverHook?: inboundAppSyncResolverParams => unit,
+  dcbAppSyncResolverHook?: dcbAppSyncResolverParams => unit,
+  // ── Deployment lifecycle (AWS) ─────────────────────────────────────────
+  onDcbEventLogCreated?: unknown => unit,
+  onDcbCommandTopicCreated?: unknown => unit,
+  onDcbSlicesCreated?: unknown => unit,
+  onHeartbeatEpChannelAvailable?: (unknown, ~pluginId: string) => unit,
+  // ── Admin → Plugin coordination ────────────────────────────────────────
+  // Set by makePlatform after Admin.construct(); read by Plugin_Builder to
+  // wire the local admin connection path (in-memory).  Starts as an empty
+  // dict; AWS platforms leave it empty and use Interstack instead.
+  adminExtensionPoints: ref<Pulumi.Output.t<dict<ExtensionPoint.outputs>>>,
+  // ── Platform context (populated by makePlatform/deployPlugin) ──────────
+  // Read by Plugin_Builder.make so app plugins don't need to pass these.
+  // api/apiRole stored as hookedValue<unknown> to avoid Pulumi Output Proxy
+  // corrupting ReScript option boxing (BS_PRIVATE_NESTED_SOME_NONE sentinel).
+  // Cast back via Obj.magic in Plugin_Builder where concrete types are known.
+  scheduler: ref<option<Pulumi.Output.t<Scheduler.operations>>>,
+  // URN identifying the principal/role the scheduler invokes targets as.
+  // Populated by deployment-aware platforms; empty Output on platforms that
+  // don't expose this (e.g. in-memory). Threaded through Plugin_Builder into
+  // each Task's runtime config so bundled handlers can talk to the
+  // underlying scheduler service.
+  schedulerRoleUrn: ref<Pulumi.Output.t<string>>,
+  api: ref<option<hookedValue<unknown>>>,
+  apiRole: ref<option<hookedValue<unknown>>>,
+  // Current deploy target, set by deployPlugin before plugin.make() is called.
+  // "Domain" (default) → resolvers/schema go to the DomainApi.
+  // "Platform" → resolvers/schema go to the PlatformApi.
+  // Plugin_Builder captures this synchronously when constructing pluginDefinition
+  // to avoid the async-reset race (deployPlugin resets to "Domain" after make()).
+  deployTarget: ref<string>,
+}
+
+// Default hooks — no callbacks, empty platform context.
+let noHooks: platformHooks = {
+  adminExtensionPoints: ref(Pulumi.Output.make(Dict.make())),
+  scheduler: ref(None),
+  schedulerRoleUrn: ref(Pulumi.Output.make("")),
+  api: ref(None),
+  apiRole: ref(None),
+  deployTarget: ref("Domain"),
+}
+
+// Functor parameter wrapper for platformHooks.
+module type HooksConfig = {
+  let hooks: platformHooks
+}
+
+// Pre-built HooksConfig with no hooks — use for builders that need no callbacks
+// (e.g. AWS aggregate builders that route via AggregateRuntimeBuilder instead).
+module NoopHooksConfig: HooksConfig = {
+  let hooks = noHooks
+}
+
+// Derive admin-prefixed mutation field names from each aggregate's command schema,
+// drop @noApi variants, register them into aggregateMutationFieldsRegistry (consumed
+// by CommandGenerator_Builder.connect to wire AppSync resolvers in the auto-flow)
+// and fire `mutationResolverHook` so adapter-side SDL stubs get registered
+// synchronously. The matching `mutationSchemaEntry` records — needed to keep the
+// SDL aligned — live in `PluginBaseFragment.pluginAggregateMutationEntries` so the
+// AWS path (which pushes `AdminApi.baseFragment` directly, not Admin.construct's
+// adminFragment) picks them up too. This helper is side-effect only.
+let registerAdminAggregateMutations = (
+  type a,
+  aggregates: array<module(ReventlessInfra.Aggregate.T with type api = a)>,
+  ~hooks: platformHooks,
+): unit =>
+  aggregates->Array.forEach((module(M: ReventlessInfra.Aggregate.T with type api = a)) => {
+    let commandSchema = M.Spec.commandSchema->S.castToUnknown
+    if ApiNoApiHelpers.isNoApi(commandSchema) {
+      ()
+    } else {
+      let constructorNames = Reventless.DcbTag.extractAllVariantNames(M.Spec.commandSchema)
+      let filteredConstructorNames =
+        ApiNoApiHelpers.filterNoApiVariants(constructorNames, commandSchema)
+      let fieldNames =
+        filteredConstructorNames->Array.map(cname =>
+          Api_Naming.adminField(~name=M.Spec.name ++ "_" ++ cname)
+        )
+      aggregateMutationFieldsRegistry->Dict.set(M.Spec.name, fieldNames)
+      if fieldNames->Array.length > 0 {
+        hooks.mutationResolverHook->Option.forEach(registerResolver =>
+          registerResolver(
+            ~kind=Aggregate,
+            ~fields=fieldNames,
+            ~commandSchema,
+            ~commandAuthorization=M.Spec.commandAuthorization->Obj.magic,
+          )
+        )
+      }
+    }
+  })
+
+// ---------------------------------------------------------------------------
+// Interop metadata — computed from builderOutputs at deploy time and stored so
+// that the plugin's entry-point module can export it as `_interopMeta`.
+// ---------------------------------------------------------------------------
+
+// Module-level ref; follows the same mutable-state pattern as `tasksOutputs`
+// above.  Set by Plugin_Builder during construct(); read by user entry-point
+// code via `getInteropMeta()`.
+// IMPORTANT: Do NOT use option<Pulumi.Output.t<_>> here.  Pulumi.Output.t is a
+// JavaScript Proxy.  ReScript's Caml_option.some() checks for BS_PRIVATE_NESTED_SOME_NONE
+// on the value — the Proxy intercepts that property access and returns a truthy value,
+// causing some() to produce the sentinel object {BS_PRIVATE_NESTED_SOME_NONE: 0}
+// instead of wrapping the actual Output.  Use a raw JS null ref to avoid option wrapping.
+let interopMetaOutput: ref<Pulumi.Output.t<JSON.t>> = ref(%raw(`null`))
+
+// Derive a field-name union across all tasks (field names present in at least
+// one task's serialized resolvedOutputs).  Optional fields only appear in the
+// union when they are Some in the source Task.outputs record.
+let taskFieldUnion = (tasks: dict<Task.outputs>): array<string> => {
+  module SSet = Belt.Set.String
+  tasks
+  ->Dict.valuesToArray
+  ->Array.reduce(SSet.empty, (acc, taskOutput) => {
+    // Convert Task.outputs → Task.resolvedOutputs using placeholders for nested
+    // Pulumi.Output.t values — we only need presence, not actual string content.
+    // ReScript optional fields must be set to the inner type (not option<_>) in
+    // record literals, so we use a switch to conditionally include them.
+    let resolved: ReventlessInterop.Task.resolvedOutputs =
+      switch (taskOutput.bucketNames, taskOutput.sideEffectSources) {
+      | (None, None) => {name: taskOutput.name}
+      | (Some(_), None) => {name: taskOutput.name, bucketNames: Dict.make()}
+      | (None, Some(src)) => {name: taskOutput.name, sideEffectSources: src}
+      | (Some(_), Some(src)) => {
+          name: taskOutput.name,
+          bucketNames: Dict.make(),
+          sideEffectSources: src,
+        }
+      }
+    ReventlessInterop.ExportMeta.fieldNamesOf(resolved, ReventlessInterop.Task.resolvedOutputsSchema)
+    ->Array.reduce(acc, SSet.add)
+  })
+  ->SSet.toArray
+}
+
+// Build an ExportMeta.t from builderOutputs.  Called inside a Pulumi.Output.apply
+// so all top-level Output.t wrappers in builderOutputs are already resolved.
+// Nested Output.t values (e.g. inside Task.bucketNames dict values) are still
+// pending — we use placeholder detection (Some vs None) rather than unwrapping.
+let toInteropMeta = (outputs: builderOutputs): ReventlessInterop.ExportMeta.t => {
+  // EventMapper field manifest uses minimum required fields (counter presence
+  // cannot be checked without resolving inner Output.t — improved in later phase).
+  let eventMapperMinimal: ReventlessInterop.EventMapper.resolvedOutputs = {
+    name: "",
+    eventCollector: {name: "", resources: []},
+  }
+
+  {
+    version: ReventlessInterop.ExportMeta.version,
+    fields: Dict.fromArray([
+      ("tasks", taskFieldUnion(outputs.tasks)),
+      (
+        "eventMappers",
+        ReventlessInterop.ExportMeta.fieldNamesOf(
+          eventMapperMinimal,
+          ReventlessInterop.EventMapper.resolvedOutputsSchema,
+        ),
+      ),
+    ]),
+  }
+}
+
+// Returns the computed interop meta Output.  Call this from the plugin's entry-
+// point module and export the result as `let _interopMeta = getInteropMeta()`.
+let getInteropMeta = (): Pulumi.Output.t<JSON.t> => {
+  let v = interopMetaOutput.contents
+  // Use raw null check to avoid option wrapping of the Proxy value.
+  if %raw(`v === null`) {
+    JsError.throwWithMessage("getInteropMeta() called before Plugin_Builder.construct()")
+  } else {
+    v
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Stack metadata export — environment, region, timestamp, actor, git SHA.
+// Called from both exportPluginOutputs and exportPlatformOutputs.
+// ---------------------------------------------------------------------------
+@val external processEnv: dict<string> = "process.env"
+
+let exportDeploymentMetadata = () => {
+  let metadata =
+    [
+      ("environment", Pulumi.Pulumi.getStackName()),
+      ("region", Pulumi.Config.make(Some("aws"))->Pulumi.Config.get("region")->Option.getOr("unknown")),
+      ("timestamp", Date.make()->Date.toISOString),
+      ("gitSha", processEnv->Dict.get("GITHUB_SHA")->Option.getOr("unknown")),
+      ("actor", processEnv->Dict.get("GITHUB_ACTOR")->Option.getOr("unknown")),
+    ]
+    ->Dict.fromArray
+  Pulumi.Pulumi.export(
+    "deploymentMetadata",
+    metadata->Dict.mapValues(JSON.Encode.string)->JSON.Encode.object->Pulumi.Output.make,
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Serialize individual component output dicts as top-level Pulumi stack exports.
+// Each component type gets its own export key (e.g. "aggregates", "readModels").
+// ---------------------------------------------------------------------------
+
+// Serialize a plain dict of component outputs to JSON. Unlike serializeDictExport,
+// this does NOT wrap the dict in Pulumi.Output.make (which deeply resolves nested
+// Outputs and breaks toResolvedOutputs).
+let serializePlainDictExport = (
+  dict: dict<'outputs>,
+  toResolved: 'outputs => Pulumi.Output.t<'resolved>,
+  schema: S.t<'resolved>,
+): Pulumi.Output.t<JSON.t> =>
+  dict
+  ->Dict.toArray
+  ->Array.map(((name, outputs)) =>
+    outputs
+    ->toResolved
+    ->Pulumi.Output.apply(resolved => (
+      name,
+      resolved->S.reverseConvertToJsonOrThrow(schema),
+    ))
+  )
+  ->Pulumi.Output.all
+  ->Pulumi.Output.apply(pairs => pairs->Dict.fromArray->JSON.Encode.object)
+
+let serializeDictExport = (
+  dictOutput: Pulumi.Output.t<dict<'outputs>>,
+  toResolved: 'outputs => Pulumi.Output.t<'resolved>,
+  schema: S.t<'resolved>,
+): Pulumi.Output.t<JSON.t> =>
+  dictOutput->Pulumi.Output.flatMap(dict =>
+    dict
+    ->Dict.toArray
+    ->Array.map(((name, outputs)) =>
+      outputs
+      ->toResolved
+      ->Pulumi.Output.apply(resolved => (
+        name,
+        resolved->S.reverseConvertToJsonOrThrow(schema),
+      ))
+    )
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(pairs => pairs->Dict.fromArray->JSON.Encode.object)
+  )
+
+// Serialize tasks dict to JSON array for the "tasks" stack export.
+let serializeTasksOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSON.t> =>
+  pluginOutputs.tasks->Pulumi.Output.flatMap(tasks =>
+    tasks
+    ->Dict.valuesToArray
+    ->Array.map(task =>
+      task
+      ->Task.toResolvedOutputs
+      ->Pulumi.Output.apply(resolved =>
+        resolved->S.reverseConvertToJsonOrThrow(ReventlessInterop.Task.resolvedOutputsSchema)
+      )
+    )
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(arr => arr->JSON.Encode.array)
+  )
+
+// Serialize event mappers from aggregates to JSON array for the "eventMappers" stack export.
+let serializeEventMappersOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSON.t> =>
+  pluginOutputs.aggregates->Pulumi.Output.flatMap(aggregates =>
+    aggregates
+    ->Dict.valuesToArray
+    ->Array.filterMap((agg: Aggregate.outputs) =>
+      agg.eventMapper->Option.map(eventMapperOutput =>
+        eventMapperOutput->Pulumi.Output.flatMap(em =>
+          em
+          ->EventMapper.toResolvedOutputs
+          ->Pulumi.Output.apply(resolved =>
+            resolved->S.reverseConvertToJsonOrThrow(
+              ReventlessInterop.EventMapper.resolvedOutputsSchema,
+            )
+          )
+        )
+      )
+    )
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(arr => arr->JSON.Encode.array)
+  )
+
+// Export platform admin component outputs as individual top-level Pulumi stack exports.
+// Follows the same serialization pattern as exportPluginOutputs.
+// Only exports non-empty component dicts to avoid cluttering stack output with empty values.
+let exportPlatformOutputs = (
+  ~extensionPointsOutputs: Pulumi.Output.t<array<ExtensionPoint.outputs>>,
+  ~aggregatesOutputs: dict<Aggregate.outputs>,
+  ~readModelsOutputs: dict<ReadModel.outputs>,
+  ~dcbEventLogOutputs: option<DcbEventLog.outputs>,
+  ~stateChangeSlicesOutputs: dict<StateChangeSlice.outputs>,
+  ~stateViewSlicesOutputs: dict<StateViewSlice.outputs>,
+  ~automationSlicesOutputs: dict<AutomationSlice.outputs>,
+  ~outboundTranslationSlicesOutputs: dict<OutboundTranslationSlice.outputs>,
+  ~inboundTranslationSlicesOutputs: dict<InboundTranslationSlice.outputs>,
+) => {
+  // Stack metadata
+  exportDeploymentMetadata()
+
+  // Extension points — always exported (the admin's primary component output)
+  Pulumi.Pulumi.export(
+    "extensionPoints",
+    extensionPointsOutputs->Pulumi.Output.flatMap(eps =>
+      eps
+      ->Array.map(ep =>
+        ep
+        ->ExtensionPoint.toResolvedOutputs
+        ->Pulumi.Output.apply(resolved => (
+          ep.name,
+          resolved->S.reverseConvertToJsonOrThrow(
+            ReventlessInterop.ExtensionPoint.resolvedOutputsSchema,
+          ),
+        ))
+      )
+      ->Pulumi.Output.all
+      ->Pulumi.Output.apply(pairs => pairs->Dict.fromArray->JSON.Encode.object)
+    ),
+  )
+
+  // Aggregates — only export if non-empty
+  if aggregatesOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "aggregates",
+      serializePlainDictExport(
+        aggregatesOutputs,
+        Aggregate.toResolvedOutputs,
+        ReventlessInterop.Aggregate.resolvedOutputsSchema,
+      ),
+    )
+  }
+
+  // ReadModels — only export if non-empty
+  if readModelsOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "readModels",
+      serializePlainDictExport(
+        readModelsOutputs,
+        ReadModel.toResolvedOutputs,
+        ReventlessInterop.ReadModel.resolvedOutputsSchema,
+      ),
+    )
+  }
+
+  // DCB event log — only export if present
+  switch dcbEventLogOutputs {
+  | Some(dcbOutputs) =>
+    Pulumi.Pulumi.export(
+      "dcbEventLog",
+      dcbOutputs
+      ->DcbEventLog.toResolvedOutputs
+      ->Pulumi.Output.apply(resolved =>
+        resolved->S.reverseConvertToJsonOrThrow(
+          ReventlessInterop.DcbEventLog.resolvedOutputsSchema,
+        )
+      ),
+    )
+  | None => ()
+  }
+
+  // DCB slices — only export non-empty dicts
+  if stateChangeSlicesOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "stateChangeSlices",
+      serializePlainDictExport(
+        stateChangeSlicesOutputs,
+        StateChangeSlice.toResolvedOutputs,
+        ReventlessInterop.StateChangeSlice.resolvedOutputsSchema,
+      ),
+    )
+  }
+
+  if stateViewSlicesOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "stateViewSlices",
+      serializePlainDictExport(
+        stateViewSlicesOutputs,
+        StateViewSlice.toResolvedOutputs,
+        ReventlessInterop.StateViewSlice.resolvedOutputsSchema,
+      ),
+    )
+  }
+
+  if automationSlicesOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "automationSlices",
+      serializePlainDictExport(
+        automationSlicesOutputs,
+        AutomationSlice.toResolvedOutputs,
+        ReventlessInterop.AutomationSlice.resolvedOutputsSchema,
+      ),
+    )
+  }
+
+  if outboundTranslationSlicesOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "outboundTranslationSlices",
+      serializePlainDictExport(
+        outboundTranslationSlicesOutputs,
+        OutboundTranslationSlice.toResolvedOutputs,
+        ReventlessInterop.OutboundTranslationSlice.resolvedOutputsSchema,
+      ),
+    )
+  }
+
+  if inboundTranslationSlicesOutputs->Dict.keysToArray->Array.length > 0 {
+    Pulumi.Pulumi.export(
+      "inboundTranslationSlices",
+      serializePlainDictExport(
+        inboundTranslationSlicesOutputs,
+        InboundTranslationSlice.toResolvedOutputs,
+        ReventlessInterop.InboundTranslationSlice.resolvedOutputsSchema,
+      ),
+    )
+  }
+}
+
+// Export all plugin outputs as individual top-level Pulumi stack exports.
+// Each component type is its own export key for flat, readable `pulumi stack output`.
+let exportPluginOutputs = (pluginOutputs: Plugin.outputs) => {
+  // Stack metadata
+  exportDeploymentMetadata()
+
+  // Scalar fields
+  Pulumi.Pulumi.export("id", pluginOutputs.id->Pulumi.Output.apply(v => v->JSON.Encode.string))
+  Pulumi.Pulumi.export(
+    "version",
+    pluginOutputs.version->Pulumi.Output.apply(v => v->JSON.Encode.string),
+  )
+
+  // Component dicts
+  Pulumi.Pulumi.export(
+    "aggregates",
+    serializeDictExport(
+      pluginOutputs.aggregates,
+      Aggregate.toResolvedOutputs,
+      ReventlessInterop.Aggregate.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "readModels",
+    serializeDictExport(
+      pluginOutputs.readModels,
+      ReadModel.toResolvedOutputs,
+      ReventlessInterop.ReadModel.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "extensionPoints",
+    serializeDictExport(
+      pluginOutputs.extensionPoints,
+      ExtensionPoint.toResolvedOutputs,
+      ReventlessInterop.ExtensionPoint.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "stateChangeSlices",
+    serializeDictExport(
+      pluginOutputs.stateChangeSlices,
+      StateChangeSlice.toResolvedOutputs,
+      ReventlessInterop.StateChangeSlice.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "stateViewSlices",
+    serializeDictExport(
+      pluginOutputs.stateViewSlices,
+      StateViewSlice.toResolvedOutputs,
+      ReventlessInterop.StateViewSlice.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "automationSlices",
+    serializeDictExport(
+      pluginOutputs.automationSlices,
+      AutomationSlice.toResolvedOutputs,
+      ReventlessInterop.AutomationSlice.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "outboundTranslationSlices",
+    serializeDictExport(
+      pluginOutputs.outboundTranslationSlices,
+      OutboundTranslationSlice.toResolvedOutputs,
+      ReventlessInterop.OutboundTranslationSlice.resolvedOutputsSchema,
+    ),
+  )
+  Pulumi.Pulumi.export(
+    "inboundTranslationSlices",
+    serializeDictExport(
+      pluginOutputs.inboundTranslationSlices,
+      InboundTranslationSlice.toResolvedOutputs,
+      ReventlessInterop.InboundTranslationSlice.resolvedOutputsSchema,
+    ),
+  )
+
+  // DCB event log — single optional value
+  Pulumi.Pulumi.export(
+    "dcbEventLog",
+    pluginOutputs.dcbEventLog->Pulumi.Output.flatMap(opt =>
+      switch opt {
+      | Some(dcbOutputs) =>
+        dcbOutputs
+        ->DcbEventLog.toResolvedOutputs
+        ->Pulumi.Output.apply(resolved =>
+          resolved->S.reverseConvertToJsonOrThrow(
+            ReventlessInterop.DcbEventLog.resolvedOutputsSchema,
+          )
+        )
+      | None => Pulumi.Output.make(Obj.magic(JSON.Encode.null))
+      }
+    ),
+  )
+
+  // Array exports
+  Pulumi.Pulumi.export("tasks", serializeTasksOutputs(pluginOutputs))
+  Pulumi.Pulumi.export("eventMappers", serializeEventMappersOutputs(pluginOutputs))
+
+  // Fire onPluginDeployed hook with fully resolved resource data.
+  switch onPluginDeployedHook.contents {
+  | Some(hook) =>
+    // Read deployment provenance from env vars synchronously (before Output.apply).
+    let actor =
+      processEnv
+      ->Dict.get("GITHUB_ACTOR")
+      ->Option.orElse(processEnv->Dict.get("CI_COMMIT_AUTHOR"))
+      ->Option.orElse(processEnv->Dict.get("USER"))
+      ->Option.getOr("local")
+    let deploymentId =
+      processEnv
+      ->Dict.get("GITHUB_SHA")
+      ->Option.orElse(processEnv->Dict.get("CI_COMMIT_SHA"))
+      ->Option.getOr(Date.make()->Date.toISOString)
+    let schemaFor = name =>
+      componentSchemaRegistry->Dict.get(name)->Option.getOr({})
+    let resolveAggregates = pluginOutputs.aggregates->Pulumi.Output.flatMap(aggs =>
+      aggs
+      ->Dict.toArray
+      ->Array.map(((name, outputs)) =>
+        outputs
+        ->Aggregate.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.Aggregate.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name,
+            kind: "Aggregate",
+            schema: schemaFor(name),
+            resources: [],
+            subComponents: [
+              {role: "commandGenerator", resources: resolved.commandGenerator.resources},
+              {role: "commandTopic", resources: resolved.commandTopic.resources},
+              {role: "eventLog", resources: resolved.eventLog.resources},
+              {role: "eventTopic", resources: resolved.eventLog.eventTopic.resources},
+            ],
+          }
+          component
+        })
+      )
+      ->Pulumi.Output.all
+    )
+
+    let resolveReadModels = pluginOutputs.readModels->Pulumi.Output.flatMap(rms =>
+      rms
+      ->Dict.toArray
+      ->Array.map(((name, outputs)) =>
+        outputs
+        ->ReadModel.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.ReadModel.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name,
+            kind: "ReadModel",
+            schema: schemaFor(name),
+            resources: [],
+            subComponents: [{role: "queryDb", resources: resolved.queryDb.resources}],
+          }
+          component
+        })
+      )
+      ->Pulumi.Output.all
+    )
+
+    let resolveExtensionPoints = pluginOutputs.extensionPoints->Pulumi.Output.flatMap(eps =>
+      eps
+      ->Dict.toArray
+      ->Array.map(((name, outputs)) =>
+        outputs
+        ->ExtensionPoint.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.ExtensionPoint.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name,
+            kind: "ExtensionPoint",
+            schema: schemaFor(name),
+            resources: [],
+            subComponents: [
+              {role: "commandTopic", resources: resolved.commandTopic.resources},
+              {role: "eventTopic", resources: resolved.eventTopic.resources},
+            ],
+          }
+          component
+        })
+      )
+      ->Pulumi.Output.all
+    )
+
+    let resolveStateChangeSlices = pluginOutputs.stateChangeSlices->Pulumi.Output.flatMap(slices =>
+      slices
+      ->Dict.toArray
+      ->Array.map(((name, outputs)) =>
+        outputs
+        ->StateChangeSlice.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.StateChangeSlice.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name,
+            kind: "StateChangeSlice",
+            schema: schemaFor(name),
+            resources: resolved.resources,
+            subComponents: [],
+          }
+          component
+        })
+      )
+      ->Pulumi.Output.all
+    )
+
+    let resolveStateViewSlices = pluginOutputs.stateViewSlices->Pulumi.Output.flatMap(slices =>
+      slices
+      ->Dict.toArray
+      ->Array.map(((name, outputs)) =>
+        outputs
+        ->StateViewSlice.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.StateViewSlice.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name,
+            kind: "StateViewSlice",
+            schema: schemaFor(name),
+            resources: resolved.resources,
+            subComponents: [{role: "queryDb", resources: resolved.queryDb.resources}],
+          }
+          component
+        })
+      )
+      ->Pulumi.Output.all
+    )
+
+    let resolveAutomationSlices = pluginOutputs.automationSlices->Pulumi.Output.flatMap(slices =>
+      slices
+      ->Dict.toArray
+      ->Array.map(((name, outputs)) =>
+        outputs
+        ->AutomationSlice.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.AutomationSlice.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name,
+            kind: "AutomationSlice",
+            schema: schemaFor(name),
+            resources: resolved.resources,
+            subComponents: [{role: "queryDb", resources: resolved.queryDb.resources}],
+          }
+          component
+        })
+      )
+      ->Pulumi.Output.all
+    )
+
+    let resolveOutboundTranslationSlices =
+      pluginOutputs.outboundTranslationSlices->Pulumi.Output.flatMap(slices =>
+        slices
+        ->Dict.toArray
+        ->Array.map(((name, outputs)) =>
+          outputs
+          ->OutboundTranslationSlice.toResolvedOutputs
+          ->Pulumi.Output.apply(
+            (resolved: ReventlessInterop.OutboundTranslationSlice.resolvedOutputs) => {
+              let component: pluginDeployedComponent = {
+                name,
+                kind: "OutboundTranslationSlice",
+                schema: schemaFor(name),
+                resources: resolved.resources,
+                subComponents: [{role: "queryDb", resources: resolved.queryDb.resources}],
+              }
+              component
+            },
+          )
+        )
+        ->Pulumi.Output.all
+      )
+
+    let resolveInboundTranslationSlices =
+      pluginOutputs.inboundTranslationSlices->Pulumi.Output.flatMap(slices =>
+        slices
+        ->Dict.toArray
+        ->Array.map(((name, outputs)) =>
+          outputs
+          ->InboundTranslationSlice.toResolvedOutputs
+          ->Pulumi.Output.apply(
+            (resolved: ReventlessInterop.InboundTranslationSlice.resolvedOutputs) => {
+              let component: pluginDeployedComponent = {
+                name,
+                kind: "InboundTranslationSlice",
+                schema: schemaFor(name),
+                resources: resolved.resources,
+                subComponents: [{role: "queryDb", resources: resolved.queryDb.resources}],
+              }
+              component
+            },
+          )
+        )
+        ->Pulumi.Output.all
+      )
+
+    let resolveDcbEventLog = pluginOutputs.dcbEventLog->Pulumi.Output.flatMap(opt =>
+      switch opt {
+      | Some(outputs) =>
+        outputs
+        ->DcbEventLog.toResolvedOutputs
+        ->Pulumi.Output.apply((resolved: ReventlessInterop.DcbEventLog.resolvedOutputs) => {
+          let component: pluginDeployedComponent = {
+            name: "DcbEventLog",
+            kind: "DcbEventLog",
+            schema: schemaFor("DcbEventLog"),
+            resources: resolved.resources,
+            subComponents: [{role: "eventTopic", resources: resolved.eventTopic.resources}],
+          }
+          [component]
+        })
+      | None => Pulumi.Output.make([])
+      }
+    )
+
+    // Resolve extension wiring metadata.
+    let resolveExtensionWirings = pluginOutputs.extensions->Pulumi.Output.flatMap(exts =>
+      pluginOutputs.id->Pulumi.Output.apply(id => {
+        let pluginName = id->String.split("@")->Array.getUnsafe(0)
+        let pluginVersion = id->String.split("@")->Array.getUnsafe(1)
+        exts
+        ->Dict.valuesToArray
+        ->Array.map((ext: ReventlessInfra.Extension.outputs) => {
+          // Derive provider plugin name from the extension point name
+          // (e.g. "Catalog.Products" → "Catalog").
+          let providerPlugin =
+            ext.extensionPointName->String.split(".")->Array.getUnsafe(0)
+          let wiring: extensionWiring = {
+            extensionName: ext.name,
+            extensionPointName: ext.extensionPointName,
+            providerPlugin,
+            providerVersion: "",
+            subscriberPlugin: pluginName,
+            subscriberVersion: pluginVersion,
+          }
+          wiring
+        })
+      })
+    )
+
+    // Collect all resolved components, fire the hook, and export the resulting
+    // Output<unit> at top level so Pulumi blocks on the hook's Promise.
+    let hookOutput =
+      (
+        pluginOutputs.id,
+        pluginOutputs.version,
+        resolveAggregates,
+        resolveReadModels,
+        resolveExtensionPoints,
+        resolveStateChangeSlices,
+      )
+      ->Pulumi.Output.all6
+      ->Pulumi.Output.flatMap(((id, version, aggs, rms, eps, scs)) =>
+        (
+          resolveStateViewSlices,
+          resolveAutomationSlices,
+          resolveOutboundTranslationSlices,
+          resolveInboundTranslationSlices,
+          resolveDcbEventLog,
+          resolveExtensionWirings,
+        )
+        ->Pulumi.Output.all6
+        ->Pulumi.Output.apply(((svs, autos, ots, its, dcb, wirings)) => {
+          let name = id->String.split("@")->Array.getUnsafe(0)
+          let meta = pluginMetadataRegistry.contents
+          let info: pluginDeployedInfo = {
+            name,
+            version,
+            environment: Pulumi.Pulumi.getStackName(),
+            stackName: Pulumi.Pulumi.getStackName(),
+            deployedAt: Date.make()->Date.toISOString,
+            actor,
+            deploymentId,
+            kind: ?meta->Option.flatMap(m => m.kind),
+            displayName: ?meta->Option.flatMap(m => m.displayName),
+            vendor: ?meta->Option.flatMap(m => m.vendor),
+            architectureType: ?meta->Option.flatMap(m => m.architectureType),
+            components: Array.flat([aggs, rms, eps, scs, svs, autos, ots, its, dcb]),
+            extensionWirings: wirings,
+          }
+          hook(info)
+        })
+      )
+      ->Pulumi.Output.flatMap(p => p->Pulumi.Output.fromPromise)
+
+    Pulumi.Pulumi.export("_pluginDeployedSync", hookOutput)
+  | None => ()
+  }
+}