@reventlessdev/reventless-core 3.0.0-alpha.156 → 3.0.0-alpha.158

package/src/plugin/connect/PluginConnectExtension_Mapping.res.mjs

@@ -8,22 +8,42 @@ function Make(Spec) {
   let mapIncomingEvent = (pluginId, event, _meta, _pluginDef, _queryEngine) => {
     let pluginDefinition = Spec.pluginDefinition;
     let id = pluginDefinition.id;
-    if (typeof event !== "object") {
-      if (pluginId === id) {
-        return [{
-            TAG: "PublishExtensionPointCommand",
-            _0: id,
-            _1: {
-              TAG: "ConnectPlugin",
-              _0: pluginDefinition
-            }
-          }];
-      } else {
-        return [];
-      }
-    } else {
+    if (typeof event === "object") {
+      return [];
+    }
+    if (pluginId !== id) {
       return [];
     }
+    let manifest = Spec.uiFragments;
+    if (manifest !== undefined) {
+      return [
+        {
+          TAG: "PublishExtensionPointCommand",
+          _0: id,
+          _1: {
+            TAG: "ConnectPlugin",
+            _0: pluginDefinition
+          }
+        },
+        {
+          TAG: "PublishExtensionPointCommand",
+          _0: id,
+          _1: {
+            TAG: "RegisterUiFragment",
+            _0: manifest
+          }
+        }
+      ];
+    } else {
+      return [{
+          TAG: "PublishExtensionPointCommand",
+          _0: id,
+          _1: {
+            TAG: "ConnectPlugin",
+            _0: pluginDefinition
+          }
+        }];
+    }
   };
   let $$let = ExtensionMapping$ReventlessInfra.NoDelegate.Id;
   let ConnectPluginMapping = ExtensionMapping$ReventlessInfra.Make({

package/src/plugin/connect/PluginExtensionPoint_Builder.res

@@ -26,7 +26,13 @@ module Make = (
 
     let name = PluginMappingInstance.Mapping.delegateName
     let moduleUrl = PluginExtensionPointSpec.moduleUrl
-    let mappings: array<module(Mapping)> = [module(PluginMappingInstance.Mapping)]
+    // The UI-fragment mapping routes RegisterUiFragment / (Disconnect →) DeregisterUiFragment to
+    // the admin UiFragmentRegistry slice; the Plugin mapping keeps the lifecycle. Both run per
+    // incoming command (ExtensionPoint_Callback fans commands through all mappings).
+    let mappings: array<module(Mapping)> = [
+      module(PluginMappingInstance.Mapping),
+      module(PluginExtensionPoint_UiFragment.Mapping),
+    ]
   }
   include ExtensionPoint_Builder.Make(
     PluginExtensionPointSpec,

package/src/plugin/connect/PluginExtensionPoint_Builder.res.mjs

@@ -3,12 +3,16 @@
 import * as ExtensionPoint_Builder$ReventlessCore from "../../components/ExtensionPoint/ExtensionPoint_Builder.res.mjs";
 import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
 import * as PluginExtensionPoint_Plugin$ReventlessCore from "./PluginExtensionPoint_Plugin.res.mjs";
+import * as PluginExtensionPoint_UiFragment$ReventlessCore from "./PluginExtensionPoint_UiFragment.res.mjs";
 
 function Make(Spec) {
   return RuntimeEnvironment => (CommandTopicChannel => (EventTopicAdapter => (ExtensionPointRuntimeBuilder => {
     let PluginMappingInstance = PluginExtensionPoint_Plugin$ReventlessCore.Make(Spec);
     let name = PluginMappingInstance.Mapping.delegateName;
-    let mappings = [PluginMappingInstance.Mapping];
+    let mappings = [
+      PluginMappingInstance.Mapping,
+      PluginExtensionPoint_UiFragment$ReventlessCore.Mapping
+    ];
     let Mappings = {
       name: name,
       moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -191,6 +191,9 @@ module Make = (Spec: Spec) => {
           HandleDirective(directiveHandler, DeleteDisconnectSchedule(id)),
         ]
       | ForwardCommand(forwardCommand) => [HandleDirective(directiveHandler, ForwardCommand(forwardCommand))]
+      // Routed to the UiFragmentRegistry slice by the sibling UI-fragment mapping, not the
+      // Plugin aggregate — a no-op here.
+      | RegisterUiFragment(_) => []
       }
 
     let mapOutgoingEvent = Some(
@@ -230,7 +233,6 @@ module Make = (Spec: Spec) => {
         | IncompatiblePluginDetected(pluginDefinition) => [
             PublishEvent(pluginDefinition.id, IncompatiblePlugin(pluginDefinition)),
           ]
-        | UIFragmentRegistered(_) | UIFragmentUpdated(_) | UIFragmentDeregistered(_) => []
         },
     )
   }

package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs

@@ -183,6 +183,8 @@ function Make(Spec) {
               _0: cmd._0
             }
           }];
+      case "RegisterUiFragment" :
+        return [];
       case "RedetectPlugin" :
         return [
           {
@@ -213,6 +215,8 @@ function Make(Spec) {
             _0: Plugin$ReventlessCore.makeId(id, event._0),
             _1: "UnknownPluginDetected"
           }];
+      case "VersionSuperseded" :
+        return [];
       case "VersionConnected" :
       case "VersionPromoted" :
         break;
@@ -296,8 +300,6 @@ function Make(Spec) {
               _0: pluginDefinition$4
             }
           }];
-      default:
-        return [];
     }
     let pluginDefinition$5 = event._0;
     return [

package/src/plugin/connect/PluginExtensionPoint_UiFragment.res

@@ -0,0 +1,52 @@
+// Second mapping on the admin PluginExtensionPoint, routing UI-fragment lifecycle to the
+// admin UiFragmentRegistry StateChangeSlice (docs/plans/event-sourced-fragment-registries.md).
+//
+// The EP runtime fans every incoming command through ALL mappings and flattens the results
+// (ExtensionPoint_Callback.mapIncomingCommands). This mapping's Delegate is the slice, so its
+// PublishCommand encodes with the slice's commandSchema and routes to the slice's command
+// topic via publishToAggregates["UiFragmentRegistry"] (registered by Platform_Admin's merge).
+// The sibling PluginExtensionPoint_Plugin mapping keeps handling lifecycle for the Plugin
+// aggregate; the two run side by side on the same EP.
+//
+// A StateChangeSlice Spec structurally satisfies Reventless.Aggregate.Spec (name, Id,
+// command/event/error + schemas, commandSchema, commandAuthorization, moduleUrl), which is all
+// ExtensionPointMapping.Make consumes from a Delegate.
+
+open ReventlessInfra.ExtensionPointMapping
+
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+
+module UiFragmentMapping = {
+  module ExtensionPoint = PluginExtensionPointSpec
+  module Delegate = UiFragmentRegistry
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  // `id` is the EP transport id (`name@version`); the registry is keyed by bare plugin name,
+  // so route on `Plugin.name(id)`. `at` carries the incoming command's producer time (the
+  // StateViewSlice projection has no event meta).
+  let mapIncomingCommand = (id, cmd, meta: Reventless.Message.meta) =>
+    switch cmd {
+    | PluginExtensionPointSpec.RegisterUiFragment(manifest) => [
+        PublishCommand(
+          Plugin.name(id),
+          Delegate.RegisterUiFragment({
+            pluginId: Plugin.name(id),
+            manifest,
+            at: meta.time,
+          }),
+        ),
+      ]
+    // Deregistration rides DisconnectPlugin, which the admin disconnect schedule also sends on
+    // heartbeat timeout — so both graceful and timeout disconnects deregister the fragment.
+    | DisconnectPlugin => [
+        PublishCommand(Plugin.name(id), Delegate.DeregisterUiFragment({pluginId: Plugin.name(id)})),
+      ]
+    | Heartbeat(_) | ConnectPlugin(_) | RedetectPlugin(_) | ForwardCommand(_) => []
+    }
+
+  // This mapping never reflects slice events back through the EP.
+  let mapOutgoingEvent = None
+}
+
+module Mapping = ReventlessInfra.ExtensionPointMapping.Make(UiFragmentMapping)

package/src/plugin/connect/PluginExtensionPoint_UiFragment.res.mjs

@@ -0,0 +1,74 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Plugin$ReventlessCore from "../component/Plugin.res.mjs";
+import * as UiFragmentRegistry$ReventlessCore from "../../admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
+import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+
+let moduleUrl = import.meta.url;
+
+function mapIncomingCommand(id, cmd, meta) {
+  if (typeof cmd !== "object") {
+    return [{
+        TAG: "PublishCommand",
+        _0: Plugin$ReventlessCore.name(id),
+        _1: {
+          TAG: "DeregisterUiFragment",
+          pluginId: Plugin$ReventlessCore.name(id)
+        }
+      }];
+  } else if (cmd.TAG === "RegisterUiFragment") {
+    return [{
+        TAG: "PublishCommand",
+        _0: Plugin$ReventlessCore.name(id),
+        _1: {
+          TAG: "RegisterUiFragment",
+          pluginId: Plugin$ReventlessCore.name(id),
+          manifest: cmd._0,
+          at: meta.time
+        }
+      }];
+  } else {
+    return [];
+  }
+}
+
+let UiFragmentMapping = {
+  ExtensionPoint: undefined,
+  Delegate: undefined,
+  moduleUrl: moduleUrl,
+  mapIncomingCommand: mapIncomingCommand,
+  mapOutgoingEvent: undefined
+};
+
+let Mapping = ExtensionPointMapping$ReventlessInfra.Make({
+  ExtensionPoint: {
+    name: PluginExtensionPointSpec$ReventlessInfra.name,
+    moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+    commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema,
+    eventSchema: PluginExtensionPointSpec$ReventlessInfra.eventSchema,
+    directiveSchema: PluginExtensionPointSpec$ReventlessInfra.directiveSchema
+  },
+  Delegate: {
+    Id: Id$Reventless.$$String,
+    name: UiFragmentRegistry$ReventlessCore.name,
+    eventSchema: UiFragmentRegistry$ReventlessCore.eventSchema,
+    errorSchema: UiFragmentRegistry$ReventlessCore.errorSchema,
+    commandSchema: UiFragmentRegistry$ReventlessCore.commandSchema,
+    moduleUrl: UiFragmentRegistry$ReventlessCore.moduleUrl,
+    commandAuthorization: UiFragmentRegistry$ReventlessCore.commandAuthorization
+  },
+  moduleUrl: moduleUrl,
+  mapIncomingCommand: mapIncomingCommand,
+  mapOutgoingEvent: undefined
+});
+
+let PluginExtensionPointSpec;
+
+export {
+  PluginExtensionPointSpec,
+  UiFragmentMapping,
+  Mapping,
+}
+/* moduleUrl Not a pure module */

package/src/plugin/lifecycle/PluginBehavior.res

@@ -38,18 +38,6 @@ let snapshot = None
 
 let atomicCounter = None
 
-let uiRegisterEvents = (pluginId, manifest) =>
-  switch manifest {
-  | None => []
-  | Some(manifest) => [(UIFragmentRegistered({pluginId, manifest}): event)]
-  }
-
-let uiDeregisterEvents = (pluginId, manifest) =>
-  switch manifest {
-  | None => []
-  | Some(_) => [(UIFragmentDeregistered({pluginId: pluginId}): event)]
-  }
-
 // Highest version with status Connected, or None.
 let highestConnected = (known: dict<knownVersion>): option<version> =>
   known
@@ -93,11 +81,11 @@ let currentAfterConnect = (known, v) =>
   | Some(h) => Plugin.compareVersions(v, h) >= 0 ? v : h
   }
 
-// Events emitted when `v` (with `def`) becomes Connected: the VersionConnected +
-// UI register, plus a VersionSuperseded record when `v` takes over from a
+// Events emitted when `v` (with `def`) becomes Connected: the VersionConnected,
+// plus a VersionSuperseded record when `v` takes over from a
 // different current version.
 let connectEvents = (state: state, v: version, def: pluginDefinition): array<event> => {
-  let base = Array.concat([VersionConnected(def)], uiRegisterEvents(def.id, def.uiFragments))
+  let base = [VersionConnected(def)]
   let supersede = if currentAfterConnect(state.known, v) == v {
     switch state.current {
     | Some(c) if c != v =>
@@ -159,7 +147,7 @@ let decide = (state, command) =>
     let v = def.version
     switch state.known->Dict.get(v) {
     // Idempotent when the definition is unchanged; when a redeploy carries a changed
-    // definition (e.g. a newly added `kind`, updated uiFragments/protocols) re-emit
+    // definition (e.g. a newly added `kind`, updated protocols) re-emit
     // VersionConnected to overwrite the stored def and re-project the row. The version
     // is already current, so connectEvents' supersede stays empty — a bare refresh.
     | Some({status: Connected, definition}) => definition == def ? Ok([]) : Ok([VersionConnected(def)])
@@ -168,24 +156,13 @@ let decide = (state, command) =>
   | Disconnect(v) =>
     switch state.known->Dict.get(v) {
     | Some({status: Connected, definition}) =>
-      Ok(
-        Array.concat(
-          Array.concat(
-            [VersionDisconnected(definition)],
-            uiDeregisterEvents(definition.id, definition.uiFragments),
-          ),
-          promoteEvents(state, v),
-        ),
-      )
+      Ok(Array.concat([VersionDisconnected(definition)], promoteEvents(state, v)))
     | _ => Ok([]) // not connected / unknown → tolerate stray disconnect
     }
   | Activate(v) =>
     switch state.known->Dict.get(v) {
     | Some({status: Inactive | Retired, definition}) =>
-      let base = Array.concat(
-        [VersionActivated(definition)],
-        uiRegisterEvents(definition.id, definition.uiFragments),
-      )
+      let base = [VersionActivated(definition)]
       let supersede = if currentAfterConnect(state.known, v) == v {
         switch state.current {
         | Some(c) if c != v =>
@@ -213,15 +190,7 @@ let decide = (state, command) =>
   | Deactivate(v) =>
     switch state.known->Dict.get(v) {
     | Some({status: Connected | Disconnected, definition}) =>
-      Ok(
-        Array.concat(
-          Array.concat(
-            [VersionDeactivated(definition)],
-            uiDeregisterEvents(definition.id, definition.uiFragments),
-          ),
-          promoteEvents(state, v),
-        ),
-      )
+      Ok(Array.concat([VersionDeactivated(definition)], promoteEvents(state, v)))
     | Some({status: Inactive | Retired}) => Ok([]) // idempotent / archived no-op
     | None => Error(UnknownVersion)
     }
@@ -229,15 +198,7 @@ let decide = (state, command) =>
     switch state.known->Dict.get(v) {
     | Some({status: Retired}) => Ok([]) // idempotent
     | Some({definition}) =>
-      Ok(
-        Array.concat(
-          Array.concat(
-            [VersionRetired(definition)],
-            uiDeregisterEvents(definition.id, definition.uiFragments),
-          ),
-          promoteEvents(state, v),
-        ),
-      )
+      Ok(Array.concat([VersionRetired(definition)], promoteEvents(state, v)))
     | None => Error(UnknownVersion)
     }
   | ReportIncompatibility(def) => Ok([IncompatiblePluginDetected(def)])
@@ -262,9 +223,6 @@ let evolve = (state: state, event) => {
   | VersionDetected(_)
   | VersionSuperseded(_)
   | VersionPromoted(_)
-  | IncompatiblePluginDetected(_)
-  | UIFragmentRegistered(_)
-  | UIFragmentUpdated(_)
-  | UIFragmentDeregistered(_) => state
+  | IncompatiblePluginDetected(_) => state
   }
 }

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,