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

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.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.167",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,16 +28,16 @@
   "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-effect": "0.1.0-alpha.27",
     "@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-pulumi-pulumi": "2.3.0-alpha.15",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.12",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.15",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.99",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {

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.)

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

@@ -3,7 +3,6 @@
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -226,88 +225,6 @@ function stitchStandalone(fragment) {
   return assembleSdl([fragment], false);
 }
 
-function isIdentStart(line) {
-  let c = line.codePointAt(0);
-  if (c !== undefined) {
-    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
-      return true;
-    } else {
-      return c === 95;
-    }
-  } else {
-    return false;
-  }
-}
-
-function rootTypeFieldNames(sdl, typeName) {
-  let marker = `type ` + typeName;
-  let typeStart = Stdlib_String.indexOfOpt(sdl, marker);
-  if (typeStart === undefined) {
-    return [];
-  }
-  let rest = sdl.slice(typeStart);
-  let match = Stdlib_String.indexOfOpt(rest, "{");
-  let match$1 = Stdlib_String.indexOfOpt(rest, "}");
-  if (match !== undefined) {
-    if (match$1 !== undefined) {
-      if (match$1 > match) {
-        return Stdlib_Array.filterMap(rest.slice(match + 1 | 0, match$1).split("\n"), line => {
-          let trimmed = line.trim();
-          if (!(trimmed.length > 0 && isIdentStart(trimmed))) {
-            return;
-          }
-          let name = extractLeadingName(trimmed);
-          let name$1 = name.endsWith(":") ? name.slice(0, name.length - 1 | 0) : name;
-          if (name$1.length > 0) {
-            return name$1;
-          }
-        });
-      } else {
-        return [];
-      }
-    } else {
-      return [];
-    }
-  } else {
-    return [];
-  }
-}
-
-function countRootTypeFields(sdl, typeName) {
-  return rootTypeFieldNames(sdl, typeName).length;
-}
-
-let rootTypeNames = [
-  "Mutation",
-  "Query",
-  "Subscription"
-];
-
-function allRootFieldNames(sdl) {
-  return rootTypeNames.flatMap(typeName => rootTypeFieldNames(sdl, typeName));
-}
-
-function missingRootFields(expectedSdl, liveSdl) {
-  let liveSet = new Set(allRootFieldNames(liveSdl));
-  return allRootFieldNames(expectedSdl).filter(name => !liveSet.has(name));
-}
-
-function isCatastrophicSchemaShrink(currentSdl, newSdl, threshold) {
-  let currentNames = allRootFieldNames(currentSdl);
-  let newSet = new Set(allRootFieldNames(newSdl));
-  let dropped = currentNames.filter(name => !newSet.has(name));
-  if (dropped.length === 0) {
-    return false;
-  }
-  let current = currentNames.length;
-  let next = allRootFieldNames(newSdl).length;
-  if (current > 0) {
-    return next < current * threshold;
-  } else {
-    return false;
-  }
-}
-
 export {
   log,
   encodeSubscriptionSource,
@@ -320,12 +237,5 @@ export {
   assembleSdl,
   stitch,
   stitchStandalone,
-  isIdentStart,
-  rootTypeFieldNames,
-  countRootTypeFields,
-  rootTypeNames,
-  allRootFieldNames,
-  missingRootFields,
-  isCatastrophicSchemaShrink,
 }
 /* log Not a pure module */

package/tests/api/GraphQL_StitcherTest.res

@@ -1,204 +1,6 @@
 open JestGlobals
 open GraphQL_Stitcher
 
-// A representative stitched schema: admin base (Platform_*) plus two domain
-// plugins (Catalog_*, Ordering_*). 4 Mutation + 4 Query root fields.
-let fullSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`
-
-// The exact failure observed in alpha: a lifecycle window collapses the live
-// schema back to admin-base only — every Catalog_*/Ordering_* field gone.
-// 1 Mutation + 2 Query root fields.
-let collapsedSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-}`
-
-// Real stitched shape: injectAwsAuthAll appends @aws_auth on its own indented
-// line after each Mutation field, so a field spans two physical lines.
-let authAnnotatedSdl = `type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-    @aws_auth(cognito_groups: ["Admin"])
-  Catalog_addProduct(input: AddInput): Product
-    @aws_auth(cognito_groups: ["User"])
-}
-
-type Query {
-  node(id: ID!): Node @aws_auth(cognito_groups: ["Admin"])
-}`
-
-describe("GraphQL_Stitcher.countRootTypeFields", () => {
-  testSync("counts Mutation fields", () => {
-    expect(countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Mutation"))->toBe(4)
-  })
-  testSync("counts Query fields", () => {
-    expect(countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Query"))->toBe(4)
-  })
-  testSync("ignores @aws_auth directive lines, counts each Mutation field once", () => {
-    expect(countRootTypeFields(~sdl=authAnnotatedSdl, ~typeName="Mutation"))->toBe(2)
-  })
-  testSync("ignores @aws_auth directive lines, counts each Query field once", () => {
-    expect(countRootTypeFields(~sdl=authAnnotatedSdl, ~typeName="Query"))->toBe(1)
-  })
-  testSync("missing type returns 0", () => {
-    expect(countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Subscription"))->toBe(0)
-  })
-  testSync("empty SDL returns 0", () => {
-    expect(countRootTypeFields(~sdl="", ~typeName="Mutation"))->toBe(0)
-  })
-})
-
-describe("GraphQL_Stitcher.isCatastrophicSchemaShrink", () => {
-  testSync("rejects the all-disconnected collapse (8 → 3 root fields, < 50%)", () => {
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=collapsedSchemaSdl, ~threshold=0.5),
-    )->toBe(true)
-  })
-  testSync("allows an intentional small removal above threshold (8 → 7)", () => {
-    let minusOneSdl = `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=minusOneSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("allows the first push when there is no live schema to protect", () => {
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl="", ~newSdl=fullSchemaSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("allows an unchanged re-push (same SDL)", () => {
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=fullSchemaSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("allows a purely additive push even below threshold cardinality", () => {
-    // A tiny live schema growing into a big one drops nothing → never a clobber,
-    // regardless of the ratio.
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=collapsedSchemaSdl, ~newSdl=fullSchemaSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("includes Subscription fields when judging a shrink", () => {
-    let withSubs = `type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}
-
-type Subscription {
-  onOrdering_Customer_Register: Customer
-  onOrdering_Customer_UpdateAddress: Customer
-  onCatalog_Product_Added: Product
-}`
-    // Dropping every Subscription field (and keeping Mutation/Query) is a shrink
-    // the Mutation+Query-only guard would have missed.
-    let subsGone = `type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}`
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=withSubs, ~newSdl=subsGone, ~threshold=0.5),
-    )->toBe(true)
-  })
-})
-
-describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
-  testSync("lists Mutation field names", () => {
-    expect(rootTypeFieldNames(~sdl=fullSchemaSdl, ~typeName="Mutation"))->toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct",
-      "Catalog_updateProduct",
-      "Ordering_placeOrder",
-    ])
-  })
-  testSync("strips args and @aws_auth directive lines", () => {
-    expect(rootTypeFieldNames(~sdl=authAnnotatedSdl, ~typeName="Mutation"))->toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct",
-    ])
-  })
-  testSync("missing type returns []", () => {
-    expect(rootTypeFieldNames(~sdl=fullSchemaSdl, ~typeName="Subscription"))->toEqual([])
-  })
-})
-
-describe("GraphQL_Stitcher.missingRootFields", () => {
-  testSync("reports plugin fields absent from an admin-base clobber", () => {
-    // The alpha 2026-07-08 clobber: live schema is admin-base only. Every
-    // Catalog_*/Ordering_* field the deploy expects is missing → repair fires.
-    let missing = missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=collapsedSchemaSdl)
-    expect(missing->Array.includes("Catalog_addProduct"))->toBe(true)
-    expect(missing->Array.includes("Ordering_placeOrder"))->toBe(true)
-    expect(missing->Array.includes("Ordering_orders"))->toBe(true)
-  })
-  testSync("empty when live schema is a superset (intact)", () => {
-    expect(missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=fullSchemaSdl))->toEqual([])
-  })
-  testSync("detects an equal-cardinality field swap the count test misses", () => {
-    // Same number of root fields, but one Mutation field replaced by a foreign
-    // one — a swap. countRootTypeFields would report no drift; the name-set diff
-    // catches it.
-    let swapped = `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Foreign_strayField(input: OrderInput): Order
-}`
-    // Same count on both sides.
-    expect(countRootTypeFields(~sdl=swapped, ~typeName="Mutation"))->toBe(
-      countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Mutation"),
-    )
-    // But the expected Ordering_placeOrder is missing from the live (swapped) schema.
-    let missing = missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=swapped)
-    expect(missing->Array.includes("Ordering_placeOrder"))->toBe(true)
-  })
-})
-
 describe("GraphQL_Stitcher.subscriptionSources", () => {
   testSync("encode/decode round-trips the subscription→mutation source mapping", () => {
     let fragment = encode({