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

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

@@ -30,33 +30,6 @@ let initialState = {
   known: initialState_known
 };
 
-function uiRegisterEvents(pluginId, manifest) {
-  if (manifest !== undefined) {
-    return [{
-        TAG: "UIFragmentRegistered",
-        _0: {
-          pluginId: pluginId,
-          manifest: manifest
-        }
-      }];
-  } else {
-    return [];
-  }
-}
-
-function uiDeregisterEvents(pluginId, manifest) {
-  if (manifest !== undefined) {
-    return [{
-        TAG: "UIFragmentDeregistered",
-        _0: {
-          pluginId: pluginId
-        }
-      }];
-  } else {
-    return [];
-  }
-}
-
 function highestConnected(known) {
   return Stdlib_Array.reduce(Object.entries(known), undefined, (acc, param) => {
     let v = param[0];
@@ -97,7 +70,7 @@ function connectEvents(state, v, def) {
   let base = [{
       TAG: "VersionConnected",
       _0: def
-    }].concat(uiRegisterEvents(def.id, def.uiFragments));
+    }];
   let supersede;
   if (currentAfterConnect(state.known, v) === v) {
     let c = state.current;
@@ -229,26 +202,27 @@ function decide(state, command) {
     case "Disconnect" :
       let v$3 = command._0;
       let match$3 = state.known[v$3];
-      if (match$3 === undefined) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-      if (match$3.status !== "Connected") {
+      if (match$3 !== undefined) {
+        if (match$3.status === "Connected") {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "VersionDisconnected",
+                _0: match$3.definition
+              }].concat(promoteEvents(state, v$3))
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        }
+      } else {
         return {
           TAG: "Ok",
           _0: []
         };
       }
-      let definition = match$3.definition;
-      return {
-        TAG: "Ok",
-        _0: [{
-            TAG: "VersionDisconnected",
-            _0: definition
-          }].concat(uiDeregisterEvents(definition.id, definition.uiFragments)).concat(promoteEvents(state, v$3))
-      };
     case "Activate" :
       let v$4 = command._0;
       let match$4 = state.known[v$4];
@@ -258,7 +232,7 @@ function decide(state, command) {
           _0: "UnknownVersion"
         };
       }
-      let definition$1 = match$4.definition;
+      let definition = match$4.definition;
       switch (match$4.status) {
         case "Connected" :
           return {
@@ -276,8 +250,8 @@ function decide(state, command) {
       }
       let base = [{
           TAG: "VersionActivated",
-          _0: definition$1
-        }].concat(uiRegisterEvents(definition$1.id, definition$1.uiFragments));
+          _0: definition
+        }];
       let supersede;
       if (currentAfterConnect(state.known, v$4) === v$4) {
         let c = state.current;
@@ -290,7 +264,7 @@ function decide(state, command) {
                     supersededVersion: c,
                     supersededDefinition: match$5.definition,
                     newVersion: v$4,
-                    newDefinition: definition$1
+                    newDefinition: definition
                   }
                 }] : [];
           } else {
@@ -316,7 +290,6 @@ function decide(state, command) {
           _0: "UnknownVersion"
         };
       }
-      let definition$2 = match$6.definition;
       switch (match$6.status) {
         case "Connected" :
         case "Disconnected" :
@@ -332,8 +305,8 @@ function decide(state, command) {
         TAG: "Ok",
         _0: [{
             TAG: "VersionDeactivated",
-            _0: definition$2
-          }].concat(uiDeregisterEvents(definition$2.id, definition$2.uiFragments)).concat(promoteEvents(state, v$5))
+            _0: match$6.definition
+          }].concat(promoteEvents(state, v$5))
       };
       break;
     case "ReportIncompatibility" :
@@ -347,27 +320,27 @@ function decide(state, command) {
     case "Retire" :
       let v$6 = command._0;
       let match$7 = state.known[v$6];
-      if (match$7 === undefined) {
+      if (match$7 !== undefined) {
+        if (match$7.status === "Retired") {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "VersionRetired",
+                _0: match$7.definition
+              }].concat(promoteEvents(state, v$6))
+          };
+        }
+      } else {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$3 = match$7.definition;
-      if (match$7.status === "Retired") {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      } else {
-        return {
-          TAG: "Ok",
-          _0: [{
-              TAG: "VersionRetired",
-              _0: definition$3
-            }].concat(uiDeregisterEvents(definition$3.id, definition$3.uiFragments)).concat(promoteEvents(state, v$6))
-        };
-      }
   }
 }
 
@@ -419,8 +392,6 @@ export {
   initialState,
   snapshot,
   atomicCounter,
-  uiRegisterEvents,
-  uiDeregisterEvents,
   highestConnected,
   highestConnectedExcluding,
   currentAfterConnect,

package/src/plugin/lifecycle/PluginSpec.res

@@ -26,19 +26,6 @@ type command =
   // automatic `Superseded` transition (which is decided, not commanded).
   | Retire(version)
 
-@schema
-type uiFragmentRegisteredData = {pluginId: string, manifest: uiFragmentManifest}
-
-@schema
-type uiFragmentUpdatedData = {
-  pluginId: string,
-  previousManifest: uiFragmentManifest,
-  newManifest: uiFragmentManifest,
-}
-
-@schema
-type uiFragmentDeregisteredData = {pluginId: string}
-
 // Carries both the superseded and the superseding version's full definition —
 // a deterministic trigger for version-to-version schema/data migrations
 // (analysis §6.2.4).
@@ -72,11 +59,6 @@ type event =
   | VersionRetired(pluginDefinition)
   // Protocol incompatibility recorded at connect; connection still proceeds.
   | IncompatiblePluginDetected(pluginDefinition)
-  // UI fragment lifecycle events — emitted alongside connect/disconnect/(de)activate
-  // when the plugin's pluginDefinition.uiFragments is set.
-  | UIFragmentRegistered(uiFragmentRegisteredData)
-  | UIFragmentUpdated(uiFragmentUpdatedData)
-  | UIFragmentDeregistered(uiFragmentDeregisteredData)
 
 @schema
 type error =

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

@@ -39,21 +39,6 @@ let commandSchema = S.union([
   }))
 ]);
 
-let uiFragmentRegisteredDataSchema = S.schema(s => ({
-  pluginId: s.m(S.string),
-  manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema)
-}));
-
-let uiFragmentUpdatedDataSchema = S.schema(s => ({
-  pluginId: s.m(S.string),
-  previousManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
-  newManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema)
-}));
-
-let uiFragmentDeregisteredDataSchema = S.schema(s => ({
-  pluginId: s.m(S.string)
-}));
-
 let versionSupersededDataSchema = S.schema(s => ({
   supersededVersion: s.m(Plugin$Reventless.versionSchema),
   supersededDefinition: s.m(Plugin$Reventless.pluginDefinitionSchema),
@@ -97,18 +82,6 @@ let eventSchema = S.union([
   S.schema(s => ({
     TAG: "IncompatiblePluginDetected",
     _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
-  })),
-  S.schema(s => ({
-    TAG: "UIFragmentRegistered",
-    _0: s.m(uiFragmentRegisteredDataSchema)
-  })),
-  S.schema(s => ({
-    TAG: "UIFragmentUpdated",
-    _0: s.m(uiFragmentUpdatedDataSchema)
-  })),
-  S.schema(s => ({
-    TAG: "UIFragmentDeregistered",
-    _0: s.m(uiFragmentDeregisteredDataSchema)
   }))
 ]);
 
@@ -140,9 +113,6 @@ let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.
 export {
   name,
   Id,
-  uiFragmentRegisteredDataSchema,
-  uiFragmentUpdatedDataSchema,
-  uiFragmentDeregisteredDataSchema,
   versionSupersededDataSchema,
   eventSchema,
   errorSchema,

package/src/plugin/lifecycle/PluginsProjection.res

@@ -55,7 +55,6 @@ let displayState = (
     status,
     statusChange,
     apiSchemaFragment: def.apiSchemaFragment,
-    uiFragments: def.uiFragments,
     structure: def.structure,
     dcbEventLog: def.dcbEventLog,
     // A freshly projected row always knows its kind (the definition carries it as a
@@ -78,14 +77,11 @@ module PluginMapping = Reventless.Projection.Mapping.Make(
     let project = ({event, id, meta: {time, user: ?user}}) => {
       let statusChange = {at: time, by: user->Option.getOr("")}
       switch event {
-      // Handshake trigger, supersession record, incompatibility and UI-fragment
+      // Handshake trigger, supersession record and incompatibility
       // events do not change which version is current.
       | PluginSpec.VersionDetected(_)
       | VersionSuperseded(_)
-      | IncompatiblePluginDetected(_)
-      | UIFragmentRegistered(_)
-      | UIFragmentUpdated(_)
-      | UIFragmentDeregistered(_) =>
+      | IncompatiblePluginDetected(_) =>
         Reventless.Projection.Ignore
 
       // A version became live. It becomes current iff it is the highest

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

@@ -71,7 +71,6 @@ function displayState(def, status, statusChange, otherConnectedVersions) {
   let base_extensionNames = def.extensions.map(extension => extension.extensionPointName);
   let base_extensions = def.extensions;
   let base_apiSchemaFragment = def.apiSchemaFragment;
-  let base_uiFragments = def.uiFragments;
   let base_structure = def.structure;
   let base_dcbEventLog = def.dcbEventLog;
   let base_kind = def.kind;
@@ -87,7 +86,6 @@ function displayState(def, status, statusChange, otherConnectedVersions) {
     status: status,
     statusChange: statusChange,
     apiSchemaFragment: base_apiSchemaFragment,
-    uiFragments: base_uiFragments,
     structure: base_structure,
     dcbEventLog: base_dcbEventLog,
     kind: base_kind,

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -28,7 +28,6 @@ type state = {
   // API target for split-API schema routing. Absent/None means "Domain" (backward compat).
   // "Platform" → excluded from DomainApi runtime schema stitching in updateApiSchema.
   apiTarget?: string,
-  uiFragments: @s.matches(Reventless.Plugin.uiFragmentManifestOptionSchema) option<Reventless.Plugin.uiFragmentManifest>,
   // Plugin structure (component metadata) — surfaced via Platform_ComponentDefinitions.
   // None for older plugins whose protocol version did not carry the field.
   structure: @s.matches(Reventless.Plugin.pluginStructureOptionSchema) option<Reventless.Plugin.pluginStructure>,
@@ -75,7 +74,6 @@ type queryResult = {
   status: status,
   apiSchemaFragment: option<Reventless.Plugin.apiSchemaFragment>,
   apiTarget?: string,
-  uiFragments: option<Reventless.Plugin.uiFragmentManifest>,
   structure: option<Reventless.Plugin.pluginStructure>,
   dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
   kind: option<Reventless.Plugin.pluginKind>,

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

@@ -25,7 +25,6 @@ let stateSchema = S.schema(s => ({
   statusChange: s.m(Message$ReventlessCore.statusChangeSchema),
   apiSchemaFragment: s.m(Plugin$Reventless.apiSchemaFragmentOptionSchema),
   apiTarget: s.m(S.option(S.string)),
-  uiFragments: s.m(Plugin$Reventless.uiFragmentManifestOptionSchema),
   structure: s.m(Plugin$Reventless.pluginStructureOptionSchema),
   dcbEventLog: s.m(Plugin$Reventless.dcbEventLogOptionSchema),
   kind: s.m(S.option(Plugin$Reventless.pluginKindSchema)),

package/tests/admin/Platform_ApiFragmentsApiTest.res

@@ -0,0 +1,66 @@
+// Asserts the canonical JSON shape produced by encodeApiFragmentEntry — the
+// deploy-facing status surface of the API-schema fragment registry, shared by
+// the in-memory and AWS adapters. Status only (no encoded SDL). If this test
+// changes, any deploy waiter parsing Platform_ApiFragments is affected.
+
+open JestGlobals
+
+let state: ApiFragments.state = {
+  pluginId: "Catalog",
+  encoded: `{"types":[],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql",
+  apiTarget: Reventless.Plugin.Domain,
+  registeredAt: "2026-05-14T00:00:00.000Z",
+  updatedAt: "2026-05-14T00:00:00.000Z",
+  pushStatus: "ok",
+  pushMessage: "",
+  pushedAt: "2026-05-14T00:00:01.000Z",
+}
+
+let encoded = Platform_ApiFragmentsApi.encodeApiFragmentEntry(state)
+let json = encoded->JSON.stringify
+
+describe("encodeApiFragmentEntry", () => {
+  testSync("produces a JSON object with the expected top-level keys (status only, no SDL)", () => {
+    let dict = encoded->JSON.Decode.object->Option.getOr(Dict.make())
+    let keys = dict->Dict.keysToArray->Array.toSorted(String.compare)
+    expect(keys)->toEqual([
+      "apiTarget",
+      "pluginId",
+      "pushMessage",
+      "pushStatus",
+      "pushedAt",
+      "registeredAt",
+      "updatedAt",
+    ])
+  })
+
+  testSync("encodes pluginId", () =>
+    expect(json->String.includes("\"pluginId\":\"Catalog\""))->toEqual(true)
+  )
+
+  testSync("encodes the apiTarget variant as its bare string", () =>
+    expect(json->String.includes("\"apiTarget\":\"Domain\""))->toEqual(true)
+  )
+
+  testSync("encodes pushStatus", () =>
+    expect(json->String.includes("\"pushStatus\":\"ok\""))->toEqual(true)
+  )
+
+  testSync("does not leak the encoded SDL into the status shape", () =>
+    expect(json->String.includes("subscriptionSources"))->toEqual(false)
+  )
+})
+
+describe("Platform_ApiFragmentsApi.sdl", () => {
+  testSync("query field declares the list type", () =>
+    expect(Platform_ApiFragmentsApi.sdlQueryField->String.includes("[Platform_ApiFragmentEntry!]!"))
+    ->toEqual(true)
+  )
+
+  testSync("sdlTypes includes Platform_ApiFragmentEntry with pushStatus field", () => {
+    let allTypes = Platform_ApiFragmentsApi.sdlTypes->Array.join("\n")
+    expect(allTypes->String.includes("Platform_ApiFragmentEntry"))->toEqual(true)
+    expect(allTypes->String.includes("pushStatus: String!"))->toEqual(true)
+  })
+})

package/tests/admin/Platform_ApiFragmentsApiTest.res.mjs

@@ -0,0 +1,68 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Platform_ApiFragmentsApi$ReventlessCore from "../../src/admin/Platform_ApiFragmentsApi.res.mjs";
+
+let state = {
+  pluginId: "Catalog",
+  encoded: `{"types":[],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql",
+  apiTarget: "Domain",
+  registeredAt: "2026-05-14T00:00:00.000Z",
+  updatedAt: "2026-05-14T00:00:00.000Z",
+  pushStatus: "ok",
+  pushMessage: "",
+  pushedAt: "2026-05-14T00:00:01.000Z"
+};
+
+let encoded = Platform_ApiFragmentsApi$ReventlessCore.encodeApiFragmentEntry(state);
+
+let json = JSON.stringify(encoded);
+
+globalThis.describe("encodeApiFragmentEntry", () => {
+  globalThis.test("produces a JSON object with the expected top-level keys (status only, no SDL)", () => {
+    let dict = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(encoded), {});
+    let keys = Object.keys(dict).toSorted(Primitive_string.compare);
+    globalThis.expect(keys).toEqual([
+      "apiTarget",
+      "pluginId",
+      "pushMessage",
+      "pushStatus",
+      "pushedAt",
+      "registeredAt",
+      "updatedAt"
+    ]);
+  });
+  globalThis.test("encodes pluginId", () => {
+    globalThis.expect(json.includes("\"pluginId\":\"Catalog\"")).toEqual(true);
+  });
+  globalThis.test("encodes the apiTarget variant as its bare string", () => {
+    globalThis.expect(json.includes("\"apiTarget\":\"Domain\"")).toEqual(true);
+  });
+  globalThis.test("encodes pushStatus", () => {
+    globalThis.expect(json.includes("\"pushStatus\":\"ok\"")).toEqual(true);
+  });
+  globalThis.test("does not leak the encoded SDL into the status shape", () => {
+    globalThis.expect(json.includes("subscriptionSources")).toEqual(false);
+  });
+});
+
+globalThis.describe("Platform_ApiFragmentsApi.sdl", () => {
+  globalThis.test("query field declares the list type", () => {
+    globalThis.expect(Platform_ApiFragmentsApi$ReventlessCore.sdlQueryField.includes("[Platform_ApiFragmentEntry!]!")).toEqual(true);
+  });
+  globalThis.test("sdlTypes includes Platform_ApiFragmentEntry with pushStatus field", () => {
+    let allTypes = Platform_ApiFragmentsApi$ReventlessCore.sdlTypes.join("\n");
+    globalThis.expect(allTypes.includes("Platform_ApiFragmentEntry")).toEqual(true);
+    globalThis.expect(allTypes.includes("pushStatus: String!")).toEqual(true);
+  });
+});
+
+export {
+  state,
+  encoded,
+  json,
+}
+/* encoded Not a pure module */

package/tests/admin/Platform_UIFragmentsApiTest.res

@@ -25,7 +25,7 @@ let page: pageManifestEntry = {
   requiredAccess: Some("admin"),
 }
 
-let state: UIFragmentRegistryReadModelSpec.state = {
+let state: UiFragments.state = {
   pluginId: "Catalog",
   remoteEntryUrl: "https://cdn.example.com/catalog@1.0/remoteEntry.js",
   panels: [panel],

package/tests/api/GraphQL_PushPlannerTest.res

@@ -0,0 +1,62 @@
+open JestGlobals
+open GraphQL_PushPlanner
+
+// Minimal neutral fragments. `stitch` always adds Relay base types + `node`, so we assert on the
+// distinctive field names to know which base/fragments landed in each plan.
+let mkFragment = (~query: string): Reventless.Plugin.apiSchemaFragment =>
+  GraphQL_Stitcher.encode({
+    types: [],
+    queries: [query],
+    mutations: [],
+    subscriptions: [],
+    subscriptionSources: [],
+  })
+
+let adminBase = mkFragment(~query="  Admin_Q: String")
+let domainFrag = mkFragment(~query="  Domain_Q: String")
+let platformFrag = mkFragment(~query="  Platform_Q: String")
+
+let fragments = [
+  {fragment: domainFrag, target: Domain},
+  {fragment: platformFrag, target: Platform},
+]
+
+let planFor = (plans: array<pushPlan>, api: planTarget): option<pushPlan> =>
+  plans->Array.find(p => p.api == api)
+
+describe("GraphQL_PushPlanner.planPushes", () => {
+  testSync("split mode: admin base + Platform fragments on the Platform API only", () => {
+    let plans = planPushes(~adminBase, ~fragments, ~splitApi=true)
+    expect(plans->Array.length)->toBe(2)
+    let platform = planFor(plans, PlatformApi)->Belt.Option.getExn
+    expect(platform.sdl->String.includes("Admin_Q"))->toBe(true)
+    expect(platform.sdl->String.includes("Platform_Q"))->toBe(true)
+    expect(platform.sdl->String.includes("Domain_Q"))->toBe(false)
+  })
+
+  testSync("split mode: empty base + Domain fragments on the Domain API only (no admin)", () => {
+    let plans = planPushes(~adminBase, ~fragments, ~splitApi=true)
+    let domain = planFor(plans, DomainApi)->Belt.Option.getExn
+    expect(domain.sdl->String.includes("Domain_Q"))->toBe(true)
+    expect(domain.sdl->String.includes("Admin_Q"))->toBe(false)
+    expect(domain.sdl->String.includes("Platform_Q"))->toBe(false)
+  })
+
+  testSync("unified mode: one Domain API push with admin base + ALL fragments", () => {
+    let plans = planPushes(~adminBase, ~fragments, ~splitApi=false)
+    expect(plans->Array.length)->toBe(1)
+    let only = plans->Array.getUnsafe(0)
+    expect(only.api == DomainApi)->toBe(true)
+    expect(only.sdl->String.includes("Admin_Q"))->toBe(true)
+    expect(only.sdl->String.includes("Domain_Q"))->toBe(true)
+    expect(only.sdl->String.includes("Platform_Q"))->toBe(true)
+  })
+
+  testSync("empty registry still pushes the admin base (split → Platform API)", () => {
+    let plans = planPushes(~adminBase, ~fragments=[], ~splitApi=true)
+    let platform = planFor(plans, PlatformApi)->Belt.Option.getExn
+    expect(platform.sdl->String.includes("Admin_Q"))->toBe(true)
+    let domain = planFor(plans, DomainApi)->Belt.Option.getExn
+    expect(domain.sdl->String.includes("Admin_Q"))->toBe(false)
+  })
+})

package/tests/api/GraphQL_PushPlannerTest.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
+import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as GraphQL_PushPlanner$ReventlessCore from "../../src/components/Api/GraphQL_PushPlanner.res.mjs";
+
+function mkFragment(query) {
+  return GraphQL_Stitcher$ReventlessCore.encode({
+    types: [],
+    mutations: [],
+    queries: [query],
+    subscriptions: [],
+    subscriptionSources: []
+  });
+}
+
+let adminBase = mkFragment("  Admin_Q: String");
+
+let domainFrag = mkFragment("  Domain_Q: String");
+
+let platformFrag = mkFragment("  Platform_Q: String");
+
+let fragments = [
+  {
+    fragment: domainFrag,
+    target: "Domain"
+  },
+  {
+    fragment: platformFrag,
+    target: "Platform"
+  }
+];
+
+function planFor(plans, api) {
+  return plans.find(p => p.api === api);
+}
+
+globalThis.describe("GraphQL_PushPlanner.planPushes", () => {
+  globalThis.test("split mode: admin base + Platform fragments on the Platform API only", () => {
+    let plans = GraphQL_PushPlanner$ReventlessCore.planPushes(adminBase, fragments, true);
+    globalThis.expect(plans.length).toBe(2);
+    let platform = Belt_Option.getExn(planFor(plans, "PlatformApi"));
+    globalThis.expect(platform.sdl.includes("Admin_Q")).toBe(true);
+    globalThis.expect(platform.sdl.includes("Platform_Q")).toBe(true);
+    globalThis.expect(platform.sdl.includes("Domain_Q")).toBe(false);
+  });
+  globalThis.test("split mode: empty base + Domain fragments on the Domain API only (no admin)", () => {
+    let plans = GraphQL_PushPlanner$ReventlessCore.planPushes(adminBase, fragments, true);
+    let domain = Belt_Option.getExn(planFor(plans, "DomainApi"));
+    globalThis.expect(domain.sdl.includes("Domain_Q")).toBe(true);
+    globalThis.expect(domain.sdl.includes("Admin_Q")).toBe(false);
+    globalThis.expect(domain.sdl.includes("Platform_Q")).toBe(false);
+  });
+  globalThis.test("unified mode: one Domain API push with admin base + ALL fragments", () => {
+    let plans = GraphQL_PushPlanner$ReventlessCore.planPushes(adminBase, fragments, false);
+    globalThis.expect(plans.length).toBe(1);
+    let only = plans[0];
+    globalThis.expect(only.api === "DomainApi").toBe(true);
+    globalThis.expect(only.sdl.includes("Admin_Q")).toBe(true);
+    globalThis.expect(only.sdl.includes("Domain_Q")).toBe(true);
+    globalThis.expect(only.sdl.includes("Platform_Q")).toBe(true);
+  });
+  globalThis.test("empty registry still pushes the admin base (split → Platform API)", () => {
+    let plans = GraphQL_PushPlanner$ReventlessCore.planPushes(adminBase, [], true);
+    let platform = Belt_Option.getExn(planFor(plans, "PlatformApi"));
+    globalThis.expect(platform.sdl.includes("Admin_Q")).toBe(true);
+    let domain = Belt_Option.getExn(planFor(plans, "DomainApi"));
+    globalThis.expect(domain.sdl.includes("Admin_Q")).toBe(false);
+  });
+});
+
+export {
+  mkFragment,
+  adminBase,
+  domainFrag,
+  platformFrag,
+  fragments,
+  planFor,
+}
+/* adminBase Not a pure module */