@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/lifecycle/PluginSpec.res

@@ -0,0 +1,84 @@
+@@reventless.spec("Plugin")
+
+open Reventless.Plugin
+
+// The Plugin aggregate is keyed by plugin **name** (not name@version). One
+// instance owns the whole lifecycle of every version of that name, deciding
+// supersession synchronously. Version-scoped commands carry the `version`
+// the transition targets; the ExtensionPoint→Plugin mapping supplies it
+// (translated from the transport-level `name@version` id — Approach 1).
+@schema
+type command =
+  | @noApi Heartbeat(version)
+  | @noApi Connect(pluginDefinition)
+  | @noApi Disconnect(version)
+  // Admin lifecycle commands — API-exposed (auto-derived admin mutations,
+  // Cognito @aws_auth gated). `version` selects which known version to act on.
+  | Activate(version)
+  | Deactivate(version)
+  // Records a protocol-version incompatibility without changing connection state.
+  | @noApi ReportIncompatibility(pluginDefinition)
+  // Manual admin retirement of a specific version (archive). Distinct from the
+  // 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).
+@schema
+type versionSupersededData = {
+  supersededVersion: version,
+  supersededDefinition: pluginDefinition,
+  newVersion: version,
+  newDefinition: pluginDefinition,
+}
+
+@schema
+type event =
+  // A heartbeat arrived for a version the aggregate has not yet connected —
+  // triggers the ConnectPlugin handshake (replaces UnknownPluginDetected). The
+  // version lets the EP rebuild the `name@version` id for the handshake.
+  | VersionDetected(version)
+  // A version completed the connect handshake (replaces Connected/Reconnected).
+  | VersionConnected(pluginDefinition)
+  // A newer version connected and took over as current.
+  | VersionSuperseded(versionSupersededData)
+  // An older still-live version became current again (rollback): the current
+  // version disconnected/deactivated/retired and a lower live version was promoted.
+  | VersionPromoted(pluginDefinition)
+  // A version's heartbeats timed out (EP disconnect schedule).
+  | VersionDisconnected(pluginDefinition)
+  // Admin transitions.
+  | VersionActivated(pluginDefinition)
+  | VersionDeactivated(pluginDefinition)
+  // Manual admin retirement (archive) of a specific version.
+  | 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 =
+  // Targeted version is unknown to this plugin name.
+  | UnknownVersion
+  // Admin command targets a version not in the state the command requires.
+  | AlreadyConnected
+  | IsDisconnected
+  | IsInactive

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

@@ -0,0 +1,148 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Heartbeat",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Connect",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Disconnect",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Activate",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Deactivate",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "ReportIncompatibility",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Retire",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  }))
+]);
+
+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),
+  newVersion: s.m(Plugin$Reventless.versionSchema),
+  newDefinition: s.m(Plugin$Reventless.pluginDefinitionSchema)
+}));
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "VersionDetected",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionConnected",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionSuperseded",
+    _0: s.m(versionSupersededDataSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionPromoted",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionDisconnected",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionActivated",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionDeactivated",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "VersionRetired",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  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)
+  }))
+]);
+
+let errorSchema = S.union([
+  S.literal("UnknownVersion"),
+  S.literal("AlreadyConnected"),
+  S.literal("IsDisconnected"),
+  S.literal("IsInactive")
+]);
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
+  "Heartbeat",
+  "Connect",
+  "Disconnect",
+  "ReportIncompatibility"
+]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "Plugin";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
+
+export {
+  name,
+  Id,
+  uiFragmentRegisteredDataSchema,
+  uiFragmentUpdatedDataSchema,
+  uiFragmentDeregisteredDataSchema,
+  versionSupersededDataSchema,
+  eventSchema,
+  errorSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+}
+/* commandSchema Not a pure module */

package/src/plugin/lifecycle/PluginsProjection.res

