@reventlessdev/reventless-core 3.0.0-alpha.159 → 3.0.0-alpha.161

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.161 (2026-07-13)
+
+### Features
+
+* **admin:** ApiFragmentRegistry singleton aggregate + ApiFragments read model (foundation) ([3203512](https://github.com/ReventlessDev/reventless-core/commit/3203512f8b312e7ce6361ffb7a89e6659364dcb8)), closes [#4](https://github.com/ReventlessDev/reventless-core/issues/4)
+* **admin:** ApiFragmentRegistry slice→singleton-aggregate + reactive schema-push SideEffect ([cf70903](https://github.com/ReventlessDev/reventless-core/commit/cf709033f0d822248ebbcfe3fe6b4019b3c1e8a0)), closes [#4](https://github.com/ReventlessDev/reventless-core/issues/4)
+
+
+# 3.0.0-alpha.160 (2026-07-13)
+
+### Bug Fixes
+
+* **api:** dual-auth arg-less IAM fields — extractLeadingName dropped the trailing colon ([ea34da2](https://github.com/ReventlessDev/reventless-core/commit/ea34da229164db63988ad035138c17ba9134ac55))
+
+
 # 3.0.0-alpha.159 (2026-07-12)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.159",
+  "version": "3.0.0-alpha.161",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "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-hash-object": "1.2.0-alpha.11",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.11",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.12",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
+    "@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/rescript-uuid": "1.1.0-alpha.15",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.76",
-    "@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

@@ -9,55 +9,55 @@ let cloneMutationEntry: mutationSchemaEntry = {
   description: "Clone the system to a specific point in time",
 }
 
-// Aggregate-derived admin mutations come from
-// `PluginBaseFragment.pluginAggregateMutationEntries` so they end up in the
-// stitched SDL (the AWS path pushes `AdminApi.baseFragment` directly). The
-// corresponding resolver wiring is fired in parallel by
-// `Plugin_Helpers.registerAdminAggregateMutations` from `Platform_Admin.construct`.
-let mutationEntries = (~cloner: bool) => {
-  let base = PluginBaseFragment.pluginAggregateMutationEntries
-  if cloner {
-    Array.concat(base, [cloneMutationEntry])
-  } else {
-    base
-  }
-}
-
-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.
+// singleton aggregate: the plugin / standalone-service deploy calls
+// `Platform_ApiFragmentRegistry_RegisterApiFragment` / `..._DeregisterApiFragment` as a SigV4
+// system caller. Derived from the aggregate's `commandSchema` exactly like the Plugin aggregate's
+// entries (`PluginBaseFragment.pluginAggregateMutationEntries`) — one `Platform_<Spec>_<Command>`
+// field per non-`@noApi` variant (`RecordApiFragmentPush` is `@noApi`, filtered out). The matching
+// resolver wiring is fired by `Plugin_Helpers.registerAdminAggregateMutations` over the same
+// `~aggregates` list in `Platform_Admin.construct`, so the SDL field and the auto-bound resolver
+// carry byte-identical names.
 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 {
+  let commandSchema = ApiFragmentRegistrySpec.commandSchema->S.castToUnknown
+  let constructorNames = Reventless.DcbTag.extractAllVariantNames(ApiFragmentRegistrySpec.commandSchema)
+  let filteredConstructorNames = ApiNoApiHelpers.filterNoApiVariants(constructorNames, commandSchema)
+  let fieldNames =
+    filteredConstructorNames->Array.map(cname =>
+      Api_Naming.adminField(~name=ApiFragmentRegistrySpec.name ++ "_" ++ cname)
+    )
+  if fieldNames->Array.length === 0 {
     []
   } else {
     [
       {
-        ReventlessInfra.Api.fieldNames: fieldSpecs->Array.map(((f, _)) => f),
+        ReventlessInfra.Api.fieldNames,
         commandSchema,
       },
     ]
   }
 }
 
+// Aggregate-derived admin mutations come from `PluginBaseFragment.pluginAggregateMutationEntries`
+// (Plugin aggregate) + `apiFragmentRegistryMutationEntries` (ApiFragmentRegistry aggregate) so they
+// end up in the stitched SDL AND in the static `baseFragment` the AWS path pushes directly. The
+// corresponding resolver wiring is fired in parallel by
+// `Plugin_Helpers.registerAdminAggregateMutations` from `Platform_Admin.construct` over the same
+// `~aggregates` list.
+let mutationEntries = (~cloner: bool) => {
+  let base = Array.concat(
+    PluginBaseFragment.pluginAggregateMutationEntries,
+    apiFragmentRegistryMutationEntries,
+  )
+  if cloner {
+    Array.concat(base, [cloneMutationEntry])
+  } else {
+    base
+  }
+}
+
+let queryEntries = PluginBaseFragment.queryEntries
+
 // 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
@@ -122,7 +122,7 @@ let pluginStatusSubscriptionSource: GraphQL_Stitcher.subscriptionSource = {
 
 let baseFragment = (~cloner: bool) => {
   let base = GraphQL_FragmentGenerator.generate(
-    ~mutationEntries=Array.concat(mutationEntries(~cloner), apiFragmentRegistryMutationEntries),
+    ~mutationEntries=mutationEntries(~cloner),
     ~queryEntries,
   )
   let parts = GraphQL_Stitcher.decode(base)

package/src/admin/AdminApi.res.mjs

@@ -1,10 +1,12 @@
 // 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 Api_Naming$ReventlessCore from "../components/Api/Api_Naming.res.mjs";
+import * as ApiNoApiHelpers$ReventlessCore from "../components/Api/ApiNoApiHelpers.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 ApiFragmentRegistrySpec$ReventlessCore from "./ApiFragmentRegistry/ApiFragmentRegistrySpec.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";
@@ -25,21 +27,26 @@ let cloneMutationEntry = {
   description: cloneMutationEntry_description
 };
 
+let constructorNames = DcbTag$Reventless.extractAllVariantNames(ApiFragmentRegistrySpec$ReventlessCore.commandSchema);
+
+let filteredConstructorNames = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(constructorNames, ApiFragmentRegistrySpec$ReventlessCore.commandSchema);
+
+let fieldNames = filteredConstructorNames.map(cname => Api_Naming$ReventlessCore.adminField(ApiFragmentRegistrySpec$ReventlessCore.name + "_" + cname));
+
+let apiFragmentRegistryMutationEntries = fieldNames.length === 0 ? [] : [{
+      fieldNames: fieldNames,
+      commandSchema: ApiFragmentRegistrySpec$ReventlessCore.commandSchema
+    }];
+
 function mutationEntries(cloner) {
+  let base = PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries.concat(apiFragmentRegistryMutationEntries);
   if (cloner) {
-    return PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries.concat([cloneMutationEntry]);
+    return base.concat([cloneMutationEntry]);
   } else {
-    return PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries;
+    return base;
   }
 }
 
-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 = [
@@ -83,7 +90,7 @@ let pluginStatusSubscriptionSource = {
 };
 
 function baseFragment(cloner) {
-  let base = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries(cloner).concat(apiFragmentRegistryMutationEntries), PluginBaseFragment$ReventlessCore.queryEntries);
+  let base = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries(cloner), PluginBaseFragment$ReventlessCore.queryEntries);
   let parts = GraphQL_Stitcher$ReventlessCore.decode(base);
   let match = Plugin_SubscriptionSchema$ReventlessCore.sourceCFields(PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries);
   return GraphQL_Stitcher$ReventlessCore.encode({
@@ -110,9 +117,9 @@ let queryEntries = PluginBaseFragment$ReventlessCore.queryEntries;
 export {
   cloneArgsSchema,
   cloneMutationEntry,
+  apiFragmentRegistryMutationEntries,
   mutationEntries,
   queryEntries,
-  apiFragmentRegistryMutationEntries,
   systemCallerFieldNames,
   uiFragmentSubscriptionTypes,
   uiFragmentMutationFields,

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res

@@ -0,0 +1,108 @@
+@@reventless.behavior(ApiFragmentRegistrySpec)
+
+// NOTE: no `open Reventless.Plugin` — it would shadow the `encoded`/`protocol` labels reused
+// below when building the fragment snapshot (warning 45). The two Plugin types are qualified.
+
+// The current fragment for a plugin name plus its target API and the last recorded push
+// outcome (kept only to dedupe at-least-once redelivery of RecordApiFragmentPush).
+type registryEntry = {
+  fragment: Reventless.Plugin.apiSchemaFragment,
+  apiTarget: Reventless.Plugin.apiTarget,
+  lastPush: option<(bool, string, string)>, // (ok, message, at)
+}
+
+// Singleton aggregate: the WHOLE registry, keyed by pluginId, in one consistency boundary.
+type state = {entries: dict<registryEntry>}
+
+let initialState = {entries: Dict.make()}
+
+// Framework-internal aggregate outside an Aggregate/ folder — the Behavior.T snapshot/counter
+// fields are satisfied manually (mirrors PluginBehavior). The registry's history is short
+// (deploy-frequency writes), so persisted snapshots would buy nothing.
+let snapshot = None
+let atomicCounter = None
+
+// Immutable dict updates (no reliance on Dict.copy/Dict.delete): rebuild via toArray/fromArray
+// so evolve never mutates the replayed state.
+let entriesWith = (entries: dict<registryEntry>, pluginId, entry) =>
+  entries
+  ->Dict.toArray
+  ->Array.filter(((k, _)) => k != pluginId)
+  ->Array.concat([(pluginId, entry)])
+  ->Dict.fromArray
+
+let entriesWithout = (entries: dict<registryEntry>, pluginId) =>
+  entries->Dict.toArray->Array.filter(((k, _)) => k != pluginId)->Dict.fromArray
+
+let evolve = (state, event) =>
+  switch event {
+  | ApiFragmentRegistered({pluginId, fragment, apiTarget}) => {
+      entries: state.entries->entriesWith(pluginId, {fragment, apiTarget, lastPush: None}),
+    }
+  | ApiFragmentUpdated({pluginId, newFragment, apiTarget}) => {
+      entries: state.entries->entriesWith(pluginId, {fragment: newFragment, apiTarget, lastPush: None}),
+    }
+  | ApiFragmentDeregistered({pluginId}) => {entries: state.entries->entriesWithout(pluginId)}
+  | ApiFragmentPushRecorded({pluginId, ok, message, at}) =>
+    switch state.entries->Dict.get(pluginId) {
+    | Some(entry) => {
+        entries: state.entries->entriesWith(pluginId, {...entry, lastPush: Some((ok, message, at))}),
+      }
+    | None => state
+    }
+  // Derived echo — no fold change.
+  | ApiSchemaComputed(_) => state
+  }
+
+// The consistent registry snapshot AFTER the triggering change — one entry per registered plugin.
+let snapshotOf = (entries: dict<registryEntry>): array<ApiFragmentRegistrySpec.fragmentSnapshotEntry> =>
+  entries
+  ->Dict.toArray
+  ->Array.map(((pluginId, e)) => {
+    ApiFragmentRegistrySpec.pluginId,
+    encoded: e.fragment.encoded,
+    protocol: e.fragment.protocol,
+    apiTarget: e.apiTarget,
+  })
+
+// Emit the fact event plus ApiSchemaComputed{snapshot} folded from the POST-change state, so the
+// reactive push SideEffect stitches from consistent state. Idempotent no-ops emit nothing (and
+// therefore no push). RecordApiFragmentPush records the outcome only — it changes no fragments,
+// so it emits no ApiSchemaComputed (which also avoids a recompute loop).
+let decide = (state, command) => {
+  let withSchema = (fact: ApiFragmentRegistrySpec.event) => {
+    let next = evolve(state, fact)
+    Ok([fact, ApiSchemaComputed({snapshot: snapshotOf(next.entries)})])
+  }
+  switch command {
+  | RegisterApiFragment({pluginId, fragment, apiTarget, at}) =>
+    switch state.entries->Dict.get(pluginId) {
+    | None => withSchema(ApiFragmentRegistered({pluginId, fragment, apiTarget, at}))
+    // Idempotent: an unchanged re-registration (same fragment AND same target — 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}) =>
+      withSchema(
+        ApiFragmentUpdated({pluginId, previousFragment: current, newFragment: fragment, apiTarget, at}),
+      )
+    }
+  | DeregisterApiFragment({pluginId}) =>
+    switch state.entries->Dict.get(pluginId) {
+    | None => Ok([]) // idempotent — nothing registered
+    | Some(_) => withSchema(ApiFragmentDeregistered({pluginId: pluginId}))
+    }
+  | RecordApiFragmentPush({pluginId, ok, message, at}) =>
+    switch state.entries->Dict.get(pluginId) {
+    | 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/ApiFragmentRegistryBehavior.res.mjs

@@ -0,0 +1,190 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+let initialState = {
+  entries: {}
+};
+
+function entriesWith(entries, pluginId, entry) {
+  return Object.fromEntries(Object.entries(entries).filter(param => param[0] !== pluginId).concat([[
+      pluginId,
+      entry
+    ]]));
+}
+
+function entriesWithout(entries, pluginId) {
+  return Object.fromEntries(Object.entries(entries).filter(param => param[0] !== pluginId));
+}
+
+function evolve(state, event) {
+  switch (event.TAG) {
+    case "ApiFragmentRegistered" :
+      return {
+        entries: entriesWith(state.entries, event.pluginId, {
+          fragment: event.fragment,
+          apiTarget: event.apiTarget,
+          lastPush: undefined
+        })
+      };
+    case "ApiFragmentUpdated" :
+      return {
+        entries: entriesWith(state.entries, event.pluginId, {
+          fragment: event.newFragment,
+          apiTarget: event.apiTarget,
+          lastPush: undefined
+        })
+      };
+    case "ApiFragmentDeregistered" :
+      return {
+        entries: entriesWithout(state.entries, event.pluginId)
+      };
+    case "ApiFragmentPushRecorded" :
+      let pluginId = event.pluginId;
+      let entry = state.entries[pluginId];
+      if (entry !== undefined) {
+        return {
+          entries: entriesWith(state.entries, pluginId, {
+            fragment: entry.fragment,
+            apiTarget: entry.apiTarget,
+            lastPush: [
+              event.ok,
+              event.message,
+              event.at
+            ]
+          })
+        };
+      } else {
+        return state;
+      }
+    case "ApiSchemaComputed" :
+      return state;
+  }
+}
+
+function snapshotOf(entries) {
+  return Object.entries(entries).map(param => {
+    let e = param[1];
+    return {
+      pluginId: param[0],
+      encoded: e.fragment.encoded,
+      protocol: e.fragment.protocol,
+      apiTarget: e.apiTarget
+    };
+  });
+}
+
+function decide(state, command) {
+  let withSchema = fact => {
+    let next = evolve(state, fact);
+    return {
+      TAG: "Ok",
+      _0: [
+        fact,
+        {
+          TAG: "ApiSchemaComputed",
+          snapshot: snapshotOf(next.entries)
+        }
+      ]
+    };
+  };
+  switch (command.TAG) {
+    case "RegisterApiFragment" :
+      let at = command.at;
+      let apiTarget = command.apiTarget;
+      let fragment = command.fragment;
+      let pluginId = command.pluginId;
+      let match = state.entries[pluginId];
+      if (match === undefined) {
+        return withSchema({
+          TAG: "ApiFragmentRegistered",
+          pluginId: pluginId,
+          fragment: fragment,
+          apiTarget: apiTarget,
+          at: at
+        });
+      }
+      let current = match.fragment;
+      if (Primitive_object.equal(current, fragment) && match.apiTarget === apiTarget) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return withSchema({
+          TAG: "ApiFragmentUpdated",
+          pluginId: pluginId,
+          previousFragment: current,
+          newFragment: fragment,
+          apiTarget: apiTarget,
+          at: at
+        });
+      }
+    case "DeregisterApiFragment" :
+      let pluginId$1 = command.pluginId;
+      let match$1 = state.entries[pluginId$1];
+      if (match$1 !== undefined) {
+        return withSchema({
+          TAG: "ApiFragmentDeregistered",
+          pluginId: pluginId$1
+        });
+      } else {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+    case "RecordApiFragmentPush" :
+      let at$1 = command.at;
+      let message = command.message;
+      let ok = command.ok;
+      let pluginId$2 = command.pluginId;
+      let match$2 = state.entries[pluginId$2];
+      if (match$2 === undefined) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      let match$3 = match$2.lastPush;
+      if (match$3 !== undefined && match$3[0] === ok && match$3[1] === message && match$3[2] === at$1) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "ApiFragmentPushRecorded",
+            pluginId: pluginId$2,
+            ok: ok,
+            message: message,
+            at: at$1
+          }]
+      };
+      break;
+  }
+}
+
+let Spec;
+
+let snapshot;
+
+let atomicCounter;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  snapshot,
+  atomicCounter,
+  entriesWith,
+  entriesWithout,
+  evolve,
+  snapshotOf,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistrySpec.res

@@ -0,0 +1,71 @@
+// ApiFragmentRegistry aggregate — the platform API-schema fragment registry, replacing the
+// raw `deploy-schema:*` keyspace (see docs/plans/event-sourced-fragment-registries.md).
+//
+// Modelled as a SINGLETON aggregate (fixed id, e.g. "registry"): the whole registry lives in
+// one consistency boundary / one event stream, so a fragment change reads the whole registry
+// with a single strongly-consistent partition read + snapshot — fixing the lagging-read
+// consistency AND the unbounded-scan cost of the earlier per-plugin DCB-slice design (deploy
+// validation #4). `pluginId` is a payload field here, not the aggregate id.
+//
+// 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 reactive schema-push SideEffect: 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 the deploy waiter can
+// poll the push status instead of timing out on introspection. It is `@noApi` — dispatched
+// platform-side, never by a GraphQL caller.
+@@reventless.spec("ApiFragmentRegistry")
+
+open Reventless.Plugin
+
+// One entry of the consistent registry snapshot carried on `ApiSchemaComputed` — the whole
+// per-plugin fragment set AFTER the triggering change, folded from the aggregate's own
+// consistent state. The push SideEffect stitches per target from this snapshot (splitApi +
+// admin base are its deploy concerns), so consistency is guaranteed without any
+// eventually-consistent read.
+@schema
+type fragmentSnapshotEntry = {
+  pluginId: string,
+  encoded: string,
+  protocol: string,
+  apiTarget: apiTarget,
+}
+
+// `RegisterApiFragment` / `DeregisterApiFragment` ARE the GraphQL surface — the deploy calls
+// them as a SigV4 system caller against the Platform API (exposed via the standard admin-aggregate
+// path as `Platform_RegisterApiFragment` / `Platform_DeregisterApiFragment`; IAM via
+// `systemCallerFieldNames`). `at` is the registration timestamp, threaded so the read-model row
+// can surface registered/updated times.
+@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})
+  // Derived echo of the consistent registry contents after a fragment change — the reactive
+  // push SideEffect's trigger. Carries the full per-plugin snapshot so the SideEffect stitches
+  // from consistent state without a read. Does NOT change fold state (evolve ignores it), and
+  // is NOT projected by the ApiFragments read model.
+  | ApiSchemaComputed({snapshot: array<fragmentSnapshotEntry>})

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

@@ -0,0 +1,92 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.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 fragmentSnapshotEntrySchema = S.schema(s => ({
+  pluginId: s.m(S.string),
+  encoded: s.m(S.string),
+  protocol: s.m(S.string),
+  apiTarget: s.m(Plugin$Reventless.apiTargetSchema)
+}));
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "RegisterApiFragment",
+    pluginId: s.m(S.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(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "RecordApiFragmentPush",
+    pluginId: s.m(S.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(S.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(S.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(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentPushRecorded",
+    pluginId: s.m(S.string),
+    ok: s.m(S.bool),
+    message: s.m(S.string),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiSchemaComputed",
+    snapshot: s.m(S.array(fragmentSnapshotEntrySchema))
+  }))
+]);
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, ["RecordApiFragmentPush"]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ApiFragmentRegistry";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentRegistrySpec.res.mjs";
+
+export {
+  name,
+  Id,
+  fragmentSnapshotEntrySchema,
+  errorSchema,
+  eventSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+}
+/* fragmentSnapshotEntrySchema Not a pure module */

package/src/admin/ApiFragmentRegistry/ApiFragmentsProjection.res

@@ -0,0 +1,63 @@
+// ApiFragments projection — maps ApiFragmentRegistry aggregate events to per-plugin rows of
+// the ApiFragments read model. Manual Mapping.Make form (mirrors PluginsProjection; no ppx —
+// this file lives outside a ReadModel/ folder). Rows are keyed by the payload `pluginId`, not
+// the (singleton) aggregate id. `ApiSchemaComputed` is the reactive push's trigger only — it
+// carries no per-plugin row change, so it is Ignored here.
+//
+// A fragment change resets the row to "pending"; the push outcome arrives as a subsequent
+// ApiFragmentPushRecorded. An Update on a deleted row (a push recorded after deregistration) is
+// a no-op by Update semantics.
+
+open Reventless.Projection
+open Reventless.Message // brings the projection input record ({event, id, meta}) labels into scope
+
+let moduleUrl: string = %raw(`import.meta.url`)
+
+module ApiFragmentsMapping = Reventless.Projection.Mapping.Make(
+  ApiFragmentRegistrySpec,
+  ApiFragmentsReadModelSpec,
+  {
+    let project = ({event, _}) =>
+      switch event {
+      | ApiFragmentRegistrySpec.ApiFragmentRegistered({pluginId, fragment, apiTarget, at}) =>
+        Set(
+          pluginId,
+          {
+            ApiFragmentsReadModelSpec.pluginId,
+            encoded: fragment.encoded,
+            protocol: fragment.protocol,
+            apiTarget,
+            registeredAt: at,
+            updatedAt: at,
+            pushStatus: "pending",
+            pushMessage: "",
+            pushedAt: "",
+          },
+        )
+      | ApiFragmentUpdated({pluginId, newFragment, apiTarget, at}) =>
+        Update(pluginId, state => {
+          ...state,
+          encoded: newFragment.encoded,
+          protocol: newFragment.protocol,
+          apiTarget,
+          updatedAt: at,
+          pushStatus: "pending",
+          pushMessage: "",
+        })
+      | ApiFragmentDeregistered({pluginId}) => Delete(pluginId)
+      | ApiFragmentPushRecorded({pluginId, ok, message, at}) =>
+        Update(pluginId, state => {
+          ...state,
+          pushStatus: ok ? "ok" : "error",
+          pushMessage: message,
+          pushedAt: at,
+        })
+      // Reactive push trigger only — no row change.
+      | ApiSchemaComputed(_) => Ignore
+      }
+  },
+)
+
+module Mappings = Reventless.Projection.Mappings.Make(ApiFragmentsReadModelSpec)
+
+let mappings: array<module(Mappings.Mapping)> = [module(ApiFragmentsMapping)]

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

@@ -0,0 +1,108 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
+import * as ApiFragmentRegistrySpec$ReventlessCore from "./ApiFragmentRegistrySpec.res.mjs";
+import * as ApiFragmentsReadModelSpec$ReventlessCore from "./ApiFragmentsReadModelSpec.res.mjs";
+
+let moduleUrl = import.meta.url;
+
+function project(param) {
+  let event = param.event;
+  switch (event.TAG) {
+    case "ApiFragmentRegistered" :
+      let at = event.at;
+      let fragment = event.fragment;
+      let pluginId = event.pluginId;
+      return {
+        TAG: "Set",
+        _0: pluginId,
+        _1: {
+          pluginId: pluginId,
+          encoded: fragment.encoded,
+          protocol: fragment.protocol,
+          apiTarget: event.apiTarget,
+          registeredAt: at,
+          updatedAt: at,
+          pushStatus: "pending",
+          pushMessage: "",
+          pushedAt: ""
+        }
+      };
+    case "ApiFragmentUpdated" :
+      let at$1 = event.at;
+      let apiTarget = event.apiTarget;
+      let newFragment = event.newFragment;
+      return {
+        TAG: "Update",
+        _0: event.pluginId,
+        _1: state => ({
+          pluginId: state.pluginId,
+          encoded: newFragment.encoded,
+          protocol: newFragment.protocol,
+          apiTarget: apiTarget,
+          registeredAt: state.registeredAt,
+          updatedAt: at$1,
+          pushStatus: "pending",
+          pushMessage: "",
+          pushedAt: state.pushedAt
+        })
+      };
+    case "ApiFragmentDeregistered" :
+      return {
+        TAG: "Delete",
+        _0: event.pluginId
+      };
+    case "ApiFragmentPushRecorded" :
+      let at$2 = event.at;
+      let message = event.message;
+      let ok = event.ok;
+      return {
+        TAG: "Update",
+        _0: event.pluginId,
+        _1: state => ({
+          pluginId: state.pluginId,
+          encoded: state.encoded,
+          protocol: state.protocol,
+          apiTarget: state.apiTarget,
+          registeredAt: state.registeredAt,
+          updatedAt: state.updatedAt,
+          pushStatus: ok ? "ok" : "error",
+          pushMessage: message,
+          pushedAt: at$2
+        })
+      };
+    case "ApiSchemaComputed" :
+      return "Ignore";
+  }
+}
+
+let ApiFragmentsMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: ApiFragmentRegistrySpec$ReventlessCore.name,
+  eventSchema: ApiFragmentRegistrySpec$ReventlessCore.eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: ApiFragmentsReadModelSpec$ReventlessCore.name,
+  stateSchema: ApiFragmentsReadModelSpec$ReventlessCore.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+let Mappings = Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: ApiFragmentsReadModelSpec$ReventlessCore.name,
+  stateSchema: ApiFragmentsReadModelSpec$ReventlessCore.stateSchema,
+  subIdConfig: undefined
+});
+
+let mappings = [ApiFragmentsMapping];
+
+export {
+  moduleUrl,
+  ApiFragmentsMapping,
+  Mappings,
+  mappings,
+}
+/* moduleUrl Not a pure module */

package/src/admin/ApiFragmentRegistry/ApiFragmentsReadModelSpec.res

@@ -0,0 +1,23 @@
+// ApiFragments read model — the read side of the platform API-schema fragment registry:
+// one row per plugin name holding its current fragment plus the outcome of the last schema
+// push that included it. Projected off the ApiFragmentRegistry singleton aggregate (keyed by
+// pluginId from the event payload, NOT by the aggregate id — the aggregate is a singleton).
+// Backs the `Platform_ApiFragments` status query the deploy waiter polls.
+//
+// `pushStatus` is "pending" from registration/update until the reactive push SideEffect records
+// the outcome ("ok" / "error"); `pushMessage`/`pushedAt` are "" until then (plain strings, no
+// option fields — matches the aggregate's wire contract).
+@@reventless.spec("ApiFragments")
+
+@schema
+type state = {
+  pluginId: string,
+  encoded: string,
+  protocol: string,
+  apiTarget: Reventless.Plugin.apiTarget,
+  registeredAt: string,
+  updatedAt: string,
+  pushStatus: string,
+  pushMessage: string,
+  pushedAt: string,
+}

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

@@ -0,0 +1,43 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+let stateSchema = S.schema(s => ({
+  pluginId: s.m(S.string),
+  encoded: s.m(S.string),
+  protocol: s.m(S.string),
+  apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+  registeredAt: s.m(S.string),
+  updatedAt: s.m(S.string),
+  pushStatus: s.m(S.string),
+  pushMessage: s.m(S.string),
+  pushedAt: s.m(S.string)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "ApiFragments";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentsReadModelSpec.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  stateSchema,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* stateSchema Not a pure module */

package/src/admin/Platform_Admin.res

@@ -152,10 +152,6 @@ module Make = (
       // hand-declared admin SDL (`AdminApi.baseFragment`, via `Api_Naming.adminField`) so the
       // auto-bound DCB resolver targets the exact field name that is pushed to the schema.
       ~apiNamePrefix="Platform",
-      // The API-schema registry's Register/Deregister mutations are invoked by the plugin/standalone
-      // deploy as a SigV4 system caller — mark them systemCallable so the AWS provider stamps the
-      // dual-auth (`@aws_cognito_user_pools @aws_iam`) directive on the constructed fragment entries.
-      ~systemCallableComponents=["ApiFragmentRegistry"],
       // Admin DCB mutation resolvers bind to the Platform API (split mode), not the deploy-target
       // Domain API — routes the provider hook to `hooks.adminApi`.
       ~onAdminApi=true,

package/src/admin/Platform_Admin.res.mjs

@@ -71,7 +71,7 @@ function Make(RuntimeEnvironment) {
       let aggregatesWithoutEventMappers = Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers(aggregates, api, opts);
       let aggregateEventTopics = Aggregate$ReventlessCore.allEventTopics(aggregatesWithoutEventMappers);
       Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
-      let dcbResult = DcbBuilder.construct(name, name, "Platform", true, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, ["ApiFragmentRegistry"], undefined, opts);
+      let dcbResult = DcbBuilder.construct(name, name, "Platform", true, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, opts);
       let slicePublishJsons = dcbResult.dcbPublishJsons;
       if (slicePublishJsons !== undefined) {
         stateChangeSlices.forEach(Sc => {

package/src/admin/Platform_ApiFragmentsApi.res

@@ -1,7 +1,7 @@
 // SDL type and JSON encoder for the Platform_ApiFragments GraphQL query — the
 // deploy-facing status surface of the API-schema fragment registry. Shared
 // between the in-memory adapter (which resolves from the in-process ApiFragments
-// StateViewSlice QueryDb) and the AWS adapter (which scans the ApiFragments
+// read-model QueryDb) and the AWS adapter (which scans the ApiFragments
 // DynamoDB table), so the wire shape is byte-identical and one client query
 // string works against either.
 //
@@ -18,7 +18,7 @@ let queryFieldName: string = "Platform_ApiFragments"
 
 let sdlQueryField: string = `  ${queryFieldName}: [Platform_ApiFragmentEntry!]!`
 
-let encodeApiFragmentEntry = (entry: ApiFragments.state): JSON.t =>
+let encodeApiFragmentEntry = (entry: ApiFragmentsReadModelSpec.state): JSON.t =>
   Dict.fromArray([
     ("pluginId", JSON.Encode.string(Plugin.name(entry.pluginId))),
     // apiTarget is a payload-less variant — its schema serializes to the bare

package/src/components/Api/GraphQL_Stitcher.res

@@ -134,7 +134,13 @@ let extractLeadingName = (str: string): string => {
   } else {
     trimmed
   }
-  // Split on "(" first to remove arg list, then on " " and "{" for the name
+  // Split on "(" first to remove arg list, then on " ", "{", and ":" for the name.
+  // The ":" split is load-bearing for ARG-LESS fields: `Foo: [Bar!]!` has no "(" to
+  // cleave the type off, and no space before the colon, so without it the name comes
+  // back as `Foo:` (trailing colon) and fails exact-match lookups like iamFieldNames
+  // — which is what dropped @aws_iam from the arg-less Platform_ApiFragments query and
+  // 401'd the deploy waiter. Fields WITH args already lost their type via split("("),
+  // so the ":" split is a harmless no-op for them.
   afterType
   ->String.split("(")
   ->Array.get(0)
@@ -148,6 +154,10 @@ let extractLeadingName = (str: string): string => {
   ->Array.get(0)
   ->Option.getOr("")
   ->String.trim
+  ->String.split(":")
+  ->Array.get(0)
+  ->Option.getOr("")
+  ->String.trim
 }
 
 // Relay base types injected into every stitched schema.

package/src/components/Api/GraphQL_Stitcher.res.mjs

@@ -121,7 +121,7 @@ function extractLeadingName(str) {
   let afterType = trimmed.startsWith("type ") || trimmed.startsWith("enum ") ? trimmed.slice(5, trimmed.length).trim() : (
       trimmed.startsWith("input ") ? trimmed.slice(6, trimmed.length).trim() : trimmed
     );
-  return Stdlib_Option.getOr(Stdlib_Option.getOr(Stdlib_Option.getOr(afterType.split("(")[0], "").trim().split(" ")[0], "").trim().split("{")[0], "").trim();
+  return Stdlib_Option.getOr(Stdlib_Option.getOr(Stdlib_Option.getOr(Stdlib_Option.getOr(afterType.split("(")[0], "").trim().split(" ")[0], "").trim().split("{")[0], "").trim().split(":")[0], "").trim();
 }
 
 let relayBaseTypes = [

package/src/components/SideEffectHandler/SideEffectHandler.res

@@ -25,6 +25,11 @@ module type T = {
     ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
     ~memorySize: int=?,
     ~timeout: int=?,
+    // Extra environment variables merged onto the side-effect-handler Lambda — used
+    // by bespoke platform side effects (e.g. the admin ApiSchemaPush) to carry
+    // deploy-derived config (API ids, command-topic URLs) that `execute` reads at
+    // runtime. Ignored by adapters that don't provision a real Lambda (in-memory).
+    ~extraEnvVars: dict<Pulumi.Input.t<string>>=?,
     ~opts: Pulumi.ComponentResource.options=?,
   ) => component
 }

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res

@@ -94,6 +94,9 @@ module Make = (
     ~resourceNaming,
     ~memorySize=2048,
     ~timeout=180,
+    // Provider-specific adapters (e.g. the AWS runtime builder) inject extra Lambda
+    // env vars via their own side-registry; the generic builder ignores them.
+    ~extraEnvVars as _=?,
     ~opts=?,
   ) => {
     Component.make(

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

@@ -14,7 +14,7 @@ import * as SideEffectHandler_Callback$ReventlessCore from "./SideEffectHandler_
 
 function Make(RuntimeEnvironment) {
   return EventCollectorChannel => (SpecificEventCollector => (EventCollectorRuntimeBuilder => {
-    let make = (name, sideEffects, allEventTopics, allCommandTopics, targets, queryEngine, scheduler, resourceNaming, memorySizeOpt, timeoutOpt, opts) => {
+    let make = (name, sideEffects, allEventTopics, allCommandTopics, targets, queryEngine, scheduler, resourceNaming, memorySizeOpt, timeoutOpt, param, opts) => {
       let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 2048;
       let timeout = timeoutOpt !== undefined ? timeoutOpt : 180;
       return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(SideEffectHandler$ReventlessCore.componentType), name, (extra, extra$1) => {

package/src/components/Task/Task_Builder.res.mjs

@@ -36,7 +36,7 @@ function Make(Spec) {
       }));
       let publishCommands = (aggregateName, cmdJsons) => Stdlib_Option.getOrThrow(publishToAggregates[aggregateName], undefined)(cmdJsons);
       let config = Spec.setup(queryEngine, queryBucketName, opts);
-      let sideEffectHandler = Stdlib_Option.map(config.sideEffects, sideEffects => SpecificSideEffectHandler.make(extra$1, sideEffects, Aggregate$ReventlessCore.allEventTopics(allAggregates), allCommandTopics, undefined, queryEngine, scheduler, resourceNaming, undefined, undefined, opts));
+      let sideEffectHandler = Stdlib_Option.map(config.sideEffects, sideEffects => SpecificSideEffectHandler.make(extra$1, sideEffects, Aggregate$ReventlessCore.allEventTopics(allAggregates), allCommandTopics, undefined, queryEngine, scheduler, resourceNaming, undefined, undefined, undefined, opts));
       let taskActionsHandler = (taskActions, operations) => Util_Promise$ReventlessCore.toUnit(Promise.all(taskActions.map(async taskAction => {
         switch (taskAction.TAG) {
           case "PublishCommands" :

package/tests/admin/Platform_ApiFragmentsApiTest.res

@@ -5,7 +5,7 @@
 
 open JestGlobals
 
-let state: ApiFragments.state = {
+let state: ApiFragmentsReadModelSpec.state = {
   pluginId: "Catalog",
   encoded: `{"types":[],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
   protocol: "graphql",