@reventlessdev/reventless-aws 3.0.0-alpha.197 → 3.0.0-alpha.198

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.198 (2026-07-12)
+
+### Features
+
+* **admin:** event-source the API fragment registry as admin DCB slices (Phase 2b) ([3fc40d2](https://github.com/ReventlessDev/reventless-core/commit/3fc40d247c54bf66ed84d625959f08299aa04a98))
+* **admin:** event-source the UI fragment registry as admin DCB slices ([711581e](https://github.com/ReventlessDev/reventless-core/commit/711581e77c626e7d0fc35db8ec351f62a70bd8f2))
+* **admin:** expose the API fragment registry as system-callable mutations (Phase 2d) ([8b1ec49](https://github.com/ReventlessDev/reventless-core/commit/8b1ec49813e67f303bc86d60470c9b95d2a8408e))
+* **admin:** react to ApiFragment* events with a schema single writer (Phase 2e) ([59f9e46](https://github.com/ReventlessDev/reventless-core/commit/59f9e46c154d8ca2a34537974722014fc279de3e))
+* **admin:** retire the Plugin-aggregate UI-fragment path in favour of the registry slices ([1dbc708](https://github.com/ReventlessDev/reventless-core/commit/1dbc708e7439b34ff970cc3d963d7835a8c6fd48))
+* **admin:** serve Platform_UIFragments from the new UiFragmentRegistry slices ([7a47533](https://github.com/ReventlessDev/reventless-core/commit/7a47533acc95977fbeeb6375e94449056b655abc))
+* **api:** neutralize core-emitted SDL — [@aws](https://github.com/aws)_subscribe moves to the AWS adapter (Phase 2a) ([9b27ec8](https://github.com/ReventlessDev/reventless-core/commit/9b27ec8f6ab2b7453b1c50b9891e89781ec3b31a))
+* **deploy:** deregister API fragments on plugin-stack destroy (Phase 3 tail) ([4a10614](https://github.com/ReventlessDev/reventless-core/commit/4a10614e785359ca4c8021da9813c3d485abe9ca))
+* **deploy:** register API fragments via the Platform API on staged deploys (Phase 3) ([7ddb045](https://github.com/ReventlessDev/reventless-core/commit/7ddb045392380497494a0109712e7a10008f9207))
+
+
 # 3.0.0-alpha.197 (2026-07-11)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.197",
+  "version": "3.0.0-alpha.198",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,16 +9,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.21",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.50",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.157",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.15",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.156",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.97",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.21",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.75",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.20"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/Platform.res

@@ -109,7 +109,13 @@ module MakeWithConfig = (
       subnetIds: pg.subnetIds,
     })
     QueryDbBackend.exempt(ReventlessCore.PluginsReadModelSpec.name)
-    QueryDbBackend.exempt(ReventlessCore.UIFragmentRegistryReadModelSpec.name)
+    // The UiFragments StateViewSlice table is scanned by the Platform_UIFragments
+    // Lambda (DynamoDB scan) — keep it off the Postgres selection like the other
+    // admin stores.
+    QueryDbBackend.exempt(ReventlessCore.UiFragments.name)
+    // The ApiFragments StateViewSlice is the durable source of the schema-push
+    // automation and the runtime re-stitcher — admin store, off Postgres too.
+    QueryDbBackend.exempt(ReventlessCore.ApiFragments.name)
   })
   type api = Types.AppSync.api
   type role = Types.AppSync.role
@@ -567,6 +573,27 @@ module MakeWithConfig = (
   }
   module InboundTranslationSlice = InboundTranslationSlice_Builder.Make(ApiConfig)
 
+  // Admin UI-fragment registry slices (docs/plans/event-sourced-fragment-registries.md): the
+  // platform UI-fragment registry hosted as admin DCB slices sharing the admin DcbEventLog.
+  // Built once at platform-module level and passed into Admin.construct below (registers the
+  // slice's command handler exactly once).
+  module UiFragmentRegistrySlice = StateChangeSlice.Make(
+    ReventlessCore.UiFragmentRegistry,
+    ReventlessCore.UiFragmentRegistry_Behavior,
+  )
+  module UiFragmentsViewSlice = StateViewSlice.Make(
+    ReventlessCore.UiFragments,
+    ReventlessCore.UiFragments_Projection,
+  )
+  module ApiFragmentRegistrySlice = StateChangeSlice.Make(
+    ReventlessCore.ApiFragmentRegistry,
+    ReventlessCore.ApiFragmentRegistry_Behavior,
+  )
+  module ApiFragmentsViewSlice = StateViewSlice.Make(
+    ReventlessCore.ApiFragments,
+    ReventlessCore.ApiFragments_Projection,
+  )
+
   // Empty base fragment — no types, no mutations, no queries.
   // Used by the plugin Api in split mode so plugin schema has no core fields.
   let emptyBaseFragment = ReventlessCore.GraphQL_Stitcher.encode({
@@ -574,6 +601,7 @@ module MakeWithConfig = (
     mutations: [],
     queries: [],
     subscriptions: [],
+    subscriptionSources: [],
   })
 
   module Api = {
@@ -639,6 +667,11 @@ module MakeWithConfig = (
   // targetApi that was set before plugin.make() and is never reset.
   let hooksApiRef: ref<option<ReventlessCore.Plugin_Helpers.hookedValue<unknown>>> = ref(None)
   let hooksApiRoleRef: ref<option<ReventlessCore.Plugin_Helpers.hookedValue<unknown>>> = ref(None)
+  // Admin DCB mutation resolvers bind here (the Platform API in split mode). Set by
+  // makePlatform / deployPlatform once the Platform API resource exists. Distinct from hooksApiRef
+  // because both are read in *deferred* callbacks — admin resolvers need the Platform API while the
+  // plugins built afterwards read hooksApiRef (Domain/deploy-target). See platformHooks.adminApi.
+  let hooksAdminApiRef: ref<option<ReventlessCore.Plugin_Helpers.hookedValue<unknown>>> = ref(None)
 
   let resolveHookedApi = (): Types.AppSync.api =>
     switch hooksApiRef.contents {
@@ -646,6 +679,160 @@ module MakeWithConfig = (
     | None => resolveTargetApi()
     }
 
+  // Admin DCB resolvers resolve to the Platform API when it has been recorded; otherwise fall back
+  // to the same api plugins use (unified mode, or before the split Platform API exists).
+  let resolveAdminHookedApi = (): Types.AppSync.api =>
+    switch hooksAdminApiRef.contents {
+    | Some({val}) => Obj.magic(val)
+    | None => resolveHookedApi()
+    }
+
+  // ── Phase 3: staged-deploy API-fragment registration ────────────────────────
+  // When a plugin deploys against an ALREADY-RUNNING platform (plugin-stack mode),
+  // it registers its API-schema fragment with the platform via the Platform API
+  // (SigV4 system caller) instead of writing deploy-schema:* rows and pushing the
+  // schema itself. The platform-side reactive single writer (Plan 2e) stitches and
+  // pushes; this waits on the push status so resolver creation (gated on the
+  // returned Output) proceeds only once the plugin's fields are ACTIVE — or fails
+  // with the stitch error. Used only in plugin-stack mode; makePlatform (all-at-once)
+  // keeps the direct deploy-time push (the reactive writer is dormant there).
+  @val external registerWaiterSetTimeout: (unit => unit, int) => unit = "setTimeout"
+  let deployWaiterDelay = (ms: int): promise<unit> =>
+    Promise.make((resolve, _) => registerWaiterSetTimeout(() => resolve(), ms))
+
+  // Poll the platform's Platform_ApiFragments status query until the plugin's row
+  // shows a push that landed at/after our registration time (`sinceAt`) — a fresh
+  // "ok" means our fields are live; a fresh "error" surfaces the stitch failure. An
+  // older "ok" is a stale prior deploy's and is ignored (ISO strings sort lexically).
+  let waitForApiFragmentPush = async (~endpoint, ~region, ~pluginId, ~sinceAt) => {
+    let query = "query { Platform_ApiFragments { pluginId pushStatus pushMessage pushedAt } }"
+    let maxAttempts = 90 // ~3 min at 2s intervals
+    let rec loop = async attempt =>
+      if attempt >= maxAttempts {
+        JsError.throwWithMessage(
+          `Timed out (>3min) waiting for the platform to push ${pluginId}'s API fragment — check the AdminEventCollector Lambda logs.`,
+        )
+      } else {
+        let data = await Util_AppSync_Caller.sendQuery(~endpoint, ~region, ~queryString=query)
+        let row =
+          data
+          ->Option.flatMap(JSON.Decode.object)
+          ->Option.flatMap(d => d->Dict.get("Platform_ApiFragments"))
+          ->Option.flatMap(JSON.Decode.array)
+          ->Option.getOr([])
+          ->Array.find(entry =>
+            entry
+            ->JSON.Decode.object
+            ->Option.flatMap(e => e->Dict.get("pluginId"))
+            ->Option.flatMap(JSON.Decode.string) == Some(pluginId)
+          )
+          ->Option.flatMap(JSON.Decode.object)
+        switch row {
+        | Some(e) =>
+          let field = k => e->Dict.get(k)->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+          let status = field("pushStatus")
+          let fresh = field("pushedAt") >= sinceAt
+          if fresh && status == "ok" {
+            log.info(~comp="registerFragmentViaApi", `${pluginId} schema push confirmed ACTIVE`)
+          } else if fresh && status == "error" {
+            JsError.throwWithMessage(`Schema push failed for ${pluginId}: ${field("pushMessage")}`)
+          } else {
+            await deployWaiterDelay(2000)
+            await loop(attempt + 1)
+          }
+        | None =>
+          await deployWaiterDelay(2000)
+          await loop(attempt + 1)
+        }
+      }
+    await loop(0)
+  }
+
+  let registerFragmentViaApi = (
+    ~name: string,
+    ~fragment: Reventless.Plugin.apiSchemaFragment,
+    ~apiTargetName: string,
+  ): Pulumi.Output.t<unit> => {
+    // Platform_RegisterApiFragment is an admin systemCallable mutation on the Platform
+    // API (regardless of the plugin's apiTarget, which is passed as the enum argument).
+    let platformApi = switch apiConfigRef.contents {
+    | Some({platformApi}) => platformApi
+    | None => domainApi
+    }
+    let region =
+      Pulumi.Config.make(Some("aws"))->Pulumi.Config.get("region")->Option.getOr("unknown")
+    let endpointOutput =
+      platformApi
+      ->Pulumi.Output.flatMap(api => api.uris)
+      ->Pulumi.Output.apply(uris => uris.graphQL)
+    // Deregister-on-destroy: a dynamic resource whose `delete` handler sends
+    // Platform_DeregisterApiFragment when the plugin stack is destroyed (final
+    // retirement). It never replaces on a version bump, so supersession does NOT
+    // deregister — only a genuine `pulumi destroy` removes the fields.
+    let _ = ApiFragmentDeregistration.make(
+      ~name=`${name}ApiFragmentRegistration`,
+      ~pluginId=name,
+      ~endpoint=endpointOutput->Pulumi.Output.asInput,
+      ~region,
+    )
+    endpointOutput
+    ->Pulumi.Output.flatMap(endpoint => {
+      let run = async () => {
+        let at = Date.make()->Date.toISOString
+        let variables = {
+          "id": name,
+          "pluginId": name,
+          "fragment": {"encoded": fragment.encoded, "protocol": fragment.protocol},
+          "apiTarget": Util_AppSync_Caller.graphqlEnum(apiTargetName),
+          "at": at,
+        }
+        let selection = "{ __typename ... on CommandAccepted { eventCount } ... on CommandRejected { errorCode errorDetail } }"
+        log.info(
+          ~comp="registerFragmentViaApi",
+          `Registering API fragment for ${name} (${apiTargetName}) via ${endpoint}`,
+        )
+        let result = await Util_AppSync_Caller.sendMutation(
+          ~endpoint,
+          ~region,
+          ~mutation="Platform_RegisterApiFragment",
+          ~selection,
+          ~variables,
+        )
+        let outcome =
+          result
+          ->Option.flatMap(JSON.Decode.object)
+          ->Option.flatMap(d => d->Dict.get("Platform_RegisterApiFragment"))
+          ->Option.flatMap(JSON.Decode.object)
+        switch outcome {
+        | Some(cmd) =>
+          let typename =
+            cmd->Dict.get("__typename")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+          switch typename {
+          | "CommandRejected" =>
+            let code =
+              cmd->Dict.get("errorCode")->Option.flatMap(JSON.Decode.string)->Option.getOr("unknown")
+            JsError.throwWithMessage(`RegisterApiFragment rejected for ${name}: ${code}`)
+          | "CommandAccepted" =>
+            // eventCount 0 ⇒ idempotent no-op (unchanged fragment) — fields already live,
+            // proceed without waiting; >0 ⇒ a real change, wait for the reactive push.
+            let eventCount =
+              cmd->Dict.get("eventCount")->Option.flatMap(JSON.Decode.float)->Option.getOr(0.0)
+            if eventCount > 0.0 {
+              await waitForApiFragmentPush(~endpoint, ~region, ~pluginId=name, ~sinceAt=at)
+            } else {
+              log.info(~comp="registerFragmentViaApi", `${name} fragment unchanged — no push needed`)
+            }
+          | _ => await waitForApiFragmentPush(~endpoint, ~region, ~pluginId=name, ~sinceAt=at)
+          }
+        | None =>
+          // Unparseable result (mutation may have failed) — fall back to polling.
+          await waitForApiFragmentPush(~endpoint, ~region, ~pluginId=name, ~sinceAt=at)
+        }
+      }
+      run()->Pulumi.Output.fromPromise
+    })
+  }
+
   let hooks: ReventlessCore.Plugin_Helpers.platformHooks = {
     // AWS uses Interstack for admin extension points — leave ref at empty dict.
     adminExtensionPoints: ref(Pulumi.Output.make(Dict.make())),
@@ -654,6 +841,7 @@ module MakeWithConfig = (
     schedulerRoleUrn: ref(Pulumi.Output.make("")),
     api: hooksApiRef,
     apiRole: hooksApiRoleRef,
+    adminApi: hooksAdminApiRef,
     deployTarget: ref("Domain"),
     inboundAppSyncResolverHook: ({runtime, fieldNames, externalInputSchemas: _, opts}) => {
       let runtimeTyped: ReventlessCore.Runtime.environment<Util.Lambda.runtimeParts> =
@@ -665,11 +853,12 @@ module MakeWithConfig = (
         ~opts,
       )
     },
-    dcbAppSyncResolverHook: ({runtime, fieldNames, tags, opts}) => {
+    dcbAppSyncResolverHook: ({runtime, fieldNames, tags, onAdminApi, opts}) => {
       let runtimeTyped: ReventlessCore.Runtime.environment<Util.Lambda.runtimeParts> =
         runtime->asLambdaRuntime
       CommandGeneratorResolvers_AppSync.makeDcb(
-        ~api=resolveHookedApi(),
+        // Admin slices bind on the Platform API (split mode); plugins on the deploy-target api.
+        ~api=onAdminApi ? resolveAdminHookedApi() : resolveHookedApi(),
         ~runtime=runtimeTyped,
         ~fieldNames,
         ~tags,
@@ -714,11 +903,15 @@ module MakeWithConfig = (
         let adminBaseFragment = AppSync_Adapter.injectAwsAuthAll(
           ReventlessCore.AdminApi.baseFragment(~cloner=Config.cloner),
           ~group="Admin",
+          // The ApiFragmentRegistry register/deregister mutations + the Platform_ApiFragments
+          // status query are invoked by the plugin/standalone deploy as a SigV4 system caller, so
+          // they carry the dual-auth (@aws_cognito_user_pools @aws_iam) directive.
+          ~iamFieldNames=ReventlessCore.AdminApi.systemCallerFieldNames,
         )
-        let sdl = ReventlessCore.GraphQL_Stitcher.stitch(
+        let sdl = AppSync_Adapter.stitchWithAwsDirectives(
           ~baseFragment=adminBaseFragment,
           ~pluginFragments=[],
-        )->AppSync_Adapter.stampSharedIamTypes
+        )
         (targetApi, adminBarrier)
         ->Pulumi.Output.all2
         ->Pulumi.Output.flatMap(((api, _)) =>
@@ -756,6 +949,19 @@ module MakeWithConfig = (
       // Domain after P.make() returns, before any Pulumi.Output async callbacks run.
       let capturedDeployTarget = currentDeployTarget.contents
 
+      switch platformStackRef {
+      | Some(_) =>
+        // Phase 3 — staged deploy against a running platform (deployPlugin): register the
+        // fragment via the Platform API; the reactive single writer (2e) stitches + pushes.
+        let apiTargetName = switch capturedDeployTarget {
+        | Domain => "Domain"
+        | Platform => "Platform"
+        }
+        registerFragmentViaApi(~name, ~fragment=pluginFragment, ~apiTargetName)
+      | None =>
+        // All-at-once (makePlatform): platform + plugins deploy in one stack, so the
+        // reactive writer is dormant — keep the direct deploy-time stitch + push below.
+
       // Select DynamoDB key prefix and target AppSync API based on the current deploy target.
       // Domain plugins use "deploy-schema:" and the Domain API (default behaviour).
       // Platform plugins use a separate "deploy-schema-platform:" namespace and the Core API,
@@ -933,6 +1139,7 @@ module MakeWithConfig = (
                 AppSync_Adapter.injectAwsAuthAll(
                   ReventlessCore.AdminApi.baseFragment(~cloner=Config.cloner),
                   ~group="Admin",
+                  ~iamFieldNames=ReventlessCore.AdminApi.systemCallerFieldNames,
                 )
               | Domain =>
                 if Config.splitApi {
@@ -944,10 +1151,10 @@ module MakeWithConfig = (
                   )
                 }
               }
-              let sdl = ReventlessCore.GraphQL_Stitcher.stitch(
+              let sdl = AppSync_Adapter.stitchWithAwsDirectives(
                 ~baseFragment,
                 ~pluginFragments=allPluginFragments,
-              )->AppSync_Adapter.stampSharedIamTypes
+              )
               let currentHash = AppSync_Adapter.sha256Hex(sdl)
               let storedHash = switch tableNameOpt {
               | Some(tn) => await readSchemaHash(~tableName=tn, ~apiId)
@@ -1088,6 +1295,7 @@ module MakeWithConfig = (
           })
         )
       })
+      }
     },
     // DCB EventLog created hook — extracts DynamoDB table name for DCB CommandTopic Lambda handler.
     // Postgres-backed DCB logs (B2.3c) create no table, so there is no resource to read:
@@ -1271,23 +1479,6 @@ module MakeWithConfig = (
     PluginReadModelMappings,
   )
 
-  // Admin-internal UIFragmentRegistry read model — projects UIFragmentRegistered/
-  // Updated/Deregistered events from the Plugin aggregate into a DynamoDB table the
-  // Platform_UIFragments admin query Lambda scans.
-  module UIFragmentRegistryReadModelMappings: Reventless.Projection.Mappings
-    with module Target := ReventlessCore.UIFragmentRegistryReadModelSpec = {
-    module M = ReventlessCore.UIFragmentRegistryProjection.Mappings
-    module type Mapping = M.Mapping
-    // See PluginReadModelMappings.moduleUrl note above.
-    let moduleUrl: string = ReventlessCore.UIFragmentRegistryProjection.moduleUrl
-    let mappings: array<module(Mapping)> = ReventlessCore.UIFragmentRegistryProjection.mappings
-  }
-
-  module UIFragmentRegistryReadModel = ReadModel_Builder_NoResolver_Stream.Make(
-    ReventlessCore.UIFragmentRegistryReadModelSpec,
-    UIFragmentRegistryReadModelMappings,
-  )
-
   module type PluginMaker = {
     let make: unit => Plugin.component
   }
@@ -1432,6 +1623,11 @@ module MakeWithConfig = (
       (domainApi, domainApiRole)
     }
 
+    // Admin DCB mutation resolvers bind to the Platform API (split mode) or the shared api
+    // (unified). Recorded now that the Platform API resource exists, so the admin's deferred
+    // dcbConnectFn (via ~onAdminApi) targets it rather than the Domain/deploy-target hooksApiRef.
+    hooks.adminApi := Some(platformApi->wrapHookedValue)
+
     // Update splitApiOutputsRef and apiConfig with the now-known Platform API.
     if Config.splitApi {
       splitApiOutputsRef := Some({platformApi, platformApiRole})
@@ -1453,16 +1649,13 @@ module MakeWithConfig = (
       ~version,
       ~extensionPoints=[],
       ~aggregates=[module(PluginAggregate)],
-      ~readModels=[
-        module(PluginReadModel),
-        module(UIFragmentRegistryReadModel),
-      ],
+      ~readModels=[module(PluginReadModel)],
       ~scheduler,
       ~resourceNaming=Util_ResourceNaming.operations,
       ~api=platformApi,
       ~apiRole=platformApiRole,
-      ~stateChangeSlices=[],
-      ~stateViewSlices=[],
+      ~stateChangeSlices=[module(UiFragmentRegistrySlice), module(ApiFragmentRegistrySlice)],
+      ~stateViewSlices=[module(UiFragmentsViewSlice), module(ApiFragmentsViewSlice)],
       ~automationSlices=[],
       ~outboundTranslationSlices=[],
       ~inboundTranslationSlices=[],
@@ -1488,9 +1681,10 @@ module MakeWithConfig = (
     | None => ()
     }
 
-    // Mount the Platform_UIFragments Lambda resolver — scans the UIFragmentRegistry
-    // table provisioned above and returns one entry per registered plugin UI.
-    switch admin.readModelsOutputs->Dict.get("UIFragmentRegistry") {
+    // Mount the Platform_UIFragments Lambda resolver — scans the UiFragments
+    // StateViewSlice table provisioned above and returns one entry per registered
+    // plugin UI.
+    switch admin.stateViewSlicesOutputs->Dict.get("UiFragments") {
     | Some(rm) =>
       switch rm.queryDb.resources->Array.get(0) {
       | Some(r) =>
@@ -1504,6 +1698,24 @@ module MakeWithConfig = (
     | None => ()
     }
 
+    // Mount the Platform_ApiFragments Lambda resolver — scans the ApiFragments
+    // StateViewSlice table and returns the push-status row per plugin (the deploy
+    // waiter polls this). The query field is in the pushed admin base but was
+    // unresolved on AWS until now.
+    switch admin.stateViewSlicesOutputs->Dict.get("ApiFragments") {
+    | Some(rm) =>
+      switch rm.queryDb.resources->Array.get(0) {
+      | Some(r) =>
+        Platform_ApiFragments_Lambda.make(
+          ~api=platformApi,
+          ~apiFragmentRegistryTableName=r.name,
+          ~opts={},
+        )
+      | None => ()
+      }
+    | None => ()
+    }
+
     // Build each plugin.
     let pluginComponents = plugins->Array.map(plugin => {
       module P = unpack(plugin)
@@ -1599,6 +1811,11 @@ module MakeWithConfig = (
       (domainApi, domainApiRole)
     }
 
+    // Admin DCB mutation resolvers bind to the Platform API (split mode) or the shared api
+    // (unified). Recorded now that the Platform API resource exists, so the admin's deferred
+    // dcbConnectFn (via ~onAdminApi) targets it rather than the Domain/deploy-target hooksApiRef.
+    hooks.adminApi := Some(platformApi->wrapHookedValue)
+
     // Update splitApiOutputsRef and apiConfig with the now-known Platform API.
     if Config.splitApi {
       splitApiOutputsRef := Some({platformApi, platformApiRole})
@@ -1660,12 +1877,13 @@ module MakeWithConfig = (
           AppSync_Adapter.injectAwsAuthAll(
             ReventlessCore.AdminApi.baseFragment(~cloner=Config.cloner),
             ~group="Admin",
+            ~iamFieldNames=ReventlessCore.AdminApi.systemCallerFieldNames,
           )
         }
-        let sdl = ReventlessCore.GraphQL_Stitcher.stitch(
+        let sdl = AppSync_Adapter.stitchWithAwsDirectives(
           ~baseFragment,
           ~pluginFragments=fragments,
-        )->AppSync_Adapter.stampSharedIamTypes
+        )
         await AppSync_Adapter.getClient()->AppSync_Adapter.startSchemaCreationRetrying({
           apiId,
           definition: sdl,
@@ -1679,16 +1897,13 @@ module MakeWithConfig = (
       ~version,
       ~extensionPoints=[module(PluginExtensionPoint)],
       ~aggregates=[module(PluginAggregate)],
-      ~readModels=[
-        module(PluginReadModel),
-        module(UIFragmentRegistryReadModel),
-      ],
+      ~readModels=[module(PluginReadModel)],
       ~scheduler,
       ~resourceNaming=Util_ResourceNaming.operations,
       ~api=platformApi,
       ~apiRole=platformApiRole,
-      ~stateChangeSlices=[],
-      ~stateViewSlices=[],
+      ~stateChangeSlices=[module(UiFragmentRegistrySlice), module(ApiFragmentRegistrySlice)],
+      ~stateViewSlices=[module(UiFragmentsViewSlice), module(ApiFragmentsViewSlice)],
       ~automationSlices=[],
       ~outboundTranslationSlices=[],
       ~inboundTranslationSlices=[],
@@ -1758,6 +1973,18 @@ module MakeWithConfig = (
       ~pluginSchemaPersistenceTableName=pluginSchemaPersistenceTable.name,
       ~schedulerRoleArn=hooks.schedulerRoleUrn.contents,
       ~clonerEnabled=Config.cloner,
+      // 2e: the reactive ApiFragmentRegistry single writer (admin EventCollector).
+      // The Platform AppSync id it pushes Platform-target fragments to (unified →
+      // domainApi, since platformApi == domainApi); the ApiFragments StateViewSlice
+      // table it re-folds from; the admin DCB command-topic FIFO URL it dispatches
+      // RecordApiFragmentPush to (captured during Admin.construct); and the mode flag.
+      ~platformApiId=platformApi->Pulumi.Output.flatMap(api => api.id),
+      ~apiFragmentRegistryTableName=?admin.stateViewSlicesOutputs
+      ->Dict.get("ApiFragments")
+      ->Option.flatMap(rm => rm.queryDb.resources->Array.get(0))
+      ->Option.map(r => r.name),
+      ~adminDcbCmdTopicUrl=?AutomationSliceRuntime_Builder_Single.getDcbQueueUrl(),
+      ~splitApi=Config.splitApi,
       (),
     )
 
@@ -1777,9 +2004,10 @@ module MakeWithConfig = (
     | None => ()
     }
 
-    // Mount the Platform_UIFragments Lambda resolver — scans the UIFragmentRegistry
-    // table provisioned above and returns one entry per registered plugin UI.
-    switch admin.readModelsOutputs->Dict.get("UIFragmentRegistry") {
+    // Mount the Platform_UIFragments Lambda resolver — scans the UiFragments
+    // StateViewSlice table provisioned above and returns one entry per registered
+    // plugin UI.
+    switch admin.stateViewSlicesOutputs->Dict.get("UiFragments") {
     | Some(rm) =>
       switch rm.queryDb.resources->Array.get(0) {
       | Some(r) =>
@@ -1793,6 +2021,24 @@ module MakeWithConfig = (
     | None => ()
     }
 
+    // Mount the Platform_ApiFragments Lambda resolver — scans the ApiFragments
+    // StateViewSlice table and returns the push-status row per plugin (the deploy
+    // waiter polls this). The query field is in the pushed admin base but was
+    // unresolved on AWS until now.
+    switch admin.stateViewSlicesOutputs->Dict.get("ApiFragments") {
+    | Some(rm) =>
+      switch rm.queryDb.resources->Array.get(0) {
+      | Some(r) =>
+        Platform_ApiFragments_Lambda.make(
+          ~api=platformApi,
+          ~apiFragmentRegistryTableName=r.name,
+          ~opts={},
+        )
+      | None => ()
+      }
+    | None => ()
+    }
+
     // Note: StateTopic_AppSync.finish runs from inside subscriptionInfraHook
     // (Phase 4 wiring above), not here — see the note in deployPlatform.