@@ -0,0 +1,154 @@
+open Reventless.Message
+
+let moduleUrl: string = %raw(`import.meta.url`)
+
+module Util = {
+  let extractExtensionPointNames = Array.map(_, (
+    extensionPoint: Reventless.Plugin.extensionPointDefinition,
+  ) => extensionPoint.name)
+  let extractExtensionNames = Array.map(_, (extension: Reventless.Plugin.extensionDefinition) =>
+    extension.extensionPointName
+  )
+
+  let isConnected = (status: PluginsReadModelSpec.status) =>
+    switch status {
+    | Connected => true
+    | Disconnected | Inactive | Retired => false
+    }
+
+  let without = (versions: array<Reventless.Plugin.version>, v) =>
+    versions->Array.filter(x => x != v)
+  let withVersion = (versions: array<Reventless.Plugin.version>, v) =>
+    versions->Array.includes(v) ? versions : Array.concat(versions, [v])
+
+  // Every version this row knows to be currently Connected — the `other` set
+  // plus the row's own version when its status is Connected.
+  let connectedVersions = (state: PluginsReadModelSpec.state): array<Reventless.Plugin.version> =>
+    isConnected(state.status) ? state.otherConnectedVersions->withVersion(state.version) : state.otherConnectedVersions
+
+  // Highest version (compareVersions) in the set, or None for an empty set.
+  let highest = (versions: array<Reventless.Plugin.version>): option<Reventless.Plugin.version> =>
+    versions->Array.reduce(None, (acc, v) =>
+      switch acc {
+      | None => Some(v)
+      | Some(cur) => Plugin.compareVersions(v, cur) > 0 ? Some(v) : acc
+      }
+    )
+}
+
+// Build the flattened current-version row from a definition + status + the set
+// of OTHER currently-connected versions (own version excluded).
+let displayState = (
+  def: Reventless.Plugin.pluginDefinition,
+  status: PluginsReadModelSpec.status,
+  statusChange,
+  otherConnectedVersions,
+): PluginsReadModelSpec.state => {
+  let base: PluginsReadModelSpec.state = {
+    name: def.name,
+    version: def.version,
+    eventCollector: def.eventCollector,
+    extensionPoints: def.extensionPoints,
+    extensionPointNames: def.extensionPoints->Util.extractExtensionPointNames,
+    extensionNames: def.extensions->Util.extractExtensionNames,
+    extensions: def.extensions,
+    status,
+    statusChange,
+    apiSchemaFragment: def.apiSchemaFragment,
+    uiFragments: def.uiFragments,
+    structure: def.structure,
+    dcbEventLog: def.dcbEventLog,
+    // The current version is never listed among the "other" connected versions.
+    otherConnectedVersions: otherConnectedVersions->Util.without(def.version),
+  }
+  switch def.apiTarget {
+  | Some(target) => {...base, apiTarget: target}
+  | None => base
+  }
+}
+
+module PluginMapping = Reventless.Projection.Mapping.Make(
+  PluginSpec,
+  PluginsReadModelSpec,
+  {
+    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
+      // events do not change which version is current.
+      | PluginSpec.VersionDetected(_)
+      | VersionSuperseded(_)
+      | IncompatiblePluginDetected(_)
+      | UIFragmentRegistered(_)
+      | UIFragmentUpdated(_)
+      | UIFragmentDeregistered(_) =>
+        Reventless.Projection.Ignore
+
+      // A version became live. It becomes current iff it is the highest
+      // Connected version; otherwise the higher version stays current and this
+      // one is recorded among the other currently-connected versions.
+      | VersionConnected(def) | VersionActivated(def) =>
+        Reventless.Projection.UpdateWithDefault(
+          id,
+          displayState(def, Connected, statusChange, []),
+          state => {
+            let connectedNow = Util.connectedVersions(state)->Util.withVersion(def.version)
+            switch Util.highest(connectedNow) {
+            | Some(hc) if hc == def.version =>
+              displayState(def, Connected, statusChange, connectedNow)
+            | _ => {
+                ...state,
+                otherConnectedVersions: state.otherConnectedVersions->Util.withVersion(def.version),
+              }
+            }
+          },
+        )
+
+      // Rollback: this (possibly lower) version is explicitly promoted to current.
+      // It leaves the "other" set (it is now the row's own version); the version
+      // it replaces already left Connected (that is what triggered the promote).
+      | VersionPromoted(def) =>
+        Reventless.Projection.UpdateWithDefault(
+          id,
+          displayState(def, Connected, statusChange, []),
+          state => displayState(def, Connected, statusChange, state.otherConnectedVersions),
+        )
+
+      // A version dropped out. The current row flips status; any OTHER version is
+      // pruned from the connected set. A VersionPromoted (if any) follows and
+      // overwrites the display with the rolled-back version.
+      | VersionDisconnected(def) =>
+        Reventless.Projection.UpdateWithDefault(
+          id,
+          displayState(def, Disconnected, statusChange, []),
+          state =>
+            state.version == def.version
+              ? {...state, status: Disconnected, statusChange}
+              : {...state, otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version)},
+        )
+      | VersionDeactivated(def) =>
+        Reventless.Projection.UpdateWithDefault(
+          id,
+          displayState(def, Inactive, statusChange, []),
+          state =>
+            state.version == def.version
+              ? {...state, status: Inactive, statusChange}
+              : {...state, otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version)},
+        )
+      | VersionRetired(def) =>
+        Reventless.Projection.UpdateWithDefault(
+          id,
+          displayState(def, Retired, statusChange, []),
+          state =>
+            state.version == def.version
+              ? {...state, status: Retired, statusChange}
+              : {...state, otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version)},
+        )
+      }
+    }
+  },
+)
+
+module Mappings = Reventless.Projection.Mappings.Make(PluginsReadModelSpec)
+
+let mappings: array<module(Mappings.Mapping)> = [module(PluginMapping)]

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

@@ -0,0 +1,230 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Plugin$ReventlessCore from "../component/Plugin.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
+import * as PluginSpec$ReventlessCore from "./PluginSpec.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "./PluginsReadModelSpec.res.mjs";
+
+let moduleUrl = import.meta.url;
+
+function extractExtensionPointNames(__x) {
+  return __x.map(extensionPoint => extensionPoint.name);
+}
+
+function extractExtensionNames(__x) {
+  return __x.map(extension => extension.extensionPointName);
+}
+
+function isConnected(status) {
+  return status === "Connected";
+}
+
+function without(versions, v) {
+  return versions.filter(x => x !== v);
+}
+
+function withVersion(versions, v) {
+  if (versions.includes(v)) {
+    return versions;
+  } else {
+    return versions.concat([v]);
+  }
+}
+
+function connectedVersions(state) {
+  if (isConnected(state.status)) {
+    return withVersion(state.otherConnectedVersions, state.version);
+  } else {
+    return state.otherConnectedVersions;
+  }
+}
+
+function highest(versions) {
+  return Stdlib_Array.reduce(versions, undefined, (acc, v) => {
+    if (acc !== undefined && Plugin$ReventlessCore.compareVersions(v, acc) <= 0) {
+      return acc;
+    } else {
+      return v;
+    }
+  });
+}
+
+let Util = {
+  extractExtensionPointNames: extractExtensionPointNames,
+  extractExtensionNames: extractExtensionNames,
+  isConnected: isConnected,
+  without: without,
+  withVersion: withVersion,
+  connectedVersions: connectedVersions,
+  highest: highest
+};
+
+function displayState(def, status, statusChange, otherConnectedVersions) {
+  let base_name = def.name;
+  let base_version = def.version;
+  let base_eventCollector = def.eventCollector;
+  let base_extensionPoints = def.extensionPoints;
+  let base_extensionPointNames = def.extensionPoints.map(extensionPoint => extensionPoint.name);
+  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_otherConnectedVersions = without(otherConnectedVersions, def.version);
+  let base = {
+    name: base_name,
+    version: base_version,
+    eventCollector: base_eventCollector,
+    extensionPoints: base_extensionPoints,
+    extensionPointNames: base_extensionPointNames,
+    extensionNames: base_extensionNames,
+    extensions: base_extensions,
+    status: status,
+    statusChange: statusChange,
+    apiSchemaFragment: base_apiSchemaFragment,
+    uiFragments: base_uiFragments,
+    structure: base_structure,
+    dcbEventLog: base_dcbEventLog,
+    otherConnectedVersions: base_otherConnectedVersions
+  };
+  let target = def.apiTarget;
+  if (target === undefined) {
+    return base;
+  }
+  let newrecord = {...base};
+  newrecord.apiTarget = target;
+  return newrecord;
+}
+
+function project(param) {
+  let event = param.event;
+  let match = param.meta;
+  let id = param.id;
+  let statusChange_at = match.time;
+  let statusChange_by = Stdlib_Option.getOr(match.user, "");
+  let statusChange = {
+    at: statusChange_at,
+    by: statusChange_by
+  };
+  switch (event.TAG) {
+    case "VersionPromoted" :
+      let def = event._0;
+      return {
+        TAG: "UpdateWithDefault",
+        _0: id,
+        _1: displayState(def, "Connected", statusChange, []),
+        _2: state => displayState(def, "Connected", statusChange, state.otherConnectedVersions)
+      };
+    case "VersionDisconnected" :
+      let def$1 = event._0;
+      return {
+        TAG: "UpdateWithDefault",
+        _0: id,
+        _1: displayState(def$1, "Disconnected", statusChange, []),
+        _2: state => {
+          if (state.version === def$1.version) {
+            let newrecord = {...state};
+            newrecord.statusChange = statusChange;
+            newrecord.status = "Disconnected";
+            return newrecord;
+          }
+          let newrecord$1 = {...state};
+          newrecord$1.otherConnectedVersions = without(state.otherConnectedVersions, def$1.version);
+          return newrecord$1;
+        }
+      };
+    case "VersionConnected" :
+    case "VersionActivated" :
+      break;
+    case "VersionDeactivated" :
+      let def$2 = event._0;
+      return {
+        TAG: "UpdateWithDefault",
+        _0: id,
+        _1: displayState(def$2, "Inactive", statusChange, []),
+        _2: state => {
+          if (state.version === def$2.version) {
+            let newrecord = {...state};
+            newrecord.statusChange = statusChange;
+            newrecord.status = "Inactive";
+            return newrecord;
+          }
+          let newrecord$1 = {...state};
+          newrecord$1.otherConnectedVersions = without(state.otherConnectedVersions, def$2.version);
+          return newrecord$1;
+        }
+      };
+    case "VersionRetired" :
+      let def$3 = event._0;
+      return {
+        TAG: "UpdateWithDefault",
+        _0: id,
+        _1: displayState(def$3, "Retired", statusChange, []),
+        _2: state => {
+          if (state.version === def$3.version) {
+            let newrecord = {...state};
+            newrecord.statusChange = statusChange;
+            newrecord.status = "Retired";
+            return newrecord;
+          }
+          let newrecord$1 = {...state};
+          newrecord$1.otherConnectedVersions = without(state.otherConnectedVersions, def$3.version);
+          return newrecord$1;
+        }
+      };
+    default:
+      return "Ignore";
+  }
+  let def$4 = event._0;
+  return {
+    TAG: "UpdateWithDefault",
+    _0: id,
+    _1: displayState(def$4, "Connected", statusChange, []),
+    _2: state => {
+      let connectedNow = withVersion(connectedVersions(state), def$4.version);
+      let hc = highest(connectedNow);
+      if (hc !== undefined && hc === def$4.version) {
+        return displayState(def$4, "Connected", statusChange, connectedNow);
+      }
+      let newrecord = {...state};
+      newrecord.otherConnectedVersions = withVersion(state.otherConnectedVersions, def$4.version);
+      return newrecord;
+    }
+  };
+}
+
+let PluginMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: PluginSpec$ReventlessCore.name,
+  eventSchema: PluginSpec$ReventlessCore.eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: PluginsReadModelSpec$ReventlessCore.name,
+  stateSchema: PluginsReadModelSpec$ReventlessCore.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+let Mappings = Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: PluginsReadModelSpec$ReventlessCore.name,
+  stateSchema: PluginsReadModelSpec$ReventlessCore.stateSchema,
+  subIdConfig: undefined
+});
+
+let mappings = [PluginMapping];
+
+export {
+  moduleUrl,
+  Util,
+  displayState,
+  PluginMapping,
+  Mappings,
+  mappings,
+}
+/* moduleUrl Not a pure module */

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -0,0 +1,66 @@
+@@reventless.spec("Plugins")
+
+// Current view — one row per plugin **name**, holding the currently-active
+// version's definition. Keyed by the aggregate id (= plugin name). The status
+// here is the *current* version's status; "Superseded" is not represented (a
+// superseded version is simply no longer the current row).
+@schema
+type status =
+  | Connected
+  | Disconnected
+  // Admin suspend (Deactivate).
+  | Inactive
+  // Manual admin retirement (archive) of the current version.
+  | Retired
+
+@schema
+type state = {
+  name: Reventless.Plugin.name,
+  version: Reventless.Plugin.version,
+  eventCollector: string,
+  extensionPoints: array<Reventless.Plugin.extensionPointDefinition>,
+  extensionPointNames: array<string>,
+  extensionNames: array<string>,
+  extensions: array<Reventless.Plugin.extensionDefinition>,
+  status: status,
+  statusChange: Message.statusChange,
+  apiSchemaFragment: @s.matches(Reventless.Plugin.apiSchemaFragmentOptionSchema) option<Reventless.Plugin.apiSchemaFragment>,
+  // 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>,
+  // DCB EventLog definition for plugins that bundle a DcbEventLog component.
+  // Admin's manageSubscriptions uses this to wire cross-plugin SNS subscriptions
+  // 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>,
+  // 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
+  // deploy overlap, and is pruned the moment a version stops being Connected. So
+  // it is empty in steady state and holds at most the one-or-two concurrently-live
+  // versions of a rolling deploy — never the full history.
+  otherConnectedVersions: array<Reventless.Plugin.version>,
+}
+
+type queryResult = {
+  id: string,
+  name: Reventless.Plugin.name,
+  version: Reventless.Plugin.version,
+  eventCollector: string,
+  extensionPoints: array<Reventless.Plugin.extensionPointDefinition>,
+  extensionPointNames: array<string>,
+  extensionNames: array<string>,
+  extensions: array<Reventless.Plugin.extensionDefinition>,
+  status: status,
+  apiSchemaFragment: option<Reventless.Plugin.apiSchemaFragment>,
+  apiTarget?: string,
+  uiFragments: option<Reventless.Plugin.uiFragmentManifest>,
+  structure: option<Reventless.Plugin.pluginStructure>,
+  dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
+}
+
+