@reventlessdev/reventless-core 3.0.0-alpha.166 → 3.0.0-alpha.168

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 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.168 (2026-07-14)
+
+### Bug Fixes
+
+* **aws:** create EC publishToAggregates SendMessage grants — cross-plugin extension→DCB publishes no longer AccessDenied ([c2126df](https://github.com/ReventlessDev/reventless-core/commit/c2126df0b9af4a79a980f2668ffc18a7760ef4c3))
+* **aws:** create heartbeat SendMessage grant at top level; document the pulumi.all side-channel gotcha ([6ffa06a](https://github.com/ReventlessDev/reventless-core/commit/6ffa06ac87070af4027ba5753ac7c2cb216a76d0))
+* show debug logs on the local platform (both launch paths) ([81837d7](https://github.com/ReventlessDev/reventless-core/commit/81837d7e02abe1065a722b43b195adef2c836794))
+### Features
+
+* **core:** thread ~comp through Projection.handleAction for attributed action logging ([fa32d93](https://github.com/ReventlessDev/reventless-core/commit/fa32d93dedabea1b1f655f01a4ea769a5908b143))
+
+
+# 3.0.0-alpha.167 (2026-07-14)
+
+**Note:** Version bump only for package @reventlessdev/reventless-core
+
+
+
+
+
 # 3.0.0-alpha.166 (2026-07-14)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.166",
+  "version": "3.0.0-alpha.168",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -31,12 +31,12 @@
     "@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-node-streams": "1.1.0-alpha.11",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.11",
     "@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-infra": "3.0.0-alpha.99",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },

package/src/Projection.res

@@ -133,10 +133,16 @@ let statesToString: array<'a> => string = states =>
   states->Array.map(stateToString)->Array.joinUnsafe(", ")
 
 let handleAction = async (
+  ~comp="Projection",
   action,
   {QueryDb.loadStream: loadStream, save, saveBatch, delete, deleteBatch} as operations,
   subIdConfig,
 ) => {
+  // Log each applied action at Debug with the full state it creates/changes,
+  // attributed to the owning component. Debug-lazy so the state is only
+  // serialized when debug logging is enabled; shadows the module-level
+  // `logAction` to carry the threaded `~comp` and the `handling action:` prefix.
+  let logAction = makeStr => log.debugLazy(~comp, () => `handling action: ${makeStr()}`)
   let loadAtMost = (n, id) =>
     loadStream(id)
     ->Stream.take(n)
@@ -210,7 +216,6 @@ let handleAction = async (
     | Error(err) => Error(err)
     }
   | UpdateWithDefault(id, default, update) =>
-    logAction(() => `UpdateWithDefault(${id}, loading ...`)
     switch await loadAtMost(2, id) {
     | Ok(states) =>
       switch states {
@@ -424,19 +429,19 @@ let optimizeActions = actions => {
   })
 }
 
-let handleActions = async (actions, operations, subIdConfig) => {
+let handleActions = async (~comp="Projection", actions, operations, subIdConfig) => {
   let handleActionsForId = async (actions, id) => {
     let actionCount = actions->Array.length
     if actionCount > 1 {
       log.debug(
-        ~comp="Projection",
+        ~comp,
         `handleActions: optimizing ${actionCount->Int.toString} actions for id=${id}`,
       )
     }
 
     let optimizedActions = optimizeActions(actions)
     let optimizedActionCount = optimizedActions->Array.length
-    log.info(~comp="Projection", `handleActions: id=${id} actions=${optimizedActionCount->Int.toString}`)
+    log.debug(~comp, `handleActions: id=${id} actions=${optimizedActionCount->Int.toString}`)
 
     // FIXME: handle errors!
     await optimizedActions->Array.reduce(Ok()->Promise.resolve, async (p, action) => {
@@ -444,11 +449,11 @@ let handleActions = async (actions, operations, subIdConfig) => {
       | Ok() => ()
       | Error(err) =>
         log.error(
-          ~comp="Projection",
+          ~comp,
           `storage error: ${err->Message.encode(ReventlessInfra.QueryDb.storageErrorSchema)->JSON.stringify}`,
         )
       }
-      await action->handleAction(operations, subIdConfig)
+      await action->handleAction(~comp, operations, subIdConfig)
     })
   }
 

package/src/Projection.res.mjs

@@ -202,10 +202,12 @@ function statesToString(states) {
   return states.map(stateToString).join(", ");
 }
 
-async function handleAction(action, operations, subIdConfig) {
+async function handleAction($staropt$star, action, operations, subIdConfig) {
   let saveBatch = operations.saveBatch;
   let save = operations.save;
   let loadStream = operations.loadStream;
+  let comp = $staropt$star !== undefined ? $staropt$star : "Projection";
+  let logAction = makeStr => log.debugLazy(comp, () => `handling action: ` + makeStr());
   let loadAtMost = (n, id) => Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(Stream$1.take(loadStream(id), n)), states => ({
     TAG: "Ok",
     _0: states
@@ -221,7 +223,7 @@ async function handleAction(action, operations, subIdConfig) {
     _0: e
   })));
   if (typeof action !== "object") {
-    log.debugLazy("Projection", () => "Ignore");
+    logAction(() => "Ignore");
     return {
       TAG: "Ok",
       _0: undefined
@@ -231,7 +233,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "Create" :
       let state = action._1;
       let id = action._0;
-      log.debugLazy("Projection", () => `Create(` + id + `, ` + stateToString(state) + `)`);
+      logAction(() => `Create(` + id + `, ` + stateToString(state) + `)`);
       return await save(id, state, "Init", undefined);
     case "CreateMany" :
       let batch = action._0.map(param => [
@@ -239,7 +241,7 @@ async function handleAction(action, operations, subIdConfig) {
         param[1],
         undefined
       ]);
-      log.debugLazy("Projection", () => `CreateMany(` + batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
+      logAction(() => `CreateMany(` + batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
       return await saveBatch(batch);
     case "Update" :
       let id$1 = action._0;
@@ -254,13 +256,13 @@ async function handleAction(action, operations, subIdConfig) {
       let len = states$1.length;
       if (len !== 1) {
         if (len !== 0) {
-          log.debugLazy("Projection", () => `Update Error: Multiple oldStates for ` + id$1 + `)`);
+          logAction(() => `Update Error: Multiple oldStates for ` + id$1 + `)`);
           return {
             TAG: "Error",
             _0: "StaleState"
           };
         } else {
-          log.debugLazy("Projection", () => `Update Error: No oldState for ` + id$1 + `)`);
+          logAction(() => `Update Error: No oldState for ` + id$1 + `)`);
           return {
             TAG: "Error",
             _0: "StaleState"
@@ -269,35 +271,34 @@ async function handleAction(action, operations, subIdConfig) {
       }
       let oldState = states$1[0];
       let newState = action._1(oldState);
-      log.debugLazy("Projection", () => `Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
+      logAction(() => `Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
       return await save(id$1, newState, "Overwrite", undefined);
     case "UpdateWithDefault" :
       let $$default = action._1;
       let id$2 = action._0;
-      log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, loading ...`);
       let states$2 = await loadAtMost(2, id$2);
       if (states$2.TAG === "Ok") {
         let states$3 = states$2._0;
         let len$1 = states$3.length;
         if (len$1 !== 1) {
           if (len$1 !== 0) {
-            log.debugLazy("Projection", () => `UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
+            logAction(() => `UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
             return {
               TAG: "Error",
               _0: "StaleState"
             };
           } else {
-            log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
+            logAction(() => `UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
             return await save(id$2, $$default, "Init", undefined);
           }
         }
         let oldState$1 = states$3[0];
         let newState$1 = action._2(oldState$1);
-        log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
+        logAction(() => `UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
         return await save(id$2, newState$1, "Overwrite", undefined);
       }
       let err = states$2._0;
-      log.debugLazy("Projection", () => `UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
+      logAction(() => `UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
       return {
         TAG: "Error",
         _0: err
@@ -305,7 +306,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "Set" :
       let state$1 = action._1;
       let id$3 = action._0;
-      log.debugLazy("Projection", () => `Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
+      logAction(() => `Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
       return await save(id$3, state$1, "Any", undefined);
     case "SetMany" :
       let set = action._1;
@@ -314,15 +315,15 @@ async function handleAction(action, operations, subIdConfig) {
         set(id),
         undefined
       ]);
-      log.debugLazy("Projection", () => `SetMany(` + batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
+      logAction(() => `SetMany(` + batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
       return await saveBatch(batch$1);
     case "Delete" :
       let id$4 = action._0;
-      log.debugLazy("Projection", () => `Delete(` + id$4 + `)`);
+      logAction(() => `Delete(` + id$4 + `)`);
       return await operations.delete(id$4, undefined);
     case "DeleteMany" :
       let ids = action._0;
-      log.debugLazy("Projection", () => `DeleteMany(` + ids.join(", ") + `)`);
+      logAction(() => `DeleteMany(` + ids.join(", ") + `)`);
       return await operations.deleteBatch(ids.map(id => [
         id,
         undefined
@@ -330,7 +331,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "CreateMultiState" :
       let states$4 = action._1;
       let id$5 = action._0;
-      log.debugLazy("Projection", () => `CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
+      logAction(() => `CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
       let len$2 = states$4.length;
       if (len$2 !== 1) {
         if (len$2 === 0) {
@@ -359,19 +360,19 @@ async function handleAction(action, operations, subIdConfig) {
         }
       } else if (subIdConfig !== undefined) {
         let err$1 = match._0;
-        log.debugLazy("Projection", () => `UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
+        logAction(() => `UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
         return {
           TAG: "Error",
           _0: err$1
         };
       }
-      log.debugLazy("Projection", () => "UpdateMultiState Error: Missing SubIdConfig !");
+      logAction(() => "UpdateMultiState Error: Missing SubIdConfig !");
       return {
         TAG: "Error",
         _0: "MissingSubIdConfig"
       };
     default:
-      log.debugLazy("Projection", () => "Error: projection action not supported");
+      logAction(() => "Error: projection action not supported");
       return {
         TAG: "Error",
         _0: {
@@ -668,24 +669,25 @@ function optimizeActions(actions) {
   });
 }
 
-async function handleActions(actions, operations, subIdConfig) {
+async function handleActions(compOpt, actions, operations, subIdConfig) {
+  let comp = compOpt !== undefined ? compOpt : "Projection";
   let handleActionsForId = async (actions, id) => {
     let actionCount = actions.length;
     if (actionCount > 1) {
-      log.debug("Projection", undefined, `handleActions: optimizing ` + actionCount.toString() + ` actions for id=` + id);
+      log.debug(comp, undefined, `handleActions: optimizing ` + actionCount.toString() + ` actions for id=` + id);
     }
     let optimizedActions = optimizeActions(actions);
     let optimizedActionCount = optimizedActions.length;
-    log.info("Projection", undefined, `handleActions: id=` + id + ` actions=` + optimizedActionCount.toString());
+    log.debug(comp, undefined, `handleActions: id=` + id + ` actions=` + optimizedActionCount.toString());
     return await Stdlib_Array.reduce(optimizedActions, Promise.resolve({
       TAG: "Ok",
       _0: undefined
     }), async (p, action) => {
       let err = await p;
       if (err.TAG !== "Ok") {
-        log.error("Projection", undefined, `storage error: ` + JSON.stringify(Message$ReventlessCore.encode(err._0, QueryDb$ReventlessInfra.storageErrorSchema)));
+        log.error(comp, undefined, `storage error: ` + JSON.stringify(Message$ReventlessCore.encode(err._0, QueryDb$ReventlessInfra.storageErrorSchema)));
       }
-      return await handleAction(action, operations, subIdConfig);
+      return await handleAction(comp, action, operations, subIdConfig);
     });
   };
   let results = await Promise.all(groupActionsById(actions).map(param => handleActionsForId(param[1], param[0])));

package/src/admin/AdminApi.res

@@ -9,46 +9,14 @@ let cloneMutationEntry: mutationSchemaEntry = {
   description: "Clone the system to a specific point in time",
 }
 
-// ApiFragmentRegistry admin mutations — the real GraphQL surface of the ApiFragmentRegistry
-// 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 = 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,
-        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.
+// (Plugin aggregate) so they end up in the admin base document. The corresponding resolver wiring
+// is fired in parallel by `Plugin_Helpers.registerAdminAggregateMutations` from
+// `Platform_Admin.construct` over the same `~aggregates` list.
+// (The ApiFragmentRegistry aggregate's entries were retired with the merged-API cutover —
+// schema composition is push-free, so no deploy-time register/deregister surface exists.)
 let mutationEntries = (~cloner: bool) => {
-  let base = Array.concat(
-    PluginBaseFragment.pluginAggregateMutationEntries,
-    apiFragmentRegistryMutationEntries,
-  )
+  let base = PluginBaseFragment.pluginAggregateMutationEntries
   if cloner {
     Array.concat(base, [cloneMutationEntry])
   } else {
@@ -58,17 +26,6 @@ let mutationEntries = (~cloner: bool) => {
 
 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
-// 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; the
 // subscription→mutation fan-in is carried as neutral `subscriptionSource`
@@ -132,35 +89,25 @@ let baseFragment = (~cloner: bool) => {
   // matching SDL fields, AppSync's CreateResolver fails with "Type not found".
   let (pluginAggregateSubscriptionFields, pluginAggregateSubscriptionSources) =
     Plugin_SubscriptionSchema.sourceCFields(~mutationEntries=PluginBaseFragment.pluginAggregateMutationEntries)
-  // The ApiFragmentRegistry aggregate's mutations go through the same CommandGenerator
-  // auto-flow, which creates an `on<field>` subscription resolver per mutation. On the
-  // static-push platform (AWS) those resolvers orphan unless the fields are declared in the
-  // pushed baseFragment — so generate them here too, symmetric with the Plugin aggregate.
-  let (apiFragmentAggregateSubscriptionFields, apiFragmentAggregateSubscriptionSources) =
-    Plugin_SubscriptionSchema.sourceCFields(~mutationEntries=apiFragmentRegistryMutationEntries)
   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_ApiFragmentsApi.sdlTypes),
+    ->Array.concat(Platform_UIFragmentsApi.sdlTypes),
     queries: Array.concat(
       parts.queries,
       [
         Platform_ComponentDefinitionsApi.sdlQueryField,
         Platform_UIFragmentsApi.sdlQueryField,
-        Platform_ApiFragmentsApi.sdlQueryField,
       ],
     ),
     mutations: parts.mutations
     ->Array.concat(uiFragmentMutationFields)
     ->Array.concat(pluginStatusMutationFields),
     subscriptions: [uiFragmentSubscriptionField, pluginStatusSubscriptionField]
-    ->Array.concat(pluginAggregateSubscriptionFields)
-    ->Array.concat(apiFragmentAggregateSubscriptionFields),
+    ->Array.concat(pluginAggregateSubscriptionFields),
     subscriptionSources: [uiFragmentSubscriptionSource, pluginStatusSubscriptionSource]
-    ->Array.concat(pluginAggregateSubscriptionSources)
-    ->Array.concat(apiFragmentAggregateSubscriptionSources),
+    ->Array.concat(pluginAggregateSubscriptionSources),
   })
 }

package/src/admin/AdminApi.res.mjs

@@ -1,14 +1,10 @@
 // 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 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";
 import * as Plugin_SubscriptionSchema$ReventlessCore from "../plugin/component/Plugin_SubscriptionSchema.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "./Platform_ComponentDefinitionsApi.res.mjs";
@@ -27,28 +23,14 @@ 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 base.concat([cloneMutationEntry]);
+    return PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries.concat([cloneMutationEntry]);
   } else {
-    return base;
+    return PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries;
   }
 }
 
-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}`
@@ -93,23 +75,21 @@ function baseFragment(cloner) {
   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);
-  let match$1 = Plugin_SubscriptionSchema$ReventlessCore.sourceCFields(apiFragmentRegistryMutationEntries);
   return GraphQL_Stitcher$ReventlessCore.encode({
-    types: parts.types.concat(uiFragmentSubscriptionTypes).concat(pluginStatusSubscriptionTypes).concat(Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes).concat(Platform_UIFragmentsApi$ReventlessCore.sdlTypes).concat(Platform_ApiFragmentsApi$ReventlessCore.sdlTypes),
+    types: parts.types.concat(uiFragmentSubscriptionTypes).concat(pluginStatusSubscriptionTypes).concat(Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes).concat(Platform_UIFragmentsApi$ReventlessCore.sdlTypes),
     mutations: parts.mutations.concat(uiFragmentMutationFields).concat(pluginStatusMutationFields),
     queries: parts.queries.concat([
       Platform_ComponentDefinitionsApi$ReventlessCore.sdlQueryField,
-      Platform_UIFragmentsApi$ReventlessCore.sdlQueryField,
-      Platform_ApiFragmentsApi$ReventlessCore.sdlQueryField
+      Platform_UIFragmentsApi$ReventlessCore.sdlQueryField
     ]),
     subscriptions: [
       uiFragmentSubscriptionField,
       pluginStatusSubscriptionField
-    ].concat(match[0]).concat(match$1[0]),
+    ].concat(match[0]),
     subscriptionSources: [
       uiFragmentSubscriptionSource,
       pluginStatusSubscriptionSource
-    ].concat(match[1]).concat(match$1[1])
+    ].concat(match[1])
   });
 }
 
@@ -118,10 +98,8 @@ let queryEntries = PluginBaseFragment$ReventlessCore.queryEntries;
 export {
   cloneArgsSchema,
   cloneMutationEntry,
-  apiFragmentRegistryMutationEntries,
   mutationEntries,
   queryEntries,
-  systemCallerFieldNames,
   uiFragmentSubscriptionTypes,
   uiFragmentMutationFields,
   uiFragmentSubscriptionField,

package/src/components/Api/GraphQL_Stitcher.res

@@ -317,115 +317,7 @@ document carries it (via `stitch`).
 let stitchStandalone = (~fragment: Reventless.Plugin.apiSchemaFragment): string =>
   assembleSdl(~fragments=[fragment], ~includeGlobalNodeQuery=false)
 
-let isIdentStart = (line: string): bool =>
-  switch line->String.codePointAt(0) {
-  // A-Z (65-90), a-z (97-122), or `_` (95)
-  | Some(c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c == 95
-  | None => false
-  }
-
-/**
-List the field NAMES defined inside a root object type (`Mutation` / `Query` /
-`Subscription`) of a full SDL string.
-
-This is the identity-aware primitive underlying every schema-clobber guard:
-`countRootTypeFields` is just its length, and the deploy-time repair / shrink
-guards compare the returned NAME SETS rather than cardinalities so they catch
-field *swaps* and equal-cardinality drift that a count comparison misses.
-
-Heuristic but adequate: root operation fields are flat single-line declarations
-(`name(args): T` or `name: T`), so we slice the `type <typeName> { … }` block at
-its first `{`/`}` and read the leading identifier of each indented line that
-begins with an identifier character, ignoring directive-only lines (`@…`),
-comments (`#…`) and braces.
-*/
-let rootTypeFieldNames = (~sdl: string, ~typeName: string): array<string> => {
-  let marker = `type ${typeName}`
-  switch sdl->String.indexOfOpt(marker) {
-  | None => []
-  | Some(typeStart) =>
-    let rest = sdl->String.slice(~start=typeStart)
-    switch (rest->String.indexOfOpt("{"), rest->String.indexOfOpt("}")) {
-    | (Some(openIdx), Some(closeIdx)) if closeIdx > openIdx =>
-      rest
-      ->String.slice(~start=openIdx + 1, ~end=closeIdx)
-      ->String.split("\n")
-      ->Array.filterMap(line => {
-        let trimmed = line->String.trim
-        if trimmed->String.length > 0 && isIdentStart(trimmed) {
-          // `name(args): T` → extractLeadingName strips the arg list; `name: T`
-          // (no args) leaves a trailing colon on the token — drop it so a field
-          // reads the same whether or not it takes arguments.
-          let name = extractLeadingName(trimmed)
-          let name = name->String.endsWith(":")
-            ? name->String.slice(~start=0, ~end=name->String.length - 1)
-            : name
-          name->String.length > 0 ? Some(name) : None
-        } else {
-          None
-        }
-      })
-    | _ => []
-    }
-  }
-}
-
-/**
-Count the field definitions inside a root object type (`Mutation` / `Query`) of a
-full SDL string. Length of `rootTypeFieldNames`.
-*/
-let countRootTypeFields = (~sdl: string, ~typeName: string): int =>
-  rootTypeFieldNames(~sdl, ~typeName)->Array.length
-
-// The three GraphQL root operation types every clobber guard reasons over.
-let rootTypeNames = ["Mutation", "Query", "Subscription"]
-
-/**
-Union of every root-operation field name across `Mutation` + `Query` +
-`Subscription`. The identity set the deploy-time repair and shrink guards diff.
-*/
-let allRootFieldNames = (~sdl: string): array<string> =>
-  rootTypeNames->Array.flatMap(typeName => rootTypeFieldNames(~sdl, ~typeName))
-
-/**
-Root-operation field names present in `expectedSdl` but MISSING from `liveSdl`
-(across Mutation + Query + Subscription). Non-empty ⇒ the live schema is not a
-superset of what we expect and a repair push is warranted — this heals field
-*swaps* and equal-cardinality drift that a bare count comparison would skip.
-*/
-let missingRootFields = (~expectedSdl: string, ~liveSdl: string): array<string> => {
-  let liveSet = allRootFieldNames(~sdl=liveSdl)->Set.fromArray
-  allRootFieldNames(~sdl=expectedSdl)->Array.filter(name => !(liveSet->Set.has(name)))
-}
-
-/**
-Decide whether replacing the live schema (`currentSdl`) with `newSdl` would drop
-root-operation fields the pushing stack does not carry — i.e. an almost-certainly
-transient/incomplete stitch rather than an intentional removal.
-
-Identity-based (across `Mutation` + `Query` + `Subscription`):
-- When `newSdl`'s field-name set is a SUPERSET of the live set — nothing is
-  dropped — it is purely additive (or unchanged) and never a clobber, so this
-  returns `false` even when the pushing stack is legitimately adding its own
-  fields.
-- Otherwise it falls back to the cardinality threshold on the union of the three
-  root types: `true` only when the new total drops below `threshold` × the
-  current total. A small intentional removal (above threshold) is allowed.
-
-When the current schema has no countable root fields (e.g. first deploy, or
-introspection was unavailable so `currentSdl` is empty) it returns `false` so the
-initial push always proceeds.
-*/
-let isCatastrophicSchemaShrink = (~currentSdl: string, ~newSdl: string, ~threshold: float): bool => {
-  let currentNames = allRootFieldNames(~sdl=currentSdl)
-  let newSet = allRootFieldNames(~sdl=newSdl)->Set.fromArray
-  let dropped = currentNames->Array.filter(name => !(newSet->Set.has(name)))
-  if dropped->Array.length == 0 {
-    // Additive or unchanged push — the new schema keeps every live field.
-    false
-  } else {
-    let current = currentNames->Array.length
-    let next = allRootFieldNames(~sdl=newSdl)->Array.length
-    current > 0 && next->Int.toFloat < current->Int.toFloat *. threshold
-  }
-}
+// (The schema-clobber guard family — rootTypeFieldNames / countRootTypeFields /
+// missingRootFields / isCatastrophicSchemaShrink — was retired with the push
+// machinery: under merged-API composition every source API is a single writer,
+// so no whole-replace push exists to guard.)