@reventlessdev/reventless-local 3.0.0-alpha.142 → 3.0.0-alpha.143

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.143 (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:** make the API fragment registry per-target (Domain | Platform) ([30491a9](https://github.com/ReventlessDev/reventless-core/commit/30491a9e14b4236c98cc756efb6de68ede1e77d7))
+* **admin:** populate the API fragment registry on connect + status query (Phase 2c) ([106d96c](https://github.com/ReventlessDev/reventless-core/commit/106d96c904e135f8360d53e582f395c107db704a))
+* **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))
+
+
 # 3.0.0-alpha.142 (2026-07-11)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.142",
+  "version": "3.0.0-alpha.143",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -32,16 +32,16 @@
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.18",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.20",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.156",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.3",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.97",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.102",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.75",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.20"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.157",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.18",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.103",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.4",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.21",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/Platform.res

@@ -44,6 +44,39 @@ let decodePluginEventEnvelope = (eventJson: JSON.t): option<ReventlessCore.Plugi
   | exception _ => None
   }
 
+// Decode a UiFragmentRegistry slice event from the admin DcbEventLog's published
+// bus envelope — same {id, meta, event} shape as the aggregate topic above
+// (DcbEventLog_Operations publishes via Message.composeEventJson'). Top-level,
+// not inside the functor, so the decode is unit-testable.
+let decodeUiFragmentRegistryEventEnvelope = (
+  eventJson: JSON.t,
+): option<ReventlessCore.UiFragmentRegistry.event> =>
+  switch eventJson
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("event"))
+  ->Option.map(payload =>
+    payload->S.parseJsonOrThrow(ReventlessCore.UiFragmentRegistry.eventSchema)
+  ) {
+  | result => result
+  | exception _ => None
+  }
+
+// Same envelope shape for the ApiFragmentRegistry slice's events on the shared
+// admin DcbEventLog topic. Returns None for envelopes of other admin slices
+// (schema mismatch), so a single subscriber can try both decoders.
+let decodeApiFragmentRegistryEventEnvelope = (
+  eventJson: JSON.t,
+): option<ReventlessCore.ApiFragmentRegistry.event> =>
+  switch eventJson
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("event"))
+  ->Option.map(payload =>
+    payload->S.parseJsonOrThrow(ReventlessCore.ApiFragmentRegistry.eventSchema)
+  ) {
+  | result => result
+  | exception _ => None
+  }
+
 // Configurable platform — set silent=true to suppress diagnostic warnings in tests,
 // splitApi=true to serve core and plugin APIs on separate ports,
 // backend=Backend.Sqlite({...}) to opt into file-backed SQLite persistence.
