@reventlessdev/reventless-core 3.0.0-alpha.250 → 3.0.0-alpha.252

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

@@ -9,12 +9,17 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Trait$Reventless from "@reventlessdev/reventless-spec/src/types/Trait.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+import * as Transition$Reventless from "@reventlessdev/reventless-spec/src/types/Transition.res.mjs";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
+import * as CapabilityNeed$Reventless from "@reventlessdev/reventless-spec/src/semantic/CapabilityNeed.res.mjs";
 import * as SchemaType$ReventlessCore from "../../components/Api/SchemaType.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
@@ -191,6 +196,132 @@ function lifecycleStatesFromStateSchema(entityName, stateSchema) {
   });
 }
 
+function translationTableFailures(label, declared, publishedNames, sourceNames) {
+  let failures = [];
+  let push = msg => {
+    failures.push(msg);
+  };
+  declared.forEach(param => {
+    let name = param.name;
+    if (!publishedNames.includes(name)) {
+      push(label + `: publishedEvents names "` + name + `", which the extension point does not ` + (`publish — it declares ` + publishedNames.join(", ") + `.`));
+    }
+    param.fromEventTypes.forEach(src => {
+      if (!sourceNames.includes(src)) {
+        return push(label + `: publishedEvents says "` + name + `" comes from "` + src + `", which is not an ` + (`event of ` + sourceNames.join(", ") + `.`));
+      }
+    });
+  });
+  return failures;
+}
+
+function translationTableDrift(label, declared, observed, followed) {
+  let declaredEdges = Stdlib_Array.reduce(declared, [], (acc, param) => {
+    let name = param.name;
+    return acc.concat(param.fromEventTypes.map(src => [
+      src,
+      name
+    ]));
+  });
+  let has = (edges, param) => {
+    let pub = param[1];
+    let src = param[0];
+    return edges.some(param => {
+      if (Primitive_object.equal(param[0], src)) {
+        return Primitive_object.equal(param[1], pub);
+      } else {
+        return false;
+      }
+    });
+  };
+  let failures = observed.filter(edge => !has(declaredEdges, edge)).map(param => label + `: "` + param[0] + `" publishes "` + param[1] + `", which publishedEvents does not declare.`);
+  let warnings = declaredEdges.filter(param => {
+    let src = param[0];
+    if (followed.includes(src)) {
+      return !has(observed, [
+        src,
+        param[1]
+      ]);
+    } else {
+      return false;
+    }
+  }).map(param => {
+    let src = param[0];
+    return label + `: publishedEvents declares "` + src + `" → "` + param[1] + `", which the mapping did not ` + (`produce for a synthesised "` + src + `".`);
+  });
+  return [
+    failures,
+    warnings
+  ];
+}
+
+function handledTableFailures(label, declared, eventNames, commandNames) {
+  let failures = [];
+  declared.forEach(param => {
+    let name = param.name;
+    if (!eventNames.includes(name)) {
+      failures.push(label + `: handledEvents names "` + name + `", which the extension point does not ` + (`publish — it declares ` + eventNames.join(", ") + `.`));
+    }
+    param.toCommandTypes.forEach(cmd => {
+      if (!commandNames.includes(cmd)) {
+        failures.push(label + `: handledEvents says "` + name + `" routes to "` + cmd + `", which is neither a ` + (`delegate command nor an extension point command — ` + commandNames.join(", ") + `.`));
+        return;
+      }
+    });
+  });
+  return failures;
+}
+
+function commandTableFailures(label, keyed, valueKind, rows, keyNames, valueNames) {
+  let failures = [];
+  let push = msg => {
+    failures.push(msg);
+  };
+  rows.forEach(param => {
+    let name = param[0];
+    if (!keyNames.includes(name)) {
+      push(label + `: ` + keyed + ` names "` + name + `", which is not a command of the extension ` + (`point — it declares ` + keyNames.join(", ") + `.`));
+    }
+    param[1].forEach(v => {
+      if (!valueNames.includes(v)) {
+        return push(label + `: ` + keyed + ` says "` + name + `" ` + valueKind + ` "` + v + `", which the delegate does ` + (`not declare — ` + valueNames.join(", ") + `.`));
+      }
+    });
+  });
+  return failures;
+}
+
+let probeId = "probe";
+
+let probeMeta = {
+  service: "Plugin_Structure",
+  time: "",
+  msgId: "",
+  correlationId: ""
+};
+
+async function probeQueryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function probeQueryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let probeQueryEngine = {
+  scan: probeQueryEngine_scan,
+  query: probeQueryEngine_query
+};
+
+function reportTranslationTables(pluginName, failures, warnings) {
+  if (warnings.length !== 0) {
+    log.warn("Plugin_Structure", undefined, pluginName + `:\n` + warnings.join("\n"));
+  }
+  if (failures.length !== 0) {
+    return Stdlib_JsError.throwWithMessage(pluginName + `: the declared translation table does not match the mapping.\n` + failures.join("\n"));
+  }
+}
+
 function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView) {
   let unvalidated = {
     contents: 0
@@ -215,16 +346,16 @@ function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView)
         unvalidated.contents = unvalidated.contents + 1 | 0;
       } else {
         declared.filter(state => !known.includes(state)).forEach(state => {
-          failures.push(w.name + `.` + cmd.name + `: @transition names "` + state + `", which none of its ` + (`linked views declare — ` + w.linkedViews.join(", ") + ` know ` + known.join(", ") + `.`));
+          failures.push(w.name + `.` + cmd.name + ` declares state "` + state + `", which none of its ` + (`linked views declare — ` + w.linkedViews.join(", ") + ` know ` + known.join(", ") + `.`));
         });
       }
     });
   });
   if (unvalidated.contents > 0) {
-    log.warn("Plugin_Structure", undefined, pluginName + `: ` + unvalidated.contents.toString() + ` command(s) declare a @transition but no linked view declares a lifecycle to check it against.`);
+    log.warn("Plugin_Structure", undefined, pluginName + `: ` + unvalidated.contents.toString() + ` command(s) declare a transition but no linked view declares a lifecycle to check it against.`);
   }
   if (failures.length !== 0) {
-    return Stdlib_JsError.throwWithMessage(pluginName + `: @transition names states that do not exist.\n` + failures.join("\n"));
+    return Stdlib_JsError.throwWithMessage(pluginName + `: a declared transition names states that do not exist.\n` + failures.join("\n"));
   }
 }
 
