@reventlessdev/reventless-core 3.0.0-alpha.156 → 3.0.0-alpha.157

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.157 (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:** 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))
+
+
 # 3.0.0-alpha.156 (2026-07-11)
 
 **Note:** Version bump only for package @reventlessdev/reventless-core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.156",
+  "version": "3.0.0-alpha.157",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.12",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.11",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.12",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.11",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.12",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.15",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.97",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.75",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.26"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/admin/AdminApi.res

@@ -25,9 +25,55 @@ let mutationEntries = (~cloner: bool) => {
 
 let queryEntries = PluginBaseFragment.queryEntries
 
+// ApiFragmentRegistry admin mutations — the real GraphQL surface of the ApiFragmentRegistry
+// StateChangeSlice: the plugin / standalone-service deploy calls `Platform_RegisterApiFragment` /
+// `Platform_DeregisterApiFragment` as a SigV4 system caller. Field names + arg SDL + the nested
+// `fragment` input type are derived from the slice's `commandSchema` via the SAME
+// `Api_Naming.sliceMutationFields` (admin "Platform" prefix) + `GraphQL_FragmentGenerator` path
+// that the DCB builder uses, so the field declared here in the STATIC admin base is byte-identical
+// to the one the DCB resolver binds to (`RecordApiFragmentPush` is `@noApi`, filtered out).
+//
+// These live in `baseFragment` ONLY, never in the shared `mutationEntries`: only the static base is
+// pushed to AppSync (`Platform.res` preAdminResolversSchemaHook), whereas the constructed admin
+// fragment (`Platform_Admin.construct`) already carries them via `dcbResult.mutationEntries`. Adding
+// them to `mutationEntries` — which feeds both — would duplicate the fields in the constructed
+// fragment. They are folded into `baseFragment`'s own `generate` call (not a separate one) so its
+// shared `seenTypes` dedups the shared `CommandResult` type family instead of re-emitting it.
+let apiFragmentRegistryMutationEntries: array<mutationSchemaEntry> = {
+  let commandSchema = ApiFragmentRegistry.commandSchema->S.castToUnknown
+  let fieldSpecs = Api_Naming.sliceMutationFields(
+    ~plugin="Platform",
+    ~slice=ApiFragmentRegistry.name,
+    ~commandSchema,
+  )
+  if fieldSpecs->Array.length === 0 {
+    []
+  } else {
+    [
+      {
+        ReventlessInfra.Api.fieldNames: fieldSpecs->Array.map(((f, _)) => f),
+        commandSchema,
+      },
+    ]
+  }
+}
+
+// Admin fields a deploy-time system caller (machine credentials — SigV4/IAM on AWS) invokes: the
+// two ApiFragmentRegistry mutations (the deploy's register/deregister write path) and
+// `Platform_ApiFragments` (the deploy waiter's push-status poll). Provider-neutral by design — the
+// AWS adapter threads these into `injectAwsAuthAll`'s `~iamFieldNames` so only these fields carry
+// the dual-auth (`@aws_cognito_user_pools @aws_iam`) directive; every other admin field stays
+// Cognito-only. Derived from the same mutation entries so the names never drift from the SDL.
+let systemCallerFieldNames =
+  apiFragmentRegistryMutationEntries
+  ->Array.flatMap(e => e.fieldNames)
+  ->Array.concat([Platform_ApiFragmentsApi.queryFieldName])
+
 // UIFragment lifecycle Source C subscriptions.
-// Mutations are called by the backend when UIFragment events occur;
-// AppSync routes via @aws_subscribe to onUIFragmentChange subscribers.
+// Mutations are called by the backend when UIFragment events occur; the
+// subscription→mutation fan-in is carried as neutral `subscriptionSource`
+// metadata (providers add their own routing — AppSync via `@aws_subscribe`
+// appended at push time, the local platform via its PubSub bridge).
 // manifest is serialised as a JSON string (String scalar, not AWSJSON).
 
 let uiFragmentSubscriptionTypes = [
@@ -41,12 +87,21 @@ let uiFragmentMutationFields = [
   `  Platform_UIFragmentDeregistered(pluginId: ID!): UIFragmentChangeEvent`,
 ]
 
-let uiFragmentSubscriptionField = `  onUIFragmentChange: UIFragmentChangeEvent\n    @aws_subscribe(mutations: ["Platform_UIFragmentRegistered", "Platform_UIFragmentUpdated", "Platform_UIFragmentDeregistered"])`
+let uiFragmentSubscriptionField = `  onUIFragmentChange: UIFragmentChangeEvent`
+
+let uiFragmentSubscriptionSource: GraphQL_Stitcher.subscriptionSource = {
+  field: "onUIFragmentChange",
+  mutations: [
+    "Platform_UIFragmentRegistered",
+    "Platform_UIFragmentUpdated",
+    "Platform_UIFragmentDeregistered",
+  ],
+}
 
 // Plugin lifecycle Source C subscription. Mirrors the UIFragment pattern: the
 // platform invokes `Platform_PluginStatusChanged` after writing the new status
-// to the Plugin read model; AppSync routes that mutation via `@aws_subscribe`
-// to live `onPluginStatusChange` subscribers (host shell). The status enum
+// to the Plugin read model; the provider routes that mutation to live
+// `onPluginStatusChange` subscribers (host shell). The status enum
 // matches `PluginsReadModelSpec.status` so consumers can mirror tier 1 / tier 2
 // transitions exactly.
 let pluginStatusSubscriptionTypes = [
@@ -58,31 +113,46 @@ let pluginStatusMutationFields = [
   `  Platform_PluginStatusChanged(pluginId: ID!, status: PluginStatus!): PluginStatusChangeEvent`,
 ]
 
-let pluginStatusSubscriptionField = `  onPluginStatusChange: PluginStatusChangeEvent\n    @aws_subscribe(mutations: ["Platform_PluginStatusChanged"])`
+let pluginStatusSubscriptionField = `  onPluginStatusChange: PluginStatusChangeEvent`
+
+let pluginStatusSubscriptionSource: GraphQL_Stitcher.subscriptionSource = {
+  field: "onPluginStatusChange",
+  mutations: ["Platform_PluginStatusChanged"],
+}
 
 let baseFragment = (~cloner: bool) => {
-  let base = GraphQL_FragmentGenerator.generate(~mutationEntries=mutationEntries(~cloner), ~queryEntries)
+  let base = GraphQL_FragmentGenerator.generate(
+    ~mutationEntries=Array.concat(mutationEntries(~cloner), apiFragmentRegistryMutationEntries),
+    ~queryEntries,
+  )
   let parts = GraphQL_Stitcher.decode(base)
   // Source C subscriptions for the admin Plugin aggregate mutations.
   // The standard auto-resolver flow (CommandGeneratorResolvers_AppSync.make)
   // always creates a Subscription.onX resolver per mutation field; without the
   // matching SDL fields, AppSync's CreateResolver fails with "Type not found".
-  let pluginAggregateSubscriptionFields =
+  let (pluginAggregateSubscriptionFields, pluginAggregateSubscriptionSources) =
     Plugin_SubscriptionSchema.sourceCFields(~mutationEntries=PluginBaseFragment.pluginAggregateMutationEntries)
   GraphQL_Stitcher.encode({
     types: parts.types
     ->Array.concat(uiFragmentSubscriptionTypes)
     ->Array.concat(pluginStatusSubscriptionTypes)
     ->Array.concat(Platform_ComponentDefinitionsApi.sdlTypes)
-    ->Array.concat(Platform_UIFragmentsApi.sdlTypes),
+    ->Array.concat(Platform_UIFragmentsApi.sdlTypes)
+    ->Array.concat(Platform_ApiFragmentsApi.sdlTypes),
     queries: Array.concat(
       parts.queries,
-      [Platform_ComponentDefinitionsApi.sdlQueryField, Platform_UIFragmentsApi.sdlQueryField],
+      [
+        Platform_ComponentDefinitionsApi.sdlQueryField,
+        Platform_UIFragmentsApi.sdlQueryField,
+        Platform_ApiFragmentsApi.sdlQueryField,
+      ],
     ),
     mutations: parts.mutations
     ->Array.concat(uiFragmentMutationFields)
     ->Array.concat(pluginStatusMutationFields),
     subscriptions: [uiFragmentSubscriptionField, pluginStatusSubscriptionField]
     ->Array.concat(pluginAggregateSubscriptionFields),
+    subscriptionSources: [uiFragmentSubscriptionSource, pluginStatusSubscriptionSource]
+    ->Array.concat(pluginAggregateSubscriptionSources),
   })
 }

package/src/admin/AdminApi.res.mjs

@@ -4,7 +4,9 @@ import * as S from "sury/src/S.res.mjs";
 import * as Api_Naming$ReventlessCore from "../components/Api/Api_Naming.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../components/Api/GraphQL_Stitcher.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "../plugin/api/PluginBaseFragment.res.mjs";
+import * as ApiFragmentRegistry$ReventlessCore from "./ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res.mjs";
 import * as Platform_UIFragmentsApi$ReventlessCore from "./Platform_UIFragmentsApi.res.mjs";
+import * as Platform_ApiFragmentsApi$ReventlessCore from "./Platform_ApiFragmentsApi.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../components/Api/GraphQL_FragmentGenerator.res.mjs";
 import * as Plugin_SubscriptionSchema$ReventlessCore from "../plugin/component/Plugin_SubscriptionSchema.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "./Platform_ComponentDefinitionsApi.res.mjs";
@@ -31,6 +33,15 @@ function mutationEntries(cloner) {
   }
 }
 
+let fieldSpecs = Api_Naming$ReventlessCore.sliceMutationFields("Platform", ApiFragmentRegistry$ReventlessCore.name, ApiFragmentRegistry$ReventlessCore.commandSchema);
+
+let apiFragmentRegistryMutationEntries = fieldSpecs.length === 0 ? [] : [{
+      fieldNames: fieldSpecs.map(param => param[0]),
+      commandSchema: ApiFragmentRegistry$ReventlessCore.commandSchema
+    }];
+
+let systemCallerFieldNames = apiFragmentRegistryMutationEntries.flatMap(e => e.fieldNames).concat([Platform_ApiFragmentsApi$ReventlessCore.queryFieldName]);
+
 let uiFragmentSubscriptionTypes = [
   `enum UIFragmentChangeKind {\n  Registered\n  Updated\n  Deregistered\n}`,
   `type UIFragmentChangeEvent {\n  pluginId: ID!\n  changeKind: UIFragmentChangeKind!\n  manifest: String\n}`
@@ -42,7 +53,18 @@ let uiFragmentMutationFields = [
   `  Platform_UIFragmentDeregistered(pluginId: ID!): UIFragmentChangeEvent`
 ];
 
-let uiFragmentSubscriptionField = `  onUIFragmentChange: UIFragmentChangeEvent\n    @aws_subscribe(mutations: ["Platform_UIFragmentRegistered", "Platform_UIFragmentUpdated", "Platform_UIFragmentDeregistered"])`;
+let uiFragmentSubscriptionField = `  onUIFragmentChange: UIFragmentChangeEvent`;
+
+let uiFragmentSubscriptionSource_mutations = [
+  "Platform_UIFragmentRegistered",
+  "Platform_UIFragmentUpdated",
+  "Platform_UIFragmentDeregistered"
+];
+
+let uiFragmentSubscriptionSource = {
+  field: "onUIFragmentChange",
+  mutations: uiFragmentSubscriptionSource_mutations
+};
 
 let pluginStatusSubscriptionTypes = [
   `enum PluginStatus {\n  Connected\n  Disconnected\n  Inactive\n  Retired\n}`,
@@ -51,23 +73,35 @@ let pluginStatusSubscriptionTypes = [
 
 let pluginStatusMutationFields = [`  Platform_PluginStatusChanged(pluginId: ID!, status: PluginStatus!): PluginStatusChangeEvent`];
 
-let pluginStatusSubscriptionField = `  onPluginStatusChange: PluginStatusChangeEvent\n    @aws_subscribe(mutations: ["Platform_PluginStatusChanged"])`;
+let pluginStatusSubscriptionField = `  onPluginStatusChange: PluginStatusChangeEvent`;
+
+let pluginStatusSubscriptionSource_mutations = ["Platform_PluginStatusChanged"];
+
+let pluginStatusSubscriptionSource = {
+  field: "onPluginStatusChange",
+  mutations: pluginStatusSubscriptionSource_mutations
+};
 
 function baseFragment(cloner) {
-  let base = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries(cloner), PluginBaseFragment$ReventlessCore.queryEntries);
+  let base = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries(cloner).concat(apiFragmentRegistryMutationEntries), PluginBaseFragment$ReventlessCore.queryEntries);
   let parts = GraphQL_Stitcher$ReventlessCore.decode(base);
-  let pluginAggregateSubscriptionFields = Plugin_SubscriptionSchema$ReventlessCore.sourceCFields(PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries);
+  let match = Plugin_SubscriptionSchema$ReventlessCore.sourceCFields(PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries);
   return GraphQL_Stitcher$ReventlessCore.encode({
-    types: parts.types.concat(uiFragmentSubscriptionTypes).concat(pluginStatusSubscriptionTypes).concat(Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes).concat(Platform_UIFragmentsApi$ReventlessCore.sdlTypes),
+    types: parts.types.concat(uiFragmentSubscriptionTypes).concat(pluginStatusSubscriptionTypes).concat(Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes).concat(Platform_UIFragmentsApi$ReventlessCore.sdlTypes).concat(Platform_ApiFragmentsApi$ReventlessCore.sdlTypes),
     mutations: parts.mutations.concat(uiFragmentMutationFields).concat(pluginStatusMutationFields),
     queries: parts.queries.concat([
       Platform_ComponentDefinitionsApi$ReventlessCore.sdlQueryField,
-      Platform_UIFragmentsApi$ReventlessCore.sdlQueryField
+      Platform_UIFragmentsApi$ReventlessCore.sdlQueryField,
+      Platform_ApiFragmentsApi$ReventlessCore.sdlQueryField
     ]),
     subscriptions: [
       uiFragmentSubscriptionField,
       pluginStatusSubscriptionField
-    ].concat(pluginAggregateSubscriptionFields)
+    ].concat(match[0]),
+    subscriptionSources: [
+      uiFragmentSubscriptionSource,
+      pluginStatusSubscriptionSource
+    ].concat(match[1])
   });
 }
 
@@ -78,12 +112,16 @@ export {
   cloneMutationEntry,
   mutationEntries,
   queryEntries,
+  apiFragmentRegistryMutationEntries,
+  systemCallerFieldNames,
   uiFragmentSubscriptionTypes,
   uiFragmentMutationFields,
   uiFragmentSubscriptionField,
+  uiFragmentSubscriptionSource,
   pluginStatusSubscriptionTypes,
   pluginStatusMutationFields,
   pluginStatusSubscriptionField,
+  pluginStatusSubscriptionSource,
   baseFragment,
 }
 /* cloneArgsSchema Not a pure module */

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res

@@ -0,0 +1,65 @@
+// ApiFragmentRegistry StateChangeSlice — the write side of the platform API-schema
+// fragment registry, replacing the raw `deploy-schema:*` keyspace (see
+// docs/plans/event-sourced-fragment-registries.md).
+//
+// Unlike the UiFragmentRegistry (connect/disconnect-driven), this registry's transitions
+// are driven by the DEPLOY / DESTROY of a plugin stack: the deploy registers its fragment
+// as a SigV4 system caller against the Platform API, and only final retirement
+// (`pulumi destroy`, resolvers gone) deregisters. Version supersession must NOT
+// deregister — the registry is keyed by plugin NAME, so a successor's deploy overwrites
+// its predecessor's fragment in place.
+//
+// The registry is idempotent: re-registering an identical fragment is a no-op,
+// deregistering an absent fragment is a no-op — it never rejects a command.
+//
+// `RecordApiFragmentPush` is the write-back of the single-writer schema-push automation:
+// after stitching and pushing the composed schema it records the outcome (ok / error +
+// message) on the row of the plugin whose fragment change triggered the push, so a
+// deploy waiter can poll the push status instead of timing out on introspection.
+@@reventless.spec
+
+open Reventless.Plugin
+
+// `at` is the registration timestamp, stamped from the incoming command meta by the
+// dispatching mapping — the StateViewSlice projection has no event meta, so time must
+// ride the payload. Inline records let the ppx auto-tag `pluginId` (scoping the decision
+// read to one plugin name). `message` is a plain string ("" = none) — option fields in
+// variant payloads don't survive the T|null wire contract cleanly.
+//
+// `apiTarget` is the API this plugin's fields belong to — Domain (the default) or Platform.
+// A plugin assigned to the Platform API (e.g. a platform inspector) stitches into the
+// Platform-API schema, not the Domain-API one; the single-writer push automation groups
+// fragments by this target and maintains one cumulative schema per API.
+// `RegisterApiFragment` / `DeregisterApiFragment` ARE the GraphQL surface — the deploy calls them
+// as a SigV4 system caller against the Platform API (exposed as `Platform_RegisterApiFragment` /
+// `Platform_DeregisterApiFragment`). `RecordApiFragmentPush` is `@noApi`: it is the internal
+// write-back of the single-writer schema-push automation, dispatched platform-side, never by a
+// GraphQL caller.
+@schema
+type command =
+  | RegisterApiFragment({pluginId: string, fragment: apiSchemaFragment, apiTarget: apiTarget, at: string})
+  | DeregisterApiFragment({pluginId: string})
+  | @noApi RecordApiFragmentPush({pluginId: string, ok: bool, message: string, at: string})
+
+// The registry never rejects (idempotent register/deregister/record); this variant is
+// never returned.
+@schema
+type error = | RegistryError
+
+@schema
+type event =
+  | ApiFragmentRegistered({pluginId: string, fragment: apiSchemaFragment, apiTarget: apiTarget, at: string})
+  | ApiFragmentUpdated({
+      pluginId: string,
+      previousFragment: apiSchemaFragment,
+      newFragment: apiSchemaFragment,
+      apiTarget: apiTarget,
+      at: string,
+    })
+  | ApiFragmentDeregistered({pluginId: string})
+  | ApiFragmentPushRecorded({pluginId: string, ok: bool, message: string, at: string})
+
+// This slice reads exactly the events it writes, so consumedEvent IS event — one inline
+// event type, no duplicate-constructor collision, ppx auto-tags `pluginId` on both roles.
+@schema
+type consumedEvent = event

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res.mjs

@@ -0,0 +1,87 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "RegisterApiFragment",
+    pluginId: s.m(DcbTag$Reventless.string),
+    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "DeregisterApiFragment",
+    pluginId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "RecordApiFragmentPush",
+    pluginId: s.m(DcbTag$Reventless.string),
+    ok: s.m(S.bool),
+    message: s.m(S.string),
+    at: s.m(S.string)
+  }))
+]);
+
+let errorSchema = S.literal("RegistryError");
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ApiFragmentRegistered",
+    pluginId: s.m(DcbTag$Reventless.string),
+    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentUpdated",
+    pluginId: s.m(DcbTag$Reventless.string),
+    previousFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    newFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentDeregistered",
+    pluginId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentPushRecorded",
+    pluginId: s.m(DcbTag$Reventless.string),
+    ok: s.m(S.bool),
+    message: s.m(S.string),
+    at: s.m(S.string)
+  }))
+]);
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, ["RecordApiFragmentPush"]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ApiFragmentRegistry";
+
+let Id;
+
+let consumedEventSchema = eventSchema;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  errorSchema,
+  eventSchema,
+  consumedEventSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* commandSchema Not a pure module */

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res