@@ -190,6 +223,8 @@ module MakeWithConfig = (
     schedulerRoleUrn: ref(Pulumi.Output.make("")),
     api: ref(None),
     apiRole: ref(None),
+    // In-memory has a single schema (no split Domain/Platform API), so admin resolvers share `api`.
+    adminApi: ref(None),
     deployTarget: ref("Domain"),
     // Phase 1: register SDL + resolver stub synchronously.
     // Pass the resolved server so the correct target (domain or platform) receives the schema.
@@ -634,6 +669,26 @@ module MakeWithConfig = (
       StateViewSliceMaker.Make(Spec, Projection)
   }
 
+  // Admin fragment registry slices (docs/plans/event-sourced-fragment-registries.md): the
+  // platform UI- and API-fragment registries hosted as admin DCB slices sharing the admin
+  // DcbEventLog. Built once and passed into Admin.construct below.
+  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,
+  )
+
   // In-memory has no DynamoDB streams — stream variant is identical to plain StateViewSlice.
   module StateViewSliceStream = {
     module Make = (
@@ -674,6 +729,7 @@ module MakeWithConfig = (
     mutations: [],
     queries: [],
     subscriptions: [],
+    subscriptionSources: [],
   })
 
   module Api = {
@@ -809,35 +865,6 @@ module MakeWithConfig = (
   // by dispatching a synthetic `Connect(pluginDefinition)` to LocalPluginAggregate
   // (see connectPlugin).
 
-  // UIFragmentRegistry QueryDb store ops — initialized lazily on first seed call.
-  let uiFragmentQueryDbOpsRef: ref<option<ReventlessCore.QueryDb_Adapter.operations>> = ref(None)
-
-  // Backend-aware storage for the UIFragment registry — the same functor every
-  // other read model uses. Replaces a hand-rolled memory-only store that ignored
-  // BackendState, so the registry now persists under SQLite too.
-  module UIFragmentStorage = LocalQueryDbStorage.Make(Bus)
-
-  let ensureUIFragmentRegistryQueryDbStore = () => {
-    switch uiFragmentQueryDbOpsRef.contents {
-    | Some(ops) => ops
-    | None =>
-      let name = ReventlessCore.UIFragmentRegistryReadModelSpec.name
-      // `make` registers the ops (and scan/stream) with the Bus for the active
-      // backend; retrieve them synchronously via getQueryDb rather than resolving
-      // the Pulumi Output.
-      let _ = UIFragmentStorage.make(
-        ~name,
-        ~indexes=[],
-        ~api=(),
-        ~apiRole=(),
-        ~opts=({}: Pulumi.CustomResourceOptions.t),
-      )
-      let ops = Bus.getQueryDb(name)->Option.getOrThrow
-      uiFragmentQueryDbOpsRef := Some(ops)
-      ops
-    }
-  }
-
   // In-memory store for plugin structures, keyed by plugin ID.
   let pluginStructuresStore: ref<dict<Reventless.Plugin.pluginStructure>> = ref(Dict.make())
 
@@ -876,12 +903,95 @@ module MakeWithConfig = (
     Bus.dispatchCommand(pluginCmdTopicKey, ReventlessCore.CommandTopic.encodeCommandJson(cmdJson))
   }
 
+  // Bus key for the shared admin DCB command topic, derived exactly as
+  // Dcb_Builder + CommandTopic_Builder name the channel:
+  // "Admin" -> +"Dcb" -> +CmdTopic ("AdminDcbCmdTopic").
+  let adminDcbCmdTopicKey = {
+    module CT = ReventlessCore.ComponentType
+    "AdminDcb"->CT.name(CT.CommandTopic)
+  }
+
+  // Dispatch a UiFragmentRegistry slice command in-process via the shared admin
+  // DCB command topic. The DCB filtering handler routes by the command's variant
+  // tag to the slice handler registered by Admin.construct's DcbBuilder. The real
+  // platform routes RegisterUiFragment through the admin PluginExtensionPoint's
+  // UI-fragment mapping; the local platform has no admin EP component (Connect is
+  // likewise dispatched straight to the Plugin aggregate), so this is the local
+  // analogue of that mapping's PublishCommand. Keyed by bare plugin NAME —
+  // dispatchCommand parks until the slice handler registers, so call-before-wire
+  // is safe.
+  let dispatchUiFragmentCommand = (
+    ~pluginName: string,
+    ~command: ReventlessCore.UiFragmentRegistry.command,
+  ) => {
+    let cmdJson: Reventless.Message.commandJson = {
+      id: pluginName,
+      meta: ReventlessCore.Message.generateMeta(~service=ReventlessCore.UiFragmentRegistry.name),
+      commandJson: command->S.reverseConvertToJsonOrThrow(
+        ReventlessCore.UiFragmentRegistry.commandSchema,
+      ),
+    }
+    Bus.dispatchCommand(adminDcbCmdTopicKey, ReventlessCore.CommandTopic.encodeCommandJson(cmdJson))
+  }
+
+  // Same in-process path for the ApiFragmentRegistry slice (the API-schema
+  // fragment registry). On the real platform the deploy is the caller (SigV4
+  // RegisterApiFragment mutation); locally we dispatch straight to the shared
+  // admin DCB command topic, the analogue used for the UI registry above.
+  let dispatchApiFragmentCommand = (
+    ~pluginName: string,
+    ~command: ReventlessCore.ApiFragmentRegistry.command,
+  ) => {
+    let cmdJson: Reventless.Message.commandJson = {
+      id: pluginName,
+      meta: ReventlessCore.Message.generateMeta(~service=ReventlessCore.ApiFragmentRegistry.name),
+      commandJson: command->S.reverseConvertToJsonOrThrow(
+        ReventlessCore.ApiFragmentRegistry.commandSchema,
+      ),
+    }
+    Bus.dispatchCommand(adminDcbCmdTopicKey, ReventlessCore.CommandTopic.encodeCommandJson(cmdJson))
+  }
+
+  // Platform_ApiFragments status-query resolver — scans the ApiFragments
+  // StateViewSlice QueryDb (populated by the ApiFragmentRegistry slice's
+  // projection) and encodes via the shared Platform_ApiFragmentsApi encoder, so
+  // the deploy-facing status shape matches AWS. Keyed by bare plugin name (one
+  // row per plugin), so no version collapse is needed. Registered at each admin
+  // server site below.
+  let apiFragmentsQueryResolver = async (_root, _args, _ctx): JSON.t => {
+    let items = switch Bus.getQueryDbScan(ReventlessCore.ApiFragments.name) {
+    | Some(scanAll) => scanAll()
+    | None => []
+    }
+    items
+    ->Array.filterMap(item =>
+      switch item->S.parseOrThrow(ReventlessCore.ApiFragments.stateSchema) {
+      | state => Some(ReventlessCore.Platform_ApiFragmentsApi.encodeApiFragmentEntry(state))
+      | exception _ => None
+      }
+    )
+    ->JSON.Encode.array
+  }
+
   // Subscription topics for the admin live-update channels.
   let pluginStatusSubTopic = "onPluginStatusChange"
   let uiFragmentSubTopic = "onUIFragmentChange"
 
-  // Relocated Source-C emission: subscribe to the Plugin aggregate's event topic and
-  // fan each lifecycle event out to the matching GraphQL subscription. Status now
+  // Bus key + service identity of the admin DcbEventLog's event topic. The
+  // Platform_Admin construct name is "Admin"; DcbEventLog_Builder hands that name
+  // to EventTopic_Builder, whose publisher registers under `<name>EventTopic`,
+  // and DcbEventLog_Operations stamps every published event's meta.service with
+  // `<name>DcbEventLog`.
+  let adminDcbEventTopicKey = {
+    module CT = ReventlessCore.ComponentType
+    "Admin"->CT.name(CT.EventTopic)
+  }
+  let adminDcbServiceName = "AdminDcbEventLog"
+
+  // Relocated Source-C emission: subscribe to the Plugin aggregate's event topic
+  // (lifecycle status) and the admin DcbEventLog event topic (UiFragmentRegistry
+  // slice events — the Plugin aggregate no longer emits UIFragment* events) and
+  // fan each event out to the matching GraphQL subscription. Status
   // flows from folding aggregate events (Connect / Activate / Deactivate / Retire),
   // not from direct QueryDb writes, so the subscription emission lives here rather
   // than inside the mutation resolvers. Idempotent: registered once per platform
@@ -923,37 +1033,68 @@ module MakeWithConfig = (
         | Some(VersionDisconnected(def)) => publishStatus(~name=def.name, ~status="Disconnected")
         | Some(VersionDeactivated(def)) => publishStatus(~name=def.name, ~status="Inactive")
         | Some(VersionRetired(def)) => publishStatus(~name=def.name, ~status="Retired")
-        | Some(UIFragmentRegistered(data)) =>
-          publishUIFragment(
-            ~name=ReventlessCore.Plugin.name(data.pluginId),
-            ~changeKind="Registered",
-            ~manifest=manifestJson(data.manifest),
-          )
-        | Some(UIFragmentUpdated(data)) =>
-          publishUIFragment(
-            ~name=ReventlessCore.Plugin.name(data.pluginId),
-            ~changeKind="Updated",
-            ~manifest=manifestJson(data.newManifest),
-          )
-        | Some(UIFragmentDeregistered(data)) =>
-          publishUIFragment(
-            ~name=ReventlessCore.Plugin.name(data.pluginId),
-            ~changeKind="Deregistered",
-            ~manifest=JSON.Encode.null,
-          )
         | Some(VersionDetected(_))
         | Some(VersionSuperseded(_))
         | Some(IncompatiblePluginDetected(_))
         | None => ()
         }
       })
+      // UI-fragment live updates — sourced from the UiFragmentRegistry slice's
+      // events on the shared admin DcbEventLog topic. The slice's `pluginId` is
+      // already the bare plugin name (the EP mapping keys the registry by name).
+      // The service guard keeps this decoder scoped to DcbEventLog-published
+      // envelopes as further admin slices join the shared log.
+      Bus.subscribeToEvents(adminDcbEventTopicKey, async (service, _meta, eventJson) =>
+        if service == adminDcbServiceName {
+          switch decodeUiFragmentRegistryEventEnvelope(eventJson) {
+          | Some(UiFragmentRegistered({pluginId, manifest})) =>
+            publishUIFragment(
+              ~name=pluginId,
+              ~changeKind="Registered",
+              ~manifest=manifestJson(manifest),
+            )
+          | Some(UiFragmentUpdated({pluginId, newManifest})) =>
+            publishUIFragment(
+              ~name=pluginId,
+              ~changeKind="Updated",
+              ~manifest=manifestJson(newManifest),
+            )
+          | Some(UiFragmentDeregistered({pluginId})) =>
+            publishUIFragment(~name=pluginId, ~changeKind="Deregistered", ~manifest=JSON.Encode.null)
+          | None => ()
+          }
+          // Local single writer for the API-schema fragment registry. On AWS the
+          // subscriber stitches + pushes the schema then records the outcome; on
+          // local the plugin's fields are already served by resolver registration,
+          // so the "push" is a no-op and we simply record success — the honest
+          // status for an in-process schema. Only Registered/Updated trigger a
+          // record (never PushRecorded — no re-entrant loop) and the record's own
+          // event decodes here as a no-op.
+          switch decodeApiFragmentRegistryEventEnvelope(eventJson) {
+          | Some(ApiFragmentRegistered({pluginId}))
+          | Some(ApiFragmentUpdated({pluginId})) =>
+            let _ = dispatchApiFragmentCommand(
+              ~pluginName=pluginId,
+              ~command=ReventlessCore.ApiFragmentRegistry.RecordApiFragmentPush({
+                pluginId,
+                ok: true,
+                message: "",
+                at: Date.make()->Date.toISOString,
+              }),
+            )
+          | Some(ApiFragmentDeregistered(_))
+          | Some(ApiFragmentPushRecorded(_))
+          | None => ()
+          }
+        }
+      )
     }
 
   // Drive the admin Plugin read models the same way AWS does: build a
   // `pluginDefinition` from the constructed plugin component outputs and dispatch a
   // synthetic `Connect(def)` to LocalPluginAggregate, keyed by the plugin NAME (the
   // Plugin aggregate is name-keyed). The Plugin aggregate emits `VersionConnected`
