@reventlessdev/reventless-core 3.0.0-alpha.144 → 3.0.0-alpha.146

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.146 (2026-07-08)
+
+### Features
+
+* **reventless-core:** classify plugins by kind in the lifecycle read model ([64e3f22](https://github.com/ReventlessDev/reventless-core/commit/64e3f22b8114a771886b7c8ec023e95971413c0b))
+
+
+# 3.0.0-alpha.145 (2026-07-08)
+
+### Bug Fixes
+
+* **reventless-aws:** stop admin-base schema clobber of split-mode DomainApi ([afce85f](https://github.com/ReventlessDev/reventless-core/commit/afce85fa57474735cea3dcb1c2a151c2d8804f0e))
+
+
 # 3.0.0-alpha.144 (2026-07-07)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.144",
+  "version": "3.0.0-alpha.146",
   "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.25",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.90",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.68"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.69",
+    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/admin/Platform_Admin.res

@@ -80,6 +80,7 @@ module Make = (
           uiFragments: None,
           structure: None,
           dcbEventLog: None,
+          kind: Domain,
         }
 
         module Callback = Admin_Callback.Make({

package/src/admin/Platform_Admin.res.mjs

@@ -46,7 +46,8 @@ function Make(RuntimeEnvironment) {
             apiTarget: undefined,
             uiFragments: undefined,
             structure: undefined,
-            dcbEventLog: undefined
+            dcbEventLog: undefined,
+            kind: "Domain"
           };
           let Callback = Admin_Callback$ReventlessCore.Make({
             pluginDefinition: fakePluginDefinition,
@@ -187,7 +188,8 @@ function Make(RuntimeEnvironment) {
               apiTarget: undefined,
               uiFragments: undefined,
               structure: undefined,
-              dcbEventLog: undefined
+              dcbEventLog: undefined,
+              kind: "Domain"
             };
             let Callback = Admin_Callback$ReventlessCore.Make({
               pluginDefinition: fakePluginDefinition,

package/src/components/Api/GraphQL_Stitcher.res

@@ -218,21 +218,24 @@ let isIdentStart = (line: string): bool =>
   }
 
 /**
-Count the field definitions inside a root object type (`Mutation` / `Query`) of a
-full SDL string.
-
-Used by the runtime schema-update circuit breaker (AdminEventCollectorEntryPoint)
-to detect a catastrophic shrink before pushing a new schema to AppSync. Heuristic
-but adequate for a shrink guard: 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 count indented lines that begin with an
-identifier character, ignoring directive-only lines (`@…`), comments (`#…`) and
-braces.
+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 countRootTypeFields = (~sdl: string, ~typeName: string): int => {
+let rootTypeFieldNames = (~sdl: string, ~typeName: string): array<string> => {
   let marker = `type ${typeName}`
   switch sdl->String.indexOfOpt(marker) {
-  | None => 0
+  | None => []
   | Some(typeStart) =>
     let rest = sdl->String.slice(~start=typeStart)
     switch (rest->String.indexOfOpt("{"), rest->String.indexOfOpt("}")) {
@@ -240,32 +243,82 @@ let countRootTypeFields = (~sdl: string, ~typeName: string): int => {
       rest
       ->String.slice(~start=openIdx + 1, ~end=closeIdx)
       ->String.split("\n")
-      ->Array.filter(line => {
+      ->Array.filterMap(line => {
         let trimmed = line->String.trim
-        trimmed->String.length > 0 && isIdentStart(trimmed)
+        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
+        }
       })
-      ->Array.length
-    | _ => 0
+    | _ => []
     }
   }
 }
 
+/**
+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
-so many root-type (`Mutation` + `Query`) fields that it is almost certainly a
+root-operation fields the pushing stack does not carry — i.e. an almost-certainly
 transient/incomplete stitch rather than an intentional removal.
 
-Returns `true` when the new root-field total is below `threshold` × the current
-total. 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.
+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 current =
-    countRootTypeFields(~sdl=currentSdl, ~typeName="Mutation") +
-    countRootTypeFields(~sdl=currentSdl, ~typeName="Query")
-  let next =
-    countRootTypeFields(~sdl=newSdl, ~typeName="Mutation") +
-    countRootTypeFields(~sdl=newSdl, ~typeName="Query")
-  current > 0 && next->Int.toFloat < current->Int.toFloat *. threshold
+  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
+  }
 }

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

@@ -181,32 +181,68 @@ function isIdentStart(line) {
   }
 }
 
-function countRootTypeFields(sdl, typeName) {
+function rootTypeFieldNames(sdl, typeName) {
   let marker = `type ` + typeName;
   let typeStart = Stdlib_String.indexOfOpt(sdl, marker);
   if (typeStart === undefined) {
-    return 0;
+    return [];
   }
   let rest = sdl.slice(typeStart);
   let match = Stdlib_String.indexOfOpt(rest, "{");
   let match$1 = Stdlib_String.indexOfOpt(rest, "}");
-  if (match !== undefined && match$1 !== undefined && match$1 > match) {
-    return rest.slice(match + 1 | 0, match$1).split("\n").filter(line => {
-      let trimmed = line.trim();
-      if (trimmed.length > 0) {
-        return isIdentStart(trimmed);
+  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 false;
+        return [];
       }
-    }).length;
+    } else {
+      return [];
+    }
   } else {
-    return 0;
+    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 current = countRootTypeFields(currentSdl, "Mutation") + countRootTypeFields(currentSdl, "Query") | 0;
-  let next = countRootTypeFields(newSdl, "Mutation") + countRootTypeFields(newSdl, "Query") | 0;
+  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 {
@@ -223,7 +259,11 @@ export {
   relayBaseQueries,
   stitch,
   isIdentStart,
+  rootTypeFieldNames,
   countRootTypeFields,
+  rootTypeNames,
+  allRootFieldNames,
+  missingRootFields,
   isCatastrophicSchemaShrink,
 }
 /* log Not a pure module */

package/src/plugin/component/Plugin_Builder.res

@@ -687,6 +687,12 @@ module Make = (
             uiFragments,
             structure: pluginStructure,
             dcbEventLog: dcbEventLogDef,
+            // Business role from the deploy-time metadata registry (set via
+            // registerPluginMetadata). Unset → Domain. Rides the handshake to the
+            // plugin-lifecycle projection so the admin can segregate infrastructure.
+            kind: Plugin_Helpers.pluginMetadataRegistry.contents
+            ->Option.flatMap(m => m.kind)
+            ->Option.getOr(Plugin_Helpers.Domain),
           })
 
         // Bundled Plugin EventCollector reconstructs Extension_Operations at

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -462,7 +462,8 @@ function Make(Spec) {
             apiTarget: capturedDeployTarget,
             uiFragments: uiFragments,
             structure: pluginStructure,
-            dcbEventLog: param[2]
+            dcbEventLog: param[2],
+            kind: Stdlib_Option.getOr(Stdlib_Option.flatMap(Plugin_Helpers$ReventlessCore.pluginMetadataRegistry.contents, m => m.kind), "Domain")
           }));
           let aggregateQueueUrls = {};
           Object.entries(aggregateResources).forEach(param => {

package/src/plugin/component/Plugin_BuiltHook.res

@@ -12,8 +12,11 @@
 // describe a plugin's role and origin.
 // ---------------------------------------------------------------------------
 
-/** Classifies the business role of a plugin. Absent defaults to Domain. */
-type pluginKind =
+/** Classifies the business role of a plugin. Absent defaults to Domain.
+    Aliases the canonical `@schema` enum in `reventless-spec` (`Reventless.Plugin.pluginKind`)
+    so the deploy-time metadata registry and the serialized `pluginDefinition` share one
+    type — no mapping needed where metadata flows onto the definition. */
+type pluginKind = Reventless.Plugin.pluginKind =
   | Domain
   | PlatformInfrastructure
   | Commercial

package/src/plugin/lifecycle/PluginsProjection.res

@@ -58,6 +58,7 @@ let displayState = (
     uiFragments: def.uiFragments,
     structure: def.structure,
     dcbEventLog: def.dcbEventLog,
+    kind: def.kind,
     // The current version is never listed among the "other" connected versions.
     otherConnectedVersions: otherConnectedVersions->Util.without(def.version),
   }

package/src/plugin/lifecycle/PluginsProjection.res.mjs

@@ -74,6 +74,7 @@ function displayState(def, status, statusChange, otherConnectedVersions) {
   let base_uiFragments = def.uiFragments;
   let base_structure = def.structure;
   let base_dcbEventLog = def.dcbEventLog;
+  let base_kind = def.kind;
   let base_otherConnectedVersions = without(otherConnectedVersions, def.version);
   let base = {
     name: base_name,
@@ -89,6 +90,7 @@ function displayState(def, status, statusChange, otherConnectedVersions) {
     uiFragments: base_uiFragments,
     structure: base_structure,
     dcbEventLog: base_dcbEventLog,
+    kind: base_kind,
     otherConnectedVersions: base_otherConnectedVersions
   };
   let target = def.apiTarget;

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -37,6 +37,12 @@ type state = {
   // from this plugin's DCB topic → peer EventCollectors (and vice-versa). None
   // for pure-aggregate plugins or for plugins persisted before Phase 4.
   dcbEventLog: @s.matches(Reventless.Plugin.dcbEventLogOptionSchema) option<Reventless.Plugin.dcbEventLogDefinition>,
+  // Business role of the plugin (from pluginDefinition.kind). Lets the admin Plugins
+  // view segregate PlatformInfrastructure / Commercial / Marketplace from Domain.
+  // @scan opts the field into server-side equality filtering so the connection gains
+  // a `kindEq` filter — the panel split (main list vs System/Infrastructure) pages
+  // correctly server-side rather than filtering a page client-side.
+  @scan kind: Reventless.Plugin.pluginKind,
   // Other versions of this name that are currently **Connected** — excludes this
   // row's own `version` (whose status is the `status` field above). Lets the
   // projection recompute which version is current (highest Connected) during a
@@ -61,6 +67,7 @@ type queryResult = {
   uiFragments: option<Reventless.Plugin.uiFragmentManifest>,
   structure: option<Reventless.Plugin.pluginStructure>,
   dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
+  kind: Reventless.Plugin.pluginKind,
 }
 
 

package/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs

@@ -4,6 +4,7 @@ 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";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 
 let statusSchema = S.union([
   S.literal("Connected"),
@@ -27,11 +28,29 @@ let stateSchema = S.schema(s => ({
   uiFragments: s.m(Plugin$Reventless.uiFragmentManifestOptionSchema),
   structure: s.m(Plugin$Reventless.pluginStructureOptionSchema),
   dcbEventLog: s.m(Plugin$Reventless.dcbEventLogOptionSchema),
+  kind: s.m(Plugin$Reventless.pluginKindSchema),
   otherConnectedVersions: s.m(S.array(Plugin$Reventless.versionSchema))
 }));
 
 let config = ReadModel$Reventless.config(undefined, undefined, undefined);
 
+let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: [],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: ["kind"],
+  scanSort: [],
+  status: undefined,
+  visibility: undefined
+});
+
 let name = "Plugins";
 
 let Id;
@@ -48,9 +67,9 @@ export {
   name,
   Id,
   statusSchema,
-  stateSchema,
   config,
   subIdConfig,
+  stateSchema$1 as stateSchema,
   moduleUrl,
   authorization,
   visibility,

package/tests/api/GraphQL_StitcherTest.res

@@ -104,4 +104,97 @@ type Mutation {
       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)
+  })
 })

package/tests/api/GraphQL_StitcherTest.res.mjs

@@ -89,6 +89,80 @@ type Mutation {
   globalThis.test("allows an unchanged re-push (same SDL)", () => {
     globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
   });
+  globalThis.test("allows a purely additive push even below threshold cardinality", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(collapsedSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
+  });
+  globalThis.test("includes Subscription fields when judging a shrink", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(`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
+}`, `type Query {
+  node(id: ID!): Node
+}
+
+type Mutation {
+  Ordering_placeOrder(input: OrderInput): Order
+}`, 0.5)).toBe(true);
+  });
+});
+
+globalThis.describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
+  globalThis.test("lists Mutation field names", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Mutation")).toEqual([
+      "Platform_connectPlugin",
+      "Catalog_addProduct",
+      "Catalog_updateProduct",
+      "Ordering_placeOrder"
+    ]);
+  });
+  globalThis.test("strips args and @aws_auth directive lines", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(authAnnotatedSdl, "Mutation")).toEqual([
+      "Platform_connectPlugin",
+      "Catalog_addProduct"
+    ]);
+  });
+  globalThis.test("missing type returns []", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Subscription")).toEqual([]);
+  });
+});
+
+globalThis.describe("GraphQL_Stitcher.missingRootFields", () => {
+  globalThis.test("reports plugin fields absent from an admin-base clobber", () => {
+    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, collapsedSchemaSdl);
+    globalThis.expect(missing.includes("Catalog_addProduct")).toBe(true);
+    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
+    globalThis.expect(missing.includes("Ordering_orders")).toBe(true);
+  });
+  globalThis.test("empty when live schema is a superset (intact)", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, fullSchemaSdl)).toEqual([]);
+  });
+  globalThis.test("detects an equal-cardinality field swap the count test misses", () => {
+    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
+}`;
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(swapped, "Mutation")).toBe(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Mutation"));
+    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, swapped);
+    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
+  });
 });
 
 export {

package/tests/logger/LogFormatTest.res

@@ -76,6 +76,7 @@ describe("LogFormat", () => {
             uiFragments: None,
             structure: None,
             dcbEventLog: None,
+            kind: Domain,
           }),
         ]
         let meta: Message.meta = {
@@ -97,7 +98,7 @@ describe("LogFormat", () => {
           },
         )
         let expected1 = `1/2: \x1b[1mHeartbeat\x1b[0m(0): {"command":{"TAG":"Heartbeat","_0":"0.0.0"},"meta":${metaStr},"id":"0"}`
-        let expected2 = `2/2: \x1b[1mConnect\x1b[0m(1): {"command":{"TAG":"Connect","_0":{"id":"id","name":"testName","version":"testVersion","extensionPoints":[{"name":"testExtensionPoint","commandTopic":"testCommandTopic","eventTopic":"testEventTopic"}],"extensions":[{"name":"testExtension","extensionPointName":"testExtensionPoint","dcbSources":[]}],"eventCollector":"testEventCollector","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null,"dcbEventLog":null}},"meta":${metaStr},"id":"1"}`
+        let expected2 = `2/2: \x1b[1mConnect\x1b[0m(1): {"command":{"TAG":"Connect","_0":{"id":"id","name":"testName","version":"testVersion","extensionPoints":[{"name":"testExtensionPoint","commandTopic":"testCommandTopic","eventTopic":"testEventTopic"}],"extensions":[{"name":"testExtension","extensionPointName":"testExtensionPoint","dcbSources":[]}],"eventCollector":"testEventCollector","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null,"dcbEventLog":null,"kind":"Domain"}},"meta":${metaStr},"id":"1"}`
         expect(commandJsonsToLogMessages(arr))->toEqual([expected1, expected2])
       },
     )

package/tests/logger/LogFormatTest.res.mjs

@@ -76,7 +76,8 @@ globalThis.describe("LogFormat", () => {
             apiTarget: undefined,
             uiFragments: undefined,
             structure: undefined,
-            dcbEventLog: undefined
+            dcbEventLog: undefined,
+            kind: "Domain"
           }
         }
       ];
@@ -95,7 +96,7 @@ globalThis.describe("LogFormat", () => {
         commandJson: Message$ReventlessCore.encode(command, PluginSpec$ReventlessCore.commandSchema)
       }));
       let expected1 = `1/2: \x1b[1mHeartbeat\x1b[0m(0): {"command":{"TAG":"Heartbeat","_0":"0.0.0"},"meta":` + metaStr + `,"id":"0"}`;
-      let expected2 = `2/2: \x1b[1mConnect\x1b[0m(1): {"command":{"TAG":"Connect","_0":{"id":"id","name":"testName","version":"testVersion","extensionPoints":[{"name":"testExtensionPoint","commandTopic":"testCommandTopic","eventTopic":"testEventTopic"}],"extensions":[{"name":"testExtension","extensionPointName":"testExtensionPoint","dcbSources":[]}],"eventCollector":"testEventCollector","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null,"dcbEventLog":null}},"meta":` + metaStr + `,"id":"1"}`;
+      let expected2 = `2/2: \x1b[1mConnect\x1b[0m(1): {"command":{"TAG":"Connect","_0":{"id":"id","name":"testName","version":"testVersion","extensionPoints":[{"name":"testExtensionPoint","commandTopic":"testCommandTopic","eventTopic":"testEventTopic"}],"extensions":[{"name":"testExtension","extensionPointName":"testExtensionPoint","dcbSources":[]}],"eventCollector":"testEventCollector","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null,"dcbEventLog":null,"kind":"Domain"}},"meta":` + metaStr + `,"id":"1"}`;
       globalThis.expect(LogFormat$ReventlessCore.commandJsonsToLogMessages(arr)).toEqual([
         expected1,
         expected2

package/tests/message/MessageTest.res

@@ -44,6 +44,7 @@ describe("Message should", () => {
       uiFragments: None,
       structure: None,
       dcbEventLog: None,
+      kind: Domain,
     })
     let variantJson = variant->Message.encode(PluginSpec.commandSchema)
     let variantName = variantNameOfJson(variantJson)

package/tests/message/MessageTest.res.mjs

@@ -43,7 +43,8 @@ globalThis.describe("Message should", () => {
         apiTarget: undefined,
         uiFragments: undefined,
         structure: undefined,
-        dcbEventLog: undefined
+        dcbEventLog: undefined,
+        kind: "Domain"
       }
     };
     let variantJson = Message$ReventlessCore.encode(variant, PluginSpec$ReventlessCore.commandSchema);