@@ -0,0 +1,58 @@
+@@reventless.behavior
+
+open Reventless.Plugin
+
+// The current fragment for this plugin name plus its target API and the last recorded push
+// outcome (kept only to dedupe at-least-once redelivery of RecordApiFragmentPush), or None
+// when no fragment is registered.
+type registryEntry = {
+  fragment: apiSchemaFragment,
+  apiTarget: apiTarget,
+  lastPush: option<(bool, string, string)>, // (ok, message, at)
+}
+type state = option<registryEntry>
+
+let initialState = None
+
+let evolve = (state, event) =>
+  switch event {
+  | ApiFragmentRegistered({fragment, apiTarget}) => Some({fragment, apiTarget, lastPush: None})
+  | ApiFragmentUpdated({newFragment, apiTarget}) =>
+    Some({fragment: newFragment, apiTarget, lastPush: None})
+  | ApiFragmentDeregistered(_) => None
+  | ApiFragmentPushRecorded({ok, message, at}) =>
+    state->Option.map(entry => {...entry, lastPush: Some((ok, message, at))})
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | RegisterApiFragment({pluginId, fragment, apiTarget, at}) =>
+    switch state {
+    | None => Ok([ApiFragmentRegistered({pluginId, fragment, apiTarget, at})])
+    // Idempotent: an unchanged re-registration (same fragment AND same target — e.g. a
+    // redeploy carrying the same schema, or a version supersession that didn't change the
+    // SDL) emits nothing. A target change with an identical fragment IS meaningful (the
+    // fields move between the Domain and Platform APIs), so it is not a no-op.
+    | Some({fragment: current, apiTarget: currentTarget})
+      if current == fragment && currentTarget == apiTarget =>
+      Ok([])
+    | Some({fragment: current}) =>
+      Ok([
+        ApiFragmentUpdated({pluginId, previousFragment: current, newFragment: fragment, apiTarget, at}),
+      ])
+    }
+  | DeregisterApiFragment({pluginId}) =>
+    switch state {
+    | None => Ok([]) // idempotent — nothing registered
+    | Some(_) => Ok([ApiFragmentDeregistered({pluginId: pluginId})])
+    }
+  | RecordApiFragmentPush({pluginId, ok, message, at}) =>
+    switch state {
+    | None => Ok([]) // fragment deregistered in the meantime — nowhere to record
+    // Idempotent: an at-least-once redelivery carries the identical payload.
+    | Some({lastPush: Some((lastOk, lastMessage, lastAt))})
+      if lastOk == ok && lastMessage == message && lastAt == at =>
+      Ok([])
+    | Some(_) => Ok([ApiFragmentPushRecorded({pluginId, ok, message, at})])
+    }
+  }

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res.mjs