-  // (+ `UIFragmentRegistered` / `VersionSuperseded`) on its event topic; the real
+  // (+ `VersionSuperseded`) on its event topic; the real
   // PluginsProjection subscription (registered by
   // Admin.construct ~readModels) folds those events into the "Plugins" current view
   // QueryDb store. This replaces the previous
@@ -1015,7 +1156,6 @@ module MakeWithConfig = (
             extensionProtocols: [],
             apiSchemaFragment,
             apiTarget: None,
-            uiFragments,
             structure: pluginStructure,
             dcbEventLog: None,
             kind: Domain,
@@ -1025,34 +1165,39 @@ module MakeWithConfig = (
             ~pluginName,
             ~command=ReventlessCore.PluginSpec.Connect(pluginDefinition),
           )
-        })
-    })
-  }
-
-  // Seed the UIFragmentRegistry QueryDb from plugin outputs that carry a uiFragments manifest.
-  let seedUIFragmentRegistryQueryDb = (~pluginComponents: array<ReventlessCore.Plugin.component>) => {
-    let uiFragmentOps = ensureUIFragmentRegistryQueryDbStore()
-    pluginComponents->Array.forEach(plugin => {
-      let outputs: ReventlessInfra.Plugin.outputs = plugin->ReventlessCore.Component.outputs
-      let _ =
-        (outputs.id, outputs.uiFragments)
-        ->Pulumi.Output.all2
-        ->Pulumi.Output.apply(((id, uiFragments)) => {
+          // Register the UI-fragment manifest with the UiFragmentRegistry slice
+          // (via the shared admin DCB command topic), so the UiFragments
+          // StateViewSlice populates in-process. `at` mirrors the EP mapping's
+          // command-meta timestamp threading.
           switch uiFragments {
           | Some(manifest) =>
-            let state: ReventlessCore.UIFragmentRegistryReadModelSpec.state = {
-              pluginId: id,
-              remoteEntryUrl: manifest.remoteEntryUrl,
-              panels: manifest.panels,
-              pages: manifest.pages,
-              registeredAt: Date.make()->Date.toISOString,
-              updatedAt: Date.make()->Date.toISOString,
-            }
-            let entry =
-              state->S.reverseConvertToJsonOrThrow(
-                ReventlessCore.UIFragmentRegistryReadModelSpec.stateSchema,
-              )
-            let _ = uiFragmentOps.save(id, entry, Any, None)
+            let _ = dispatchUiFragmentCommand(
+              ~pluginName,
+              ~command=ReventlessCore.UiFragmentRegistry.RegisterUiFragment({
+                pluginId: pluginName,
+                manifest,
+                at: Date.make()->Date.toISOString,
+              }),
+            )
+          | None => ()
+          }
+          // Register the API-schema fragment with the ApiFragmentRegistry slice.
+          // On the real platform the deploy sends this as a SigV4 caller; locally
+          // connect stands in. apiTarget is Domain (mirrors pluginDefinition.kind
+          // = Domain / apiTarget = None above — the local platform has no
+          // Platform-target plugins). The subscriber below records the push as ok,
+          // since the fields are already served in-process by resolver registration.
+          switch apiSchemaFragment {
+          | Some(fragment) =>
+            let _ = dispatchApiFragmentCommand(
+              ~pluginName,
+              ~command=ReventlessCore.ApiFragmentRegistry.RegisterApiFragment({
+                pluginId: pluginName,
+                fragment,
+                apiTarget: Domain,
+                at: Date.make()->Date.toISOString,
+              }),
+            )
           | None => ()
           }
         })
@@ -1326,8 +1471,8 @@ module MakeWithConfig = (
       ~resourceNaming=LocalPluginSpec.resourceNaming,
       ~api=(),
       ~apiRole=(),
-      ~stateChangeSlices=[],
-      ~stateViewSlices=[],
+      ~stateChangeSlices=[module(UiFragmentRegistrySlice), module(ApiFragmentRegistrySlice)],
+      ~stateViewSlices=[module(UiFragmentsViewSlice), module(ApiFragmentsViewSlice)],
       ~automationSlices=[],
       ~outboundTranslationSlices=[],
       ~inboundTranslationSlices=[],
@@ -1409,7 +1554,6 @@ module MakeWithConfig = (
     // chains, so deferring their invocation changes no synchronous contract.
     let seedAdminStores = () => {
       connectPlugin(~pluginComponents=plugins)
-      seedUIFragmentRegistryQueryDb(~pluginComponents=plugins)
       seedPluginStructuresStore(~pluginComponents=plugins)
     }
     switch (projectionCatchup, pgProjectionCatchup) {
@@ -1455,7 +1599,7 @@ module MakeWithConfig = (
     )
 
     let pluginQueryDbName = ReventlessCore.PluginsReadModelSpec.name
-    let uiFragmentQueryDbName = ReventlessCore.UIFragmentRegistryReadModelSpec.name
+    let uiFragmentQueryDbName = ReventlessCore.UiFragments.name
 
     // Wire the per-mutation plugin-status gate (Part 2.3 of the resolver plan).
     // Resolves at call-time so updates to Plugin RM status are reflected immediately.
@@ -1605,10 +1749,10 @@ module MakeWithConfig = (
       },
     )
 
-    // Platform_UIFragments resolver — reads the seeded UIFragmentRegistry QueryDb
-    // (same store the admin UIFragment / UIFragments queries scan) and encodes via
-    // the shared Platform_UIFragmentsApi encoder so AWS and in-memory return the
-    // same JSON shape.
+    // Platform_UIFragments resolver — reads the UiFragments StateViewSlice
+    // QueryDb (populated by the UiFragmentRegistry slice's projection) and
+    // encodes via the shared Platform_UIFragmentsApi encoder so AWS and
+    // in-memory return the same JSON shape.
     queryResolvers->Dict.set(
       "Platform_UIFragments",
       async (_root, _args, _ctx): JSON.t => {
@@ -1616,15 +1760,13 @@ module MakeWithConfig = (
         | Some(scanAll) => scanAll()
         | None => []
         }
-        // Collapse to one entry per plugin name (highest version). UIFragmentRegistry
-        // accumulates a row per deployed version and has no lifecycle status of its
-        // own, so without this a redeployed federation plugin surfaces duplicate
-        // fragments — mirrors the dedup in Platform_UIFragments_Lambda.res.
+        // Collapse to one entry per plugin name (highest version). The registry is
+        // keyed by bare plugin name now (a no-op collapse), but rows persisted by
+        // the pre-slice registry were keyed name@version — keep the dedup so a
+        // mixed store never surfaces duplicates (mirrors Platform_UIFragments_Lambda.res).
         let latestByName = Dict.make()
         items->Array.forEach(item =>
-          switch item->S.parseOrThrow(
-            ReventlessCore.UIFragmentRegistryReadModelSpec.stateSchema,
-          ) {
+          switch item->S.parseOrThrow(ReventlessCore.UiFragments.stateSchema) {
           | state =>
             let name = ReventlessCore.Plugin.name(state.pluginId)
             let version = ReventlessCore.Plugin.version(state.pluginId)
@@ -1646,6 +1788,7 @@ module MakeWithConfig = (
         ->JSON.Encode.array
       },
     )
+    queryResolvers->Dict.set("Platform_ApiFragments", apiFragmentsQueryResolver)
 
     // Composite-key / index admin query fields. Live loads from the seeded QueryDb stores.
     registerAdminItemsAndIndexResolvers(~queryResolvers, ~live=true)
@@ -1730,8 +1873,9 @@ module MakeWithConfig = (
       }
     )
     // UIFragment admin mutations — explicit admin-triggered fragment changes still
-    // publish onUIFragmentChange directly (aggregate-driven fragment changes are
-    // emitted by subscribeToPluginEvents). uiFragmentSubTopic is the shared topic.
+    // publish onUIFragmentChange directly (slice-driven fragment changes are
+    // emitted by subscribeToPluginEvents' admin-DCB subscription). uiFragmentSubTopic
+    // is the shared topic.
     let makeUIEvent = (~pluginId, ~changeKind, ~manifest) =>
       JSON.Encode.object(
         Dict.fromArray([
@@ -1769,10 +1913,11 @@ module MakeWithConfig = (
     )
     adminRegisteredServers.contents->Array.push(platformGraphQL)
     // Register onUIFragmentChange + onPluginStatusChange subscriptions (Source C).
+    // The SDL field constants are provider-neutral, shared with the AWS path.
     platformGraphQL.registerSubscriptions(
       ~sdlFields=[
-        "  onUIFragmentChange: UIFragmentChangeEvent",
-        "  onPluginStatusChange: PluginStatusChangeEvent",
+        ReventlessCore.AdminApi.uiFragmentSubscriptionField,
+        ReventlessCore.AdminApi.pluginStatusSubscriptionField,
       ],
       ~resolvers=Dict.fromArray([
         (
@@ -1892,8 +2037,8 @@ module MakeWithConfig = (
       ~resourceNaming=LocalPluginSpec.resourceNaming,
       ~api=(),
       ~apiRole=(),
-      ~stateChangeSlices=[],
-      ~stateViewSlices=[],
+      ~stateChangeSlices=[module(UiFragmentRegistrySlice), module(ApiFragmentRegistrySlice)],
+      ~stateViewSlices=[module(UiFragmentsViewSlice), module(ApiFragmentsViewSlice)],
       ~automationSlices=[],
       ~outboundTranslationSlices=[],
       ~inboundTranslationSlices=[],
@@ -1925,6 +2070,7 @@ module MakeWithConfig = (
       "Platform_UIFragments",
       async (_root, _args, _ctx): JSON.t => JSON.Encode.array([]),
     )
+    queryResolvers->Dict.set("Platform_ApiFragments", apiFragmentsQueryResolver)
     // Composite-key / index admin query fields — empty stubs in the platform-only
     // path (no plugins connected → no QueryDb seeded).
     registerAdminItemsAndIndexResolvers(~queryResolvers, ~live=false)
@@ -2058,8 +2204,8 @@ module MakeWithConfig = (
       ~resourceNaming=LocalPluginSpec.resourceNaming,
       ~api=(),
       ~apiRole=(),
-      ~stateChangeSlices=[],
-      ~stateViewSlices=[],
+      ~stateChangeSlices=[module(UiFragmentRegistrySlice), module(ApiFragmentRegistrySlice)],
+      ~stateViewSlices=[module(UiFragmentsViewSlice), module(ApiFragmentsViewSlice)],
       ~automationSlices=[],
       ~outboundTranslationSlices=[],
       ~inboundTranslationSlices=[],
@@ -2099,23 +2245,19 @@ module MakeWithConfig = (
       queryResolvers->Dict.set(adminQueryEntry.listFieldName, async (_root, _args, _ctx): JSON.t =>
         connectionResponse([])
       )
-      // Platform_UIFragments — single-plugin path. Seeded by
-      // seedUIFragmentRegistryQueryDb below if the plugin component carries
-      // a uiFragments manifest, otherwise scans an empty store.
+      // Platform_UIFragments — single-plugin path. Populated by the
+      // UiFragments StateViewSlice when the plugin registers a manifest through
+      // the admin EP (connectPlugin below), otherwise scans an empty store.
       queryResolvers->Dict.set(
         "Platform_UIFragments",
         async (_root, _args, _ctx): JSON.t => {
-          let items = switch Bus.getQueryDbScan(
-            ReventlessCore.UIFragmentRegistryReadModelSpec.name,
-          ) {
+          let items = switch Bus.getQueryDbScan(ReventlessCore.UiFragments.name) {
           | Some(scanAll) => scanAll()
           | None => []
           }
           items
           ->Array.filterMap(item =>
-            switch item->S.parseOrThrow(
-              ReventlessCore.UIFragmentRegistryReadModelSpec.stateSchema,
-            ) {
+            switch item->S.parseOrThrow(ReventlessCore.UiFragments.stateSchema) {
             | state =>
               Some(ReventlessCore.Platform_UIFragmentsApi.encodeUIFragmentEntry(state))
             | exception _ => None
@@ -2124,6 +2266,7 @@ module MakeWithConfig = (
           ->JSON.Encode.array
         },
       )
+      queryResolvers->Dict.set("Platform_ApiFragments", apiFragmentsQueryResolver)
       // Platform_ComponentDefinitions resolver — SDL is already stitched into baseParts via
       // AdminApi.baseFragment so we register only the resolver here. Uses the shared
       // encoder so the dynamic-plugin admin server emits the same canonical shape as
@@ -2204,7 +2347,6 @@ module MakeWithConfig = (
     // Drive the admin Plugin read models via synthetic Connect dispatch through
     // LocalPluginAggregate (replaces the old direct-write seed).
     connectPlugin(~pluginComponents=[pluginComponent])
-    seedUIFragmentRegistryQueryDb(~pluginComponents=[pluginComponent])
     seedPluginStructuresStore(~pluginComponents=[pluginComponent])
 
     // Fire onPluginDeployed hooks so subscribers learn about this plugin.