@@ -463,20 +594,27 @@ function annotateArgTypes(schema, argTypes) {
   return schema;
 }
 
-function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthorization, v) {
+function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, v) {
   let mkDef = (variantName, properties) => {
     let match = commandLevelAndId(isAggregate, variantName, properties);
     let references = extractReferences(properties);
-    let allowedStates = ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName);
-    let targetState = ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName);
+    let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
+        TAG: variantName
+      }) : variantName;
+    let declared = commandTransition(syntheticCommand);
+    let match$1;
+    match$1 = typeof declared !== "object" ? [
+        ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName),
+        ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName)
+      ] : [
+        Transition$Reventless.allowedStates(declared),
+        Transition$Reventless.targetState(declared)
+      ];
     let apiExposed = false;
     if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
       let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
       apiExposed = excluded !== undefined ? !excluded.has(variantName) : true;
     }
-    let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
-        TAG: variantName
-      }) : variantName;
     let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand));
     let mutationField = apiExposed ? mutationFieldFor(variantName) : "";
     let jsonSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v);
@@ -488,8 +626,8 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
       aggregateIdField: match[1],
       mutationField: mutationField,
       references: references,
-      allowedStates: allowedStates,
-      targetState: targetState,
+      allowedStates: match$1[0],
+      targetState: match$1[1],
       apiExposed: apiExposed,
       requiredAccess: requiredAccess,
       ownerField: Owner$Reventless.fieldNamesOfProperties(properties)[0]
@@ -519,11 +657,11 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
   }
 }
 