@@ -0,0 +1,135 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function evolve(state, event) {
+  switch (event.TAG) {
+    case "ApiFragmentRegistered" :
+      return {
+        fragment: event.fragment,
+        apiTarget: event.apiTarget,
+        lastPush: undefined
+      };
+    case "ApiFragmentUpdated" :
+      return {
+        fragment: event.newFragment,
+        apiTarget: event.apiTarget,
+        lastPush: undefined
+      };
+    case "ApiFragmentDeregistered" :
+      return;
+    case "ApiFragmentPushRecorded" :
+      let at = event.at;
+      let message = event.message;
+      let ok = event.ok;
+      return Stdlib_Option.map(state, entry => ({
+        fragment: entry.fragment,
+        apiTarget: entry.apiTarget,
+        lastPush: [
+          ok,
+          message,
+          at
+        ]
+      }));
+  }
+}
+
+function decide(state, command) {
+  switch (command.TAG) {
+    case "RegisterApiFragment" :
+      let at = command.at;
+      let apiTarget = command.apiTarget;
+      let fragment = command.fragment;
+      let pluginId = command.pluginId;
+      if (state === undefined) {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "ApiFragmentRegistered",
+              pluginId: pluginId,
+              fragment: fragment,
+              apiTarget: apiTarget,
+              at: at
+            }]
+        };
+      }
+      let current = state.fragment;
+      if (Primitive_object.equal(current, fragment) && state.apiTarget === apiTarget) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "ApiFragmentUpdated",
+              pluginId: pluginId,
+              previousFragment: current,
+              newFragment: fragment,
+              apiTarget: apiTarget,
+              at: at
+            }]
+        };
+      }
+    case "DeregisterApiFragment" :
+      if (state !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "ApiFragmentDeregistered",
+              pluginId: command.pluginId
+            }]
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+    case "RecordApiFragmentPush" :
+      if (state === undefined) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      let match = state.lastPush;
+      let at$1 = command.at;
+      let message = command.message;
+      let ok = command.ok;
+      if (match !== undefined && match[0] === ok && match[1] === message && match[2] === at$1) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "ApiFragmentPushRecorded",
+            pluginId: command.pluginId,
+            ok: ok,
+            message: message,
+            at: at$1
+          }]
+      };
+      break;
+  }
+}
+
+let Spec;
+
+let initialState;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */