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

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.252 (2026-09-01)
+
+### Bug Fixes
+
+* **api:** [@no](https://github.com/no)Api was lost when a command variant was spliced into another type ([00403fb](https://github.com/ReventlessDev/reventless-core/commit/00403fb4b8873a68a69558829e598339a5012833))
+* **automation:** a mapping is handed the envelope's id ([9ee482c](https://github.com/ReventlessDev/reventless-core/commit/9ee482c5ad0aae09efd1259eeb7f39b781867b91))
+* **capabilities:** a plugin's geocoding need was declared nowhere and failed silently ([67917dd](https://github.com/ReventlessDev/reventless-core/commit/67917dd504b43fa78b7c6a51644c9eae656b7f6b))
+### Features
+
+* **plugin:** refuse two DCB slices that declare one command name ([8c6ec39](https://github.com/ReventlessDev/reventless-core/commit/8c6ec39cb3c6768446f46d0fc6dc04c256e2e9d9))
+* **plugin:** the admin lifecycle commands name their argument ([ea552ec](https://github.com/ReventlessDev/reventless-core/commit/ea552ec64e5db0b3dc465c0d9a80cac89627f727))
+* **spec:** a command declares its lifecycle edge as a value ([40eee9f](https://github.com/ReventlessDev/reventless-core/commit/40eee9f7723dc05e418be680528f01967d074da4))
+* **spec:** a graft leaves a trace the deployed plugin can read ([c08ff6c](https://github.com/ReventlessDev/reventless-core/commit/c08ff6c0f6177d58603e7ae1e5cec392d9bac16a))
+
+
+# 3.0.0-alpha.251 (2026-08-27)
+
+* feat(spec)!: reflect the command direction across a port, both halves ([f2fe258](https://github.com/ReventlessDev/reventless-core/commit/f2fe258d195b74f4a61488edee305665341020ea))
+* feat(spec)!: drop the plugin protocol's reconnect event, which nothing published ([7549db6](https://github.com/ReventlessDev/reventless-core/commit/7549db6aac6ad3f94dbb8d72dac4b4e783756ad1))
+* feat(spec)!: read the port's translation table off the mapping's arms ([956348a](https://github.com/ReventlessDev/reventless-core/commit/956348a9fcb256cfff9db51809bdc27d73360e6c))
+
+### BREAKING CHANGES
+
+* `ExtensionPointMapping.Mapping` gains `acceptedCommands` and
+`ExtensionMapping.Mapping` gains `issuedCommands`; both are derived, so a
+mapping the ppx can read needs no source change, and one it cannot names itself
+at compile time. Definitions persisted before the two new def fields must be
+re-emitted before a consumer can read them as present — and until then they
+decode as None, which means unknown, not "issues nothing".
+* `PluginExtensionPointSpec.event` no longer declares
+`PluginReconnected`. An extension matching on it was matching an event it could
+never receive; drop the arm.
+* `ExtensionPointMapping.Mapping` requires `publishedEvents` and
+`ExtensionMapping.Mapping` requires `handledEvents`; the ppx injects both for
+mappings it can read, so app code must build against the matching ppx. Plugin
+definitions persisted before the new fields must be re-emitted before a consumer
+reads them as present.
+
+
+
 # 3.0.0-alpha.250 (2026-08-23)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.250",
+  "version": "3.0.0-alpha.252",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.33",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.123",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.151"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.153",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.34",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.125"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.73"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.75"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/admin/Platform_Admin_Structure.res

@@ -24,7 +24,7 @@ let commandSchema = PluginSpec.commandSchema->S.castToUnknown
 // Every variant of `PluginSpec.command`, walked by the same `extractCommandDefs`
 // an ordinary aggregate goes through. The hand-written alternative described the
 // arguments with a local `{id}` schema while the generated SDL declared
-// `Platform_Plugin_Activate(_0: String!, id: ID!)`, so AutoUI built a mutation
+// `Platform_Plugin_Activate(id: ID!, version: String!)`, so AutoUI built a mutation
 // missing a required argument and every admin row action was rejected before it
 // reached the aggregate. Deriving from `commandSchema` — the same schema the SDL
 // is generated from — cannot reproduce that class of fault.
@@ -38,6 +38,7 @@ let pluginCommands: array<commandDef> = Plugin_Structure.extractCommandDefs(
   ~mutationFieldFor=variantName =>
     Api_Naming.adminField(~name=PluginSpec.name ++ "_" ++ variantName),
   ~commandAuthorization=PluginSpec.commandAuthorization->Obj.magic,
+  ~commandTransition=PluginSpec.commandTransition->Obj.magic,
   commandSchema,
 )
 
@@ -76,6 +77,8 @@ let structure: pluginStructure = {
   extensionPoints: None,
   requiredStores: None,
   requiredStoreDeclarations: None,
+  requiredCapabilities: None,
+  traitDeclarations: None,
 }
 
 /** The definition the platform's own EventCollector ships as its

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -7,7 +7,7 @@ import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/Plugin
 
 let pluginId = "Platform";
 
-let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandSchema);
+let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, PluginSpec$ReventlessCore.commandSchema);
 
 let pluginAggregate_producedEventTypes = [];
 
@@ -60,7 +60,9 @@ let structure = {
   extensions: structure_extensions,
   extensionPoints: undefined,
   requiredStores: undefined,
-  requiredStoreDeclarations: undefined
+  requiredStoreDeclarations: undefined,
+  requiredCapabilities: undefined,
+  traitDeclarations: undefined
 };
 
 let internalPluginDefinition = {

package/src/admin/Platform_BakedManifest.res.mjs

@@ -134,7 +134,9 @@ function curateStructure(pluginId, def, sel) {
       extensions: def.extensions,
       extensionPoints: def.extensionPoints,
       requiredStores: def.requiredStores,
-      requiredStoreDeclarations: def.requiredStoreDeclarations
+      requiredStoreDeclarations: def.requiredStoreDeclarations,
+      requiredCapabilities: def.requiredCapabilities,
+      traitDeclarations: def.traitDeclarations
     };
   });
 }

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -33,7 +33,11 @@ let sdlTypes: array<string> = [
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
-  `type Platform_ExtensionDef {\n  name: String!\n  delegateNames: [String!]!\n  eventTypes: [String!]!\n  commandTypes: [String!]!\n}`,
+  // The subscriber's half of the port's translation table — see `handledEventDef`.
+  `type Platform_HandledEventDef {\n  name: String!\n  toCommandTypes: [String!]!\n}`,
+  // Its command-direction mirror — see `issuedCommandDef`.
+  `type Platform_IssuedCommandDef {\n  name: String!\n  fromEventTypes: [String!]!\n}`,
+  `type Platform_ExtensionDef {\n  name: String!\n  delegateNames: [String!]!\n  eventTypes: [String!]!\n  commandTypes: [String!]!\n  handledEvents: [Platform_HandledEventDef!]\n  issuedCommands: [Platform_IssuedCommandDef!]\n}`,
   // `internalQueryables` is the complement of the `readModels` / `stateViewSlices`
   // filter, not an addition to either: it carries exactly the components the
   // filter removed. A consumer enumerating surfaces reads the two filtered lists
@@ -208,6 +212,32 @@ let encodeExtensionDef = (e: extensionDef): JSON.t =>
     ("delegateNames", encodeStrings(e.delegateNames)),
     ("eventTypes", encodeStrings(e.eventTypes)),
     ("commandTypes", encodeStrings(e.commandTypes)),
+    (
+      "handledEvents",
+      e.handledEvents->Option.mapOr(JSON.Encode.null, handled =>
+        handled
+        ->Array.map(h =>
+          Dict.fromArray([
+            ("name", JSON.Encode.string(h.name)),
+            ("toCommandTypes", encodeStrings(h.toCommandTypes)),
+          ])->JSON.Encode.object
+        )
+        ->JSON.Encode.array
+      ),
+    ),
+    (
+      "issuedCommands",
+      e.issuedCommands->Option.mapOr(JSON.Encode.null, issued =>
+        issued
+        ->Array.map(i =>
+          Dict.fromArray([
+            ("name", JSON.Encode.string(i.name)),
+            ("fromEventTypes", encodeStrings(i.fromEventTypes)),
+          ])->JSON.Encode.object
+        )
+        ->JSON.Encode.array
+      ),
+    ),
   ])->JSON.Encode.object
 
 // `derived` is curation, not structure: it says which of the pages a shell

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -14,7 +14,9 @@ let sdlTypes = [
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
-  `type Platform_ExtensionDef {\n  name: String!\n  delegateNames: [String!]!\n  eventTypes: [String!]!\n  commandTypes: [String!]!\n}`,
+  `type Platform_HandledEventDef {\n  name: String!\n  toCommandTypes: [String!]!\n}`,
+  `type Platform_IssuedCommandDef {\n  name: String!\n  fromEventTypes: [String!]!\n}`,
+  `type Platform_ExtensionDef {\n  name: String!\n  delegateNames: [String!]!\n  eventTypes: [String!]!\n  commandTypes: [String!]!\n  handledEvents: [Platform_HandledEventDef!]\n  issuedCommands: [Platform_IssuedCommandDef!]\n}`,
   `type Platform_ComponentDefinitionEntry {\n  pluginId: String!\n  readModels: [Platform_ReadSideDef!]!\n  stateViewSlices: [Platform_ReadSideDef!]!\n  internalQueryables: [Platform_ReadSideDef!]!\n  stateChangeSlices: [Platform_WriteSideDef!]!\n  aggregates: [Platform_WriteSideDef!]!\n  automationSlices: [Platform_AutomationSliceDef!]!\n  outboundTranslationSlices: [Platform_OutboundTranslationSliceDef!]!\n  inboundTranslationSlices: [Platform_InboundTranslationSliceDef!]!\n  extensions: [Platform_ExtensionDef!]!\n}`
 ];
 
@@ -347,6 +349,32 @@ function encodeExtensionDef(e) {
     [
       "commandTypes",
       e.commandTypes.map(prim => prim)
+    ],
+    [
+      "handledEvents",
+      Stdlib_Option.mapOr(e.handledEvents, null, handled => handled.map(h => Object.fromEntries([
+        [
+          "name",
+          h.name
+        ],
+        [
+          "toCommandTypes",
+          h.toCommandTypes.map(prim => prim)
+        ]
+      ])))
+    ],
+    [
+      "issuedCommands",
+      Stdlib_Option.mapOr(e.issuedCommands, null, issued => issued.map(i => Object.fromEntries([
+        [
+          "name",
+          i.name
+        ],
+        [
+          "fromEventTypes",
+          i.fromEventTypes.map(prim => prim)
+        ]
+      ])))
     ]
   ]);
 }

package/src/admin/Platform_PluginStructuresApi.res

@@ -28,21 +28,43 @@
 open Reventless.Plugin
 
 let sdlTypes: array<string> = [
+  // The port's translation table — see `publishedEventDef`.
+  `type Platform_PublishedEventDef {\n  name: String!\n  fromEventTypes: [String!]!\n}`,
+  // Its command-direction mirror — see `acceptedCommandDef`.
+  `type Platform_AcceptedCommandDef {\n  name: String!\n  toCommandTypes: [String!]!\n}`,
   // Producer side of an extension point. `commandTypes` is null for a
   // notification-only (`command = unit`) extension point — see `extensionPointDef`.
-  `type Platform_ExtensionPointDef {\n  name: String!\n  delegateNames: [String!]!\n  sourceEventTypes: [String!]!\n  commandTypes: [String!]\n}`,
+  `type Platform_ExtensionPointDef {\n  name: String!\n  delegateNames: [String!]!\n  sourceEventTypes: [String!]!\n  commandTypes: [String!]\n  publishedEvents: [Platform_PublishedEventDef!]\n  acceptedCommands: [Platform_AcceptedCommandDef!]\n}`,
   `type Platform_RequiredStoreDeclaration {\n  store: String!\n  component: String!\n  field: String!\n  annotation: String\n}`,
-  // `extensionPoints` / `requiredStores` / `requiredStoreDeclarations` are nullable
-  // lists, not `[T!]!`: all three are optional on `pluginStructure` so that plugin
-  // definitions persisted before the field existed still decode. A structure written
-  // by an older deploy sends null, and null is the honest answer — an empty list
-  // would claim the plugin has no extension points when the truth is that the
-  // deployment cannot say.
-  `type Platform_PluginStructureEntry {\n  pluginId: String!\n  readModels: [Platform_ReadSideDef!]!\n  stateViewSlices: [Platform_ReadSideDef!]!\n  stateChangeSlices: [Platform_WriteSideDef!]!\n  aggregates: [Platform_WriteSideDef!]!\n  automationSlices: [Platform_AutomationSliceDef!]!\n  outboundTranslationSlices: [Platform_OutboundTranslationSliceDef!]!\n  inboundTranslationSlices: [Platform_InboundTranslationSliceDef!]!\n  extensions: [Platform_ExtensionDef!]!\n  extensionPoints: [Platform_ExtensionPointDef!]\n  requiredStores: [String!]\n  requiredStoreDeclarations: [Platform_RequiredStoreDeclaration!]\n}`,
+  // The capability a component declares its translate reaches for. No `field`:
+  // unlike a store, this need is not expressible as an annotation on one.
+  `type Platform_RequiredCapabilityDeclaration {\n  capability: String!\n  component: String!\n}`,
+  // One graft's provenance. `posture` is a String rather than an enum for the
+  // reason the capability above is: a plugin built against a newer framework,
+  // naming a posture this schema has never heard of, still decodes.
+  //
+  // It records ORIGIN, never behaviour — a grafted file is the host's to edit
+  // afterwards — so a reader must not paint a declared graft as a verified one.
+  `type Platform_TraitDeclaration {\n  trait: String!\n  version: String!\n  posture: String!\n  component: String!\n}`,
+  // `extensionPoints` / `requiredStores` / `requiredStoreDeclarations` /
+  // `requiredCapabilities` / `traitDeclarations` are nullable lists, not `[T!]!`: all five are optional on
+  // `pluginStructure` so that plugin definitions persisted before the field existed
+  // still decode. A structure written by an older deploy sends null, and null is the
+  // honest answer — an empty list would claim the plugin has no extension points when
+  // the truth is that the deployment cannot say.
+  `type Platform_PluginStructureEntry {\n  pluginId: String!\n  readModels: [Platform_ReadSideDef!]!\n  stateViewSlices: [Platform_ReadSideDef!]!\n  stateChangeSlices: [Platform_WriteSideDef!]!\n  aggregates: [Platform_WriteSideDef!]!\n  automationSlices: [Platform_AutomationSliceDef!]!\n  outboundTranslationSlices: [Platform_OutboundTranslationSliceDef!]!\n  inboundTranslationSlices: [Platform_InboundTranslationSliceDef!]!\n  extensions: [Platform_ExtensionDef!]!\n  extensionPoints: [Platform_ExtensionPointDef!]\n  requiredStores: [String!]\n  requiredStoreDeclarations: [Platform_RequiredStoreDeclaration!]\n  requiredCapabilities: [Platform_RequiredCapabilityDeclaration!]\n  traitDeclarations: [Platform_TraitDeclaration!]\n}`,
 ]
 
 let sdlQueryField: string = `  Platform_PluginStructures: [Platform_PluginStructureEntry!]!`
 
+let encodeTraitDeclaration = (d: traitDeclaration): JSON.t =>
+  Dict.fromArray([
+    ("trait", JSON.Encode.string(d.trait)),
+    ("version", JSON.Encode.string(d.version)),
+    ("posture", JSON.Encode.string(d.posture)),
+    ("component", JSON.Encode.string(d.component)),
+  ])->JSON.Encode.object
+
 let encodeExtensionPointDef = (e: extensionPointDef): JSON.t =>
   Dict.fromArray([
     ("name", JSON.Encode.string(e.name)),
@@ -52,6 +74,38 @@ let encodeExtensionPointDef = (e: extensionPointDef): JSON.t =>
       "commandTypes",
       e.commandTypes->Option.mapOr(JSON.Encode.null, Platform_ComponentDefinitionsApi.encodeStrings),
     ),
+    (
+      "publishedEvents",
+      e.publishedEvents->Option.mapOr(JSON.Encode.null, published =>
+        published
+        ->Array.map(p =>
+          Dict.fromArray([
+            ("name", JSON.Encode.string(p.name)),
+            (
+              "fromEventTypes",
+              Platform_ComponentDefinitionsApi.encodeStrings(p.fromEventTypes),
+            ),
+          ])->JSON.Encode.object
+        )
+        ->JSON.Encode.array
+      ),
+    ),
+    (
+      "acceptedCommands",
+      e.acceptedCommands->Option.mapOr(JSON.Encode.null, accepted =>
+        accepted
+        ->Array.map(a =>
+          Dict.fromArray([
+            ("name", JSON.Encode.string(a.name)),
+            (
+              "toCommandTypes",
+              Platform_ComponentDefinitionsApi.encodeStrings(a.toCommandTypes),
+            ),
+          ])->JSON.Encode.object
+        )
+        ->JSON.Encode.array
+      ),
+    ),
   ])->JSON.Encode.object
 
 let encodeRequiredStoreDeclaration = (d: requiredStoreDeclaration): JSON.t =>
@@ -62,6 +116,12 @@ let encodeRequiredStoreDeclaration = (d: requiredStoreDeclaration): JSON.t =>
     ("annotation", d.annotation->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
+let encodeRequiredCapabilityDeclaration = (d: requiredCapabilityDeclaration): JSON.t =>
+  Dict.fromArray([
+    ("capability", JSON.Encode.string(d.capability)),
+    ("component", JSON.Encode.string(d.component)),
+  ])->JSON.Encode.object
+
 // Deliberately NOT filtered by `isPublicQueryable`: that filter is the AutoUI
 // contract, and applying it here would silently drop Internal components from the
 // graph a developer tool draws.
@@ -129,4 +189,16 @@ let encodePluginStructureEntry = (~pluginId: string, def: pluginStructure): JSON
         ds->Array.map(encodeRequiredStoreDeclaration)->JSON.Encode.array
       ),
     ),
+    (
+      "requiredCapabilities",
+      def.requiredCapabilities->Option.mapOr(JSON.Encode.null, ds =>
+        ds->Array.map(encodeRequiredCapabilityDeclaration)->JSON.Encode.array
+      ),
+    ),
+    (
+      "traitDeclarations",
+      def.traitDeclarations->Option.mapOr(JSON.Encode.null, ds =>
+        ds->Array.map(encodeTraitDeclaration)->JSON.Encode.array
+      ),
+    ),
   ])->JSON.Encode.object

package/src/admin/Platform_PluginStructuresApi.res.mjs

@@ -5,11 +5,36 @@ import * as Plugin$ReventlessCore from "../plugin/component/Plugin.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "./Platform_ComponentDefinitionsApi.res.mjs";
 
 let sdlTypes = [
-  `type Platform_ExtensionPointDef {\n  name: String!\n  delegateNames: [String!]!\n  sourceEventTypes: [String!]!\n  commandTypes: [String!]\n}`,
+  `type Platform_PublishedEventDef {\n  name: String!\n  fromEventTypes: [String!]!\n}`,
+  `type Platform_AcceptedCommandDef {\n  name: String!\n  toCommandTypes: [String!]!\n}`,
+  `type Platform_ExtensionPointDef {\n  name: String!\n  delegateNames: [String!]!\n  sourceEventTypes: [String!]!\n  commandTypes: [String!]\n  publishedEvents: [Platform_PublishedEventDef!]\n  acceptedCommands: [Platform_AcceptedCommandDef!]\n}`,
   `type Platform_RequiredStoreDeclaration {\n  store: String!\n  component: String!\n  field: String!\n  annotation: String\n}`,
-  `type Platform_PluginStructureEntry {\n  pluginId: String!\n  readModels: [Platform_ReadSideDef!]!\n  stateViewSlices: [Platform_ReadSideDef!]!\n  stateChangeSlices: [Platform_WriteSideDef!]!\n  aggregates: [Platform_WriteSideDef!]!\n  automationSlices: [Platform_AutomationSliceDef!]!\n  outboundTranslationSlices: [Platform_OutboundTranslationSliceDef!]!\n  inboundTranslationSlices: [Platform_InboundTranslationSliceDef!]!\n  extensions: [Platform_ExtensionDef!]!\n  extensionPoints: [Platform_ExtensionPointDef!]\n  requiredStores: [String!]\n  requiredStoreDeclarations: [Platform_RequiredStoreDeclaration!]\n}`
+  `type Platform_RequiredCapabilityDeclaration {\n  capability: String!\n  component: String!\n}`,
+  `type Platform_TraitDeclaration {\n  trait: String!\n  version: String!\n  posture: String!\n  component: String!\n}`,
+  `type Platform_PluginStructureEntry {\n  pluginId: String!\n  readModels: [Platform_ReadSideDef!]!\n  stateViewSlices: [Platform_ReadSideDef!]!\n  stateChangeSlices: [Platform_WriteSideDef!]!\n  aggregates: [Platform_WriteSideDef!]!\n  automationSlices: [Platform_AutomationSliceDef!]!\n  outboundTranslationSlices: [Platform_OutboundTranslationSliceDef!]!\n  inboundTranslationSlices: [Platform_InboundTranslationSliceDef!]!\n  extensions: [Platform_ExtensionDef!]!\n  extensionPoints: [Platform_ExtensionPointDef!]\n  requiredStores: [String!]\n  requiredStoreDeclarations: [Platform_RequiredStoreDeclaration!]\n  requiredCapabilities: [Platform_RequiredCapabilityDeclaration!]\n  traitDeclarations: [Platform_TraitDeclaration!]\n}`
 ];
 
+function encodeTraitDeclaration(d) {
+  return Object.fromEntries([
+    [
+      "trait",
+      d.trait
+    ],
+    [
+      "version",
+      d.version
+    ],
+    [
+      "posture",
+      d.posture
+    ],
+    [
+      "component",
+      d.component
+    ]
+  ]);
+}
+
 function encodeExtensionPointDef(e) {
   return Object.fromEntries([
     [
@@ -27,6 +52,32 @@ function encodeExtensionPointDef(e) {
     [
       "commandTypes",
       Stdlib_Option.mapOr(e.commandTypes, null, Platform_ComponentDefinitionsApi$ReventlessCore.encodeStrings)
+    ],
+    [
+      "publishedEvents",
+      Stdlib_Option.mapOr(e.publishedEvents, null, published => published.map(p => Object.fromEntries([
+        [
+          "name",
+          p.name
+        ],
+        [
+          "fromEventTypes",
+          Platform_ComponentDefinitionsApi$ReventlessCore.encodeStrings(p.fromEventTypes)
+        ]
+      ])))
+    ],
+    [
+      "acceptedCommands",
+      Stdlib_Option.mapOr(e.acceptedCommands, null, accepted => accepted.map(a => Object.fromEntries([
+        [
+          "name",
+          a.name
+        ],
+        [
+          "toCommandTypes",
+          Platform_ComponentDefinitionsApi$ReventlessCore.encodeStrings(a.toCommandTypes)
+        ]
+      ])))
     ]
   ]);
 }
@@ -52,6 +103,19 @@ function encodeRequiredStoreDeclaration(d) {
   ]);
 }
 
+function encodeRequiredCapabilityDeclaration(d) {
+  return Object.fromEntries([
+    [
+      "capability",
+      d.capability
+    ],
+    [
+      "component",
+      d.component
+    ]
+  ]);
+}
+
 function encodePluginStructureEntry(pluginId, def) {
   return Object.fromEntries([
     [
@@ -101,6 +165,14 @@ function encodePluginStructureEntry(pluginId, def) {
     [
       "requiredStoreDeclarations",
       Stdlib_Option.mapOr(def.requiredStoreDeclarations, null, ds => ds.map(encodeRequiredStoreDeclaration))
+    ],
+    [
+      "requiredCapabilities",
+      Stdlib_Option.mapOr(def.requiredCapabilities, null, ds => ds.map(encodeRequiredCapabilityDeclaration))
+    ],
+    [
+      "traitDeclarations",
+      Stdlib_Option.mapOr(def.traitDeclarations, null, ds => ds.map(encodeTraitDeclaration))
     ]
   ]);
 }
@@ -110,8 +182,10 @@ let sdlQueryField = `  Platform_PluginStructures: [Platform_PluginStructureEntry
 export {
   sdlTypes,
   sdlQueryField,
+  encodeTraitDeclaration,
   encodeExtensionPointDef,
   encodeRequiredStoreDeclaration,
+  encodeRequiredCapabilityDeclaration,
   encodePluginStructureEntry,
 }
 /* No side effect */

package/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs

@@ -46,6 +46,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "UiFragmentRegistry";
 
 let Id;
@@ -66,5 +72,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* commandSchema Not a pure module */

package/src/components/Api/ApiNoApiHelpers.res

@@ -3,11 +3,45 @@ open ReventlessInfra.Api
 let isNoApi = (commandSchema: S.t<unknown>): bool =>
   commandSchema->S.Metadata.get(~id=noApiId)->Option.getOr(false)
 
-let getExcludedVariants = (commandSchema: S.t<unknown>): option<Set.t<string>> =>
-  commandSchema->S.Metadata.get(~id=noApiVariantsId)
+// Variants excluded by a mark on the member itself. This is the half that
+// survives a spread: splicing copies members, not the metadata of the union they
+// came from, so a command a trait marked internal is only still recognisable here.
+let excludedByMembers = (commandSchema: S.t<unknown>): array<string> =>
+  switch commandSchema {
+  | AnyOf({anyOf}) =>
+    anyOf->Array.filterMap(member =>
+      member->S.Metadata.get(~id=noApiVariantId)->Option.getOr(false)
+        ? variantNameOf(member)
+        : None
+    )
+  | _ => []
+  }
+
+/**
+Every variant excluded from the API, from both records of the fact.
+
+The union's own set covers variants the schema's author declared; the members'
+marks cover variants spliced in from another type, whose author's declaration is
+in a file this one never mentions. A reader that consulted only the first
+published someone else's internal commands.
+
+`None` still means "nothing is excluded", so a caller's existing branch is
+unchanged.
+*/
+let getExcludedVariants = (commandSchema: S.t<unknown>): option<Set.t<string>> => {
+  let fromMembers = excludedByMembers(commandSchema)
+  switch (commandSchema->S.Metadata.get(~id=noApiVariantsId), fromMembers) {
+  | (None, []) => None
+  | (None, members) => Some(Set.fromArray(members))
+  | (Some(declared), []) => Some(declared)
+  | (Some(declared), members) =>
+    let all = declared->Set.toArray->Array.concat(members)
+    Some(Set.fromArray(all))
+  }
+}
 
 let filterNoApiVariants = (fieldNames: array<string>, commandSchema: S.t<unknown>): array<string> =>
-  switch commandSchema->S.Metadata.get(~id=noApiVariantsId) {
+  switch getExcludedVariants(commandSchema) {
   | None => fieldNames
   | Some(excluded) => fieldNames->Array.filter(name => !(excluded->Set.has(name)))
   }

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

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 
@@ -8,12 +9,37 @@ function isNoApi(commandSchema) {
   return Stdlib_Option.getOr(Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiId), false);
 }
 
+function excludedByMembers(commandSchema) {
+  if (commandSchema.type === "anyOf") {
+    return Stdlib_Array.filterMap(commandSchema.anyOf, member => {
+      if (Stdlib_Option.getOr(Sury.$Metadata_get(member, Api$ReventlessInfra.noApiVariantId), false)) {
+        return Api$ReventlessInfra.variantNameOf(member);
+      }
+    });
+  } else {
+    return [];
+  }
+}
+
 function getExcludedVariants(commandSchema) {
-  return Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+  let fromMembers = excludedByMembers(commandSchema);
+  let match = Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+  if (match === undefined) {
+    if (fromMembers.length !== 0) {
+      return new Set(fromMembers);
+    } else {
+      return;
+    }
+  }
+  if (fromMembers.length === 0) {
+    return match;
+  }
+  let all = Array.from(match).concat(fromMembers);
+  return new Set(all);
 }
 
 function filterNoApiVariants(fieldNames, commandSchema) {
-  let excluded = Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+  let excluded = getExcludedVariants(commandSchema);
   if (excluded !== undefined) {
     return fieldNames.filter(name => !excluded.has(name));
   } else {
@@ -23,6 +49,7 @@ function filterNoApiVariants(fieldNames, commandSchema) {
 
 export {
   isNoApi,
+  excludedByMembers,
   getExcludedVariants,
   filterNoApiVariants,
 }

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -169,19 +169,19 @@ module Make = (
   // Per-source erased dispatch — pre-compile decoders once at module init.
   type dispatch = {
     sourceName: string,
-    handle: (JSON.t, Reventless.AutomationSlice.context) => unit,
+    handle: (JSON.t, ~sourceId: string, Reventless.AutomationSlice.context) => unit,
   }
 
   let dispatches: array<dispatch> = Automation.mappings->Array.map((
     module(M: Automation.Mapping),
   ) => {
     let decoder = Reventless.DcbDecode.makeDecoder(M.sourceEventSchema)
-    let handle = (json: JSON.t, ctx: Reventless.AutomationSlice.context) => {
+    let handle = (json: JSON.t, ~sourceId: string, ctx: Reventless.AutomationSlice.context) => {
       let (eventType, dataDict) = json->Message.splitMessage
       switch decoder.decode(~eventType, ~data=dataDict) {
       | Some(event) =>
         // Collect — append new items keyed by ID; first writer wins (idempotent).
-        M.collect(event, ctx)->Array.forEach(((id, item)) => {
+        M.collect(event, ~sourceId, ctx)->Array.forEach(((id, item)) => {
           switch todoItems->Dict.get(id) {
           | Some(_) => () // Already exists — skip
           | None =>
@@ -225,7 +225,7 @@ module Make = (
       // Multiple mappings can share a sourceName; all matching dispatches run.
       dispatches->Array.forEach(d => {
         if d.sourceName == sourceName {
-          d.handle(eventPayload, ctx)
+          d.handle(eventPayload, ~sourceId=context.id, ctx)
         }
       })
     })

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -57,14 +57,14 @@ function Make(Spec) {
     };
     let dispatches = Automation.mappings.map(M => {
       let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
-      let handle = (json, ctx) => {
+      let handle = (json, sourceId, ctx) => {
         let match = Message$ReventlessCore.splitMessage(json);
         let event = decoder.decode(match[0], match[1]);
         if (event === undefined) {
           return;
         }
         let event$1 = Primitive_option.valFromOption(event);
-        M.collect(event$1, ctx).forEach(param => {
+        M.collect(event$1, sourceId, ctx).forEach(param => {
           let id = param[0];
           let match = todoItems[id];
           if (match !== undefined) {
@@ -105,7 +105,7 @@ function Make(Spec) {
         let eventPayload = dict !== undefined ? Stdlib_Option.getOr(dict["event"], json) : json;
         dispatches.forEach(d => {
           if (d.sourceName === sourceName) {
-            return d.handle(eventPayload, ctx);
+            return d.handle(eventPayload, context.id, ctx);
           }
         });
       });