-function extractCommandDefs(isAggregate, mutationFieldFor, commandAuthorization, commandSchema) {
+function extractCommandDefs(isAggregate, mutationFieldFor, commandAuthorization, commandTransition, commandSchema) {
   if (commandSchema.type === "anyOf") {
-    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, v));
+    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, v));
   } else {
-    return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandSchema), [], def => [def]);
+    return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, commandSchema), [], def => [def]);
   }
 }
 
@@ -663,6 +801,17 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       return Primitive_string.compare(a.field, b.field);
     }
   };
+  let dcbCommandOwners = {};
+  stateChangeSlices.forEach(SCS => {
+    DcbTag$Reventless.extractAllVariantNames(SCS.Spec.commandSchema).forEach(cmd => {
+      let owners = Stdlib_Option.getOr(dcbCommandOwners[cmd], []);
+      dcbCommandOwners[cmd] = owners.concat([SCS.Spec.name]);
+    });
+  });
+  let clashes = Object.entries(dcbCommandOwners).filter(param => param[1].length > 1).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+  if (clashes.length !== 0) {
+    Stdlib_JsError.throwWithMessage(name + `: ` + clashes.map(param => param[1].join(" and ") + ` both declare the command "` + param[0] + `"`).join("; ") + `.\n  A DCB plugin routes a command by its bare name, so one of these would never run. Qualify them — the shipped traits' emitters prefix every name with the host they are grafted onto, for exactly this reason.`);
+  }
   let storeDeclarationSites = [
     aggregates.flatMap(A => [
       [
@@ -746,6 +895,55 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
   if (found.length !== 0) {
     Stdlib_JsError.throwWithMessage(name + `: two declared object stores look like one store misspelled.\n` + found.map(Capability_Inference$ReventlessCore.collisionMessage).join("\n"));
   }
+  let requiredCapabilities = Stdlib_Array.reduce(outboundTranslationSlices.flatMap(OTS => OTS.Spec.capabilityNeeds.map(need => ({
+    capability: CapabilityNeed$Reventless.toString(need),
+    component: OTS.Spec.name
+  }))).toSorted((a, b) => {
+    if (a.capability === b.capability) {
+      return Primitive_string.compare(a.component, b.component);
+    } else {
+      return Primitive_string.compare(a.capability, b.capability);
+    }
+  }), [], (acc, d) => {
+    let prev = Stdlib_Array.last(acc);
+    if (prev !== undefined) {
+      if (Primitive_object.equal(prev, d)) {
+        return acc;
+      } else {
+        return acc.concat([d]);
+      }
+    } else {
+      return acc.concat([d]);
+    }
+  });
+  let entry = (component, decl) => ({
+    trait: decl.trait,
+    version: decl.version,
+    posture: Trait$Reventless.postureToString(decl.posture),
+    component: component
+  });
+  let traitDeclarations = Stdlib_Array.reduce([
+    aggregates.flatMap(A => A.Spec.traits.map(extra => entry(A.Spec.name, extra))),
+    stateChangeSlices.flatMap(SCS => SCS.Spec.traits.map(extra => entry(SCS.Spec.name, extra))),
+    outboundTranslationSlices.flatMap(OTS => OTS.Spec.traits.map(extra => entry(OTS.Spec.name, extra)))
+  ].flat().toSorted((a, b) => {
+    if (a.trait === b.trait) {
+      return Primitive_string.compare(a.component, b.component);
+    } else {
+      return Primitive_string.compare(a.trait, b.trait);
+    }
+  }), [], (acc, d) => {
+    let prev = Stdlib_Array.last(acc);
+    if (prev !== undefined) {
+      if (Primitive_object.equal(prev, d)) {
+        return acc;
+      } else {
+        return acc.concat([d]);
+      }
+    } else {
+      return acc.concat([d]);
+    }
+  });
   storeDeclarationSites.forEach(param => {
     Capability_Inference$ReventlessCore.scanSchema(param[0], param[1]).forEach(w => log.warn("Plugin_Structure", undefined, Capability_Inference$ReventlessCore.message(w)));
   });
@@ -840,7 +1038,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let consumed = match$1[1];
     return {
       name: SCS.Spec.name,
-      commands: extractCommandDefs(false, variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandSchema),
+      commands: extractCommandDefs(false, variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, SCS.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: consumed,
       linkedViews: linkedSvsFor(produced),
@@ -855,7 +1053,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let produced = match[1];
     return {
       name: A.Spec.name,
-      commands: extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandSchema),
+      commands: extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, A.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: [],
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
@@ -890,16 +1088,60 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     externalSystem: ITS.Spec.externalSystem,
     chapter: componentChapters[ITS.Spec.name]
   }));
+  let tableFailures = [];
+  let tableWarnings = [];
+  let pushAll = (into, xs) => {
+    xs.forEach(x => {
+      into.push(x);
+    });
+  };
   let extensionDefs = extensions.map(E => {
     let delegateNames = E.mappings.map(M => M.delegateName);
+    let epEventNames = DcbTag$Reventless.extractAllVariantNames(E.Spec.eventSchema);
+    let epCommandNames = DcbTag$Reventless.extractAllVariantNames(E.Spec.commandSchema);
+    let commandsByEvent = {};
+    let eventsByCommand = {};
+    E.mappings.forEach(M => {
+      let label = E.Spec.name + ` → ` + M.delegateName;
+      pushAll(tableFailures, handledTableFailures(label, M.handledEvents, epEventNames, M.delegateCommandNames.concat(epCommandNames)));
+      pushAll(tableFailures, commandTableFailures(label, "issuedCommands", "comes from", M.issuedCommands.map(param => [
+        param.name,
+        param.fromEventTypes
+      ]), epCommandNames, M.delegateEventNames));
+      M.issuedCommands.forEach(param => {
+        let key = E.Spec.name + `.` + param.name;
+        eventsByCommand[key] = Stdlib_Option.getOr(eventsByCommand[key], []).concat(qualify(name, param.fromEventTypes));
+      });
+      M.handledEvents.forEach(param => {
+        let qualified = param.toCommandTypes.map(cmd => {
+          if (M.delegateCommandNames.includes(cmd)) {
+            return name + `.` + cmd;
+          } else {
+            return E.Spec.name + `.` + cmd;
+          }
+        });
+        let key = E.Spec.name + `.` + param.name;
+        commandsByEvent[key] = Stdlib_Option.getOr(commandsByEvent[key], []).concat(qualified);
+      });
+    });
     return {
       name: E.Spec.name,
       delegateNames: delegateNames,
       eventTypes: qualify(E.Spec.name, DcbTag$Reventless.extractVariantNames(E.Spec.eventSchema)),
-      commandTypes: qualify(E.Spec.name, DcbTag$Reventless.extractAllVariantNames(E.Spec.commandSchema))
+      commandTypes: qualify(E.Spec.name, DcbTag$Reventless.extractAllVariantNames(E.Spec.commandSchema)),
+      handledEvents: Object.entries(commandsByEvent).map(param => ({
+        name: param[0],
+        toCommandTypes: Belt_SetString.toArray(Belt_SetString.fromArray(param[1]))
+      })),
+      issuedCommands: Object.entries(eventsByCommand).map(param => ({
+        name: param[0],
+        fromEventTypes: Belt_SetString.toArray(Belt_SetString.fromArray(param[1]))
+      }))
     };
   });
   let epByName = {};
+  let epPublished = {};
+  let epAccepted = {};
   extensionPoints.forEach(M => {
     let epName = M.ExtensionPoint.name;
     let sourceEvents = qualify(name, DcbTag$Reventless.extractVariantNames(M.Delegate.eventSchema));
@@ -914,16 +1156,174 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       match[1].concat(sourceEvents),
       match[2].concat(commands)
     ];
+    let label = epName + ` ← ` + M.Delegate.name;
+    let publishedNames = DcbTag$Reventless.extractAllVariantNames(M.ExtensionPoint.eventSchema);
+    let sourceNames = DcbTag$Reventless.extractAllVariantNames(M.Delegate.eventSchema);
+    pushAll(tableFailures, translationTableFailures(label, M.publishedEvents, publishedNames, sourceNames));
+    let acceptedNames = DcbTag$Reventless.extractAllVariantNames(M.ExtensionPoint.commandSchema);
+    let delegateCommandNames = DcbTag$Reventless.extractAllVariantNames(M.Delegate.commandSchema);
+    pushAll(tableFailures, commandTableFailures(label, "acceptedCommands", "routes to", M.acceptedCommands.map(param => [
+      param.name,
+      param.toCommandTypes
+    ]), acceptedNames, delegateCommandNames));
+    let acceptedObserved = [];
+    acceptedNames.forEach(cmd => {
+      let synthesised = DcbTag$Reventless.isVariantPayloadBearing(M.ExtensionPoint.commandSchema, cmd) ? Object.fromEntries([[
+            "TAG",
+            cmd
+          ]]) : cmd;
+      let actions;
+      try {
+        let command = Util_Sury$Reventless.fromJson(Message$Reventless.fillMissingDefaults(M.ExtensionPoint.commandSchema, synthesised, []), M.ExtensionPoint.commandSchema);
+        let decodedAs = Message$Reventless.variantNameOfJson(Message$Reventless.encode(command, M.ExtensionPoint.commandSchema));
+        actions = decodedAs !== cmd ? ({
+            TAG: "Error",
+            _0: `a synthesised "` + cmd + `" decoded as "` + decodedAs + `"`
+          }) : ({
+            TAG: "Ok",
+            _0: M.mapIncomingCommand(probeId, command, probeMeta)
+          });
+      } catch (exn) {
+        actions = {
+          TAG: "Error",
+          _0: `the mapping raised on a synthesised "` + cmd + `"`
+        };
+      }
+      if (actions.TAG === "Ok") {
+        actions._0.forEach(action => {
+          if (action.TAG !== "PublishCommand") {
+            return;
+          }
+          acceptedObserved.push([
+            cmd,
+            Message$Reventless.variantNameOfJson(Message$Reventless.encode(action._1, M.Delegate.commandSchema))
+          ]);
+        });
+        return;
+      }
+      tableWarnings.push(label + `: not checked against the arms — ` + actions._0 + `.`);
+    });
+    acceptedObserved.forEach(param => {
+      let routed = param[1];
+      let cmd = param[0];
+      if (!M.acceptedCommands.some(param => param.name === cmd ? param.toCommandTypes.includes(routed) : false)) {
+        tableFailures.push(label + `: "` + cmd + `" routes to "` + routed + `", which acceptedCommands does not declare.`);
+        return;
+      }
+    });
+    let acceptedTable = Stdlib_Option.getOr(epAccepted[epName], {});
+    M.acceptedCommands.forEach(param => {
+      let key = epName + `.` + param.name;
+      acceptedTable[key] = Stdlib_Option.getOr(acceptedTable[key], []).concat(qualify(name, param.toCommandTypes));
+    });
+    epAccepted[epName] = acceptedTable;
+    let mapOutgoing = M.mapOutgoingEvent;
+    if (mapOutgoing !== undefined) {
+      let observed = [];
+      let followed = [];
+      sourceNames.forEach(src => {
+        let synthesised = DcbTag$Reventless.isVariantPayloadBearing(M.Delegate.eventSchema, src) ? Object.fromEntries([[
+              "TAG",
+              src
+            ]]) : src;
+        let outcome;
+        try {
+          let event = Util_Sury$Reventless.fromJson(Message$Reventless.fillMissingDefaults(M.Delegate.eventSchema, synthesised, []), M.Delegate.eventSchema);
+          let decodedAs = Message$Reventless.variantNameOfJson(Message$Reventless.encode(event, M.Delegate.eventSchema));
+          if (decodedAs !== src) {
+            outcome = {
+              TAG: "Error",
+              _0: `a synthesised "` + src + `" decoded as "` + decodedAs + `"`
+            };
+          } else {
+            let actions = mapOutgoing(probeId, event, probeMeta, probeQueryEngine);
+            actions.forEach(action => {
+              switch (action.TAG) {
+                case "PublishEvent" :
+                  observed.push([
+                    src,
+                    Message$Reventless.variantNameOfJson(Message$Reventless.encode(action._1, M.ExtensionPoint.eventSchema))
+                  ]);
+                  return;
+                case "PublishEventAsync" :
+                case "HandleDirective" :
+                  return;
+              }
+            });
+            outcome = actions.some(action => {
+              switch (action.TAG) {
+                case "PublishEventAsync" :
+                  return true;
+                case "PublishEvent" :
+                case "HandleDirective" :
+                  return false;
+              }
+            }) ? ({
+                TAG: "Error",
+                _0: `"` + src + `" publishes behind a promise`
+              }) : ({
+                TAG: "Ok",
+                _0: undefined
+              });
+          }
+        } catch (exn) {
+          outcome = {
+            TAG: "Error",
+            _0: `the mapping raised on a synthesised "` + src + `"`
+          };
+        }
+        if (outcome.TAG === "Ok") {
+          followed.push(src);
+          return;
+        }
+        tableWarnings.push(label + `: not checked against the arms — ` + outcome._0 + `.`);
+      });
+      let match$1 = translationTableDrift(label, M.publishedEvents, observed, followed);
+      pushAll(tableFailures, match$1[0]);
+      pushAll(tableWarnings, match$1[1]);
+    } else if (M.publishedEvents.length !== 0) {
+      tableFailures.push(label + `: publishedEvents declares ` + M.publishedEvents.length.toString() + ` event(s), but the mapping has no mapOutgoingEvent and publishes nothing.`);
+    }
+    let declaredNames = M.publishedEvents.map(p => p.name);
+    publishedNames.filter(p => !declaredNames.includes(p)).forEach(p => {
+      tableWarnings.push(label + `: the extension point publishes "` + p + `", which no arm produces.`);
+    });
+    let table = Stdlib_Option.getOr(epPublished[epName], {});
+    M.publishedEvents.forEach(param => {
+      let key = epName + `.` + param.name;
+      table[key] = Stdlib_Option.getOr(table[key], []).concat(qualify(name, param.fromEventTypes));
+    });
+    epPublished[epName] = table;
   });
   let extensionPointDefs = Object.entries(epByName).map(param => {
     let match = param[1];
+    let epName = param[0];
     return {
-      name: param[0],
+      name: epName,
       delegateNames: Belt_SetString.toArray(Belt_SetString.fromArray(match[0])),
       sourceEventTypes: Belt_SetString.toArray(Belt_SetString.fromArray(match[1])),
-      commandTypes: Belt_SetString.toArray(Belt_SetString.fromArray(match[2]))
+      commandTypes: Belt_SetString.toArray(Belt_SetString.fromArray(match[2])),
+      publishedEvents: Object.entries(Stdlib_Option.getOr(epPublished[epName], {})).map(param => ({
+        name: param[0],
+        fromEventTypes: Belt_SetString.toArray(Belt_SetString.fromArray(param[1]))
+      })),
+      acceptedCommands: Object.entries(Stdlib_Option.getOr(epAccepted[epName], {})).map(param => ({
+        name: param[0],
+        toCommandTypes: Belt_SetString.toArray(Belt_SetString.fromArray(param[1]))
+      }))
     };
   });
+  Object.entries(epByName).forEach(param => {
+    let epName = param[0];
+    let handled = Object.keys(Stdlib_Option.getOr(epAccepted[epName], {}));
+    Belt_SetString.toArray(Belt_SetString.fromArray(param[1][2])).forEach(cmd => {
+      if (!handled.includes(cmd)) {
+        tableWarnings.push(epName + `: the extension point accepts "` + cmd + `", which no arm handles — a sender gets no error and nothing happens.`);
+        return;
+      }
+    });
+  });
+  reportTranslationTables(name, tableFailures, tableWarnings);
   checkDeclaredTransitions(name, stateChangeDefs.concat(aggregateDefs), lifecycleStatesByView);
   checkLifecycleTopology(name, stateChangeDefs.concat(aggregateDefs), lifecycleStatesByView);
   reportRetiredStates(name, retiredFailures, retiredUnchecked);
@@ -938,7 +1338,9 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     extensions: extensionDefs,
     extensionPoints: extensionPointDefs,
     requiredStores: requiredStores,
-    requiredStoreDeclarations: requiredStoreDeclarations
+    requiredStoreDeclarations: requiredStoreDeclarations,
+    requiredCapabilities: requiredCapabilities,
+    traitDeclarations: traitDeclarations
   };
 }
 
@@ -956,6 +1358,14 @@ export {
   checkRetiredValue,
   reportRetiredStates,
   lifecycleStatesFromStateSchema,
+  translationTableFailures,
+  translationTableDrift,
+  handledTableFailures,
+  commandTableFailures,
+  probeId,
+  probeMeta,
+  probeQueryEngine,
+  reportTranslationTables,
   checkDeclaredTransitions,
   lifecycleTopologyFindings,
   checkLifecycleTopology,

package/src/plugin/connect/PluginConnectExtension_Mapping.res

@@ -74,12 +74,9 @@ module Make = (Spec: Spec) => {
               ),
             ]
           }
-        // PluginConnected / PluginReconnected / PluginDeactivated for peer
-        // plugins used to call DoConnectPlugin / DoDisconnectPlugin here so
-        // each plugin's EC Lambda could subscribe / unsubscribe its own
-        // queue to peer EP topics. Admin owns that work now
-        // (manageSubscriptions in EventCollectorEntryPoint.mjs) — these
-        // cases drop to no-ops.
+        // A peer's PluginConnected / PluginDeactivated used to subscribe or
+        // unsubscribe this plugin's own queue to peer EP topics. Admin owns that
+        // now (manageSubscriptions), so these drop to no-ops.
         | _ => []
         }
       }

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

@@ -45,6 +45,14 @@ function Make(Spec) {
         }];
     }
   };
+  let handledEvents = [{
+      name: "UnknownPluginDetected",
+      toCommandTypes: [
+        "ConnectPlugin",
+        "RegisterUiFragment"
+      ]
+    }];
+  let issuedCommands = [];
   let $$let = ExtensionMapping$ReventlessInfra.NoDelegate.Id;
   let ConnectPluginMapping = ExtensionMapping$ReventlessInfra.Make({
     ExtensionPoint: {
@@ -67,12 +75,16 @@ function Make(Spec) {
       errorSchema: ExtensionMapping$ReventlessInfra.NoDelegate.errorSchema,
       commandSchema: ExtensionMapping$ReventlessInfra.NoDelegate.commandSchema,
       moduleUrl: ExtensionMapping$ReventlessInfra.NoDelegate.moduleUrl,
-      commandAuthorization: ExtensionMapping$ReventlessInfra.NoDelegate.commandAuthorization
+      commandAuthorization: ExtensionMapping$ReventlessInfra.NoDelegate.commandAuthorization,
+      commandTransition: ExtensionMapping$ReventlessInfra.NoDelegate.commandTransition,
+      traits: ExtensionMapping$ReventlessInfra.NoDelegate.traits
     },
     moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
     delegateModuleUrl: delegateModuleUrl,
     mapIncomingEvent: mapIncomingEvent,
-    mapOutgoingEvent: undefined
+    mapOutgoingEvent: undefined,
+    handledEvents: handledEvents,
+    issuedCommands: issuedCommands
   });
   let moduleUrl = import.meta.url;
   let mappings = [ConnectPluginMapping];

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -1,7 +1,6 @@
 @@reventless.spec
 
 open ReventlessInfra.ExtensionPointMapping
-open Reventless.Plugin
 
 module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec