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

package/src/plugin/component/Plugin_Structure.res

@@ -373,12 +373,18 @@ let reportTranslationTables = (
   }
 }
 
-// `@transition` names states belonging to another component's enum, which the PPX
-// only ever sees as names — so a misspelling compiles clean and produces a command
-// legal in a state no row is in. Both sides are in hand here. A state the linked
-// views do not declare raises (this runs at assembly, never in a Lambda, so that is
-// a failed deploy); no resolvable view only warns. Checked against the UNION of the
-// linked views: a slice feeding two is not claiming which one.
+// A command's declared edge names states belonging to another component's enum.
+// From `@transition` the PPX only ever sees names, so a misspelling compiles clean
+// and produces a command legal in a state no row is in. Both sides are in hand
+// here. A state the linked views do not declare raises (this runs at assembly,
+// never in a Lambda, so that is a failed deploy); no resolvable view only warns.
+// Checked against the UNION of the linked views: a slice feeding two is not
+// claiming which one.
+//
+// A `commandTransition` switch comes through the same `commandDef` fields and is
+// checked the same way. The compiler has already resolved its constructors, so
+// what survives to here is naming the wrong enum rather than misspelling one —
+// which this catches for the same reason and with the same message.
 let checkDeclaredTransitions = (
   ~pluginName: string,
   ~writables: array<Reventless.Plugin.writableDef>,
@@ -412,7 +418,7 @@ let checkDeclaredTransitions = (
           ->Array.forEach(state =>
             failures
             ->Array.push(
-              `${w.name}.${cmd.name}: @transition names "${state}", which none of its ` ++
+              `${w.name}.${cmd.name} declares state "${state}", which none of its ` ++
               `linked views declare — ${w.linkedViews->Array.join(
                   ", ",
                 )} know ${known->Array.join(", ")}.`,
@@ -430,14 +436,14 @@ let checkDeclaredTransitions = (
   if unvalidated.contents > 0 {
     log.warn(
       ~comp="Plugin_Structure",
-      `${pluginName}: ${unvalidated.contents->Int.toString} command(s) declare a @transition ` ++
+      `${pluginName}: ${unvalidated.contents->Int.toString} command(s) declare a transition ` ++
       `but no linked view declares a lifecycle to check it against.`,
     )
   }
 
   if Array.length(failures) > 0 {
     JsError.throwWithMessage(
-      `${pluginName}: @transition names states that do not exist.\n` ++
+      `${pluginName}: a declared transition names states that do not exist.\n` ++
       failures->Array.join("\n"),
     )
   }
@@ -707,6 +713,18 @@ let toCommandDef = (
   // one aggregate carries commands with very different audiences, and a
   // component-level shortcut would gate `AddProduct` and `PlaceOrder` alike.
   ~commandAuthorization: unknown => Reventless.Authorization.permission,
+  // The spec's `command => Transition.t<_>`, evaluated per variant the same way
+  // `commandAuthorization` is. It wins over the `@transition` metadata where it
+  // declares an edge, and stands aside where it says `Unrestricted` — which is
+  // what the PPX injects for a spec that never wrote the switch.
+  //
+  // Read at `t<string>` because this is the erasure boundary: the spec declares
+  // its edges over the linked view's own lifecycle enum, whose arms are
+  // payload-less and therefore ARE their own names at run time. The one cast
+  // that says so is the same `->Obj.magic` every spec member arrives through
+  // (see the call sites below), so `Transition` itself asserts nothing about
+  // representation and stays parameterised all the way down.
+  ~commandTransition: unknown => Reventless.Transition.t<string>,
   v: S.t<unknown>,
 ): option<Reventless.Plugin.commandDef> => {
   // Build a commandDef for one variant. `properties` is the variant's field dict —
@@ -715,12 +733,41 @@ let toCommandDef = (
   let mkDef = (~variantName, ~properties) => {
     let (level, aggregateIdField) = commandLevelAndId(~isAggregate, ~variantName, properties)
     let references = extractReferences(properties)
-    // Per-variant, but attached by the PPX to the *parent* schema as one dict.
-    let allowedStates = ApiAllowedStatesHelpers.getAllowedStates(parentSchema, ~variantName)
-    // The `@transition` target (the command's *to* status), read the same way
-    // as allowedStates. None ⇒ AutoUI's board resolver falls back to its
-    // name-stem heuristic.
-    let targetState = ApiTargetStateHelpers.getTargetState(parentSchema, ~variantName)
+    // Evaluated against a synthetic value per constructor, the same shape the
+    // resolver builds at call time: a payload-bearing variant compiles to
+    // `{TAG, ...}`, a payload-less one to a bare string.
+    let syntheticCommand: unknown =
+      Reventless.DcbTag.isVariantPayloadBearing(parentSchema, variantName)
+        ? {"TAG": variantName}->Obj.magic
+        : variantName->Obj.magic
+    // The spec's own switch, which is the only form that can speak for a
+    // constructor the host did not declare: `@transition` lowers to a dict on
+    // the parent union, and a variant spread splices members, so a spliced
+    // command reaches the metadata below carrying nothing.
+    let declared = commandTransition(syntheticCommand)
+    // An edge is ONE declaration, so the two fields are chosen together. Taking
+    // them separately would let `Guards(…)` — which positively claims the
+    // command moves the row nowhere — inherit a target from an annotation it
+    // was written to replace.
+    //
+    // The `@transition` metadata is per-variant but attached by the PPX to the
+    // *parent* schema as one dict. It is consulted only where the switch
+    // declares no edge at all: a spec that never wrote one answers
+    // `Unrestricted` for every command, which is how the annotation stays in
+    // charge for the hosts that still use it.
+    //
+    // `targetState: None` ⇒ AutoUI's board resolver falls back to its name-stem
+    // heuristic.
+    let (allowedStates, targetState) = switch declared {
+    | Unrestricted => (
+        ApiAllowedStatesHelpers.getAllowedStates(parentSchema, ~variantName),
+        ApiTargetStateHelpers.getTargetState(parentSchema, ~variantName),
+      )
+    | _ => (
+        Reventless.Transition.allowedStates(declared),
+        Reventless.Transition.targetState(declared),
+      )
+    }
     // API-exposed iff the whole command isn't @noApi and this variant
     // isn't in its @noApi-variants set — mirrors the API-generation filter
     // (Plugin_Helpers / PluginBaseFragment). Drives the event-graph API badge.
@@ -730,13 +777,6 @@ let toCommandDef = (
       | Some(excluded) => !(excluded->Set.has(variantName))
       | None => true
       }
-    // Evaluated against a synthetic value per constructor, the same shape the
-    // resolver builds at call time: a payload-bearing variant compiles to
-    // `{TAG, ...}`, a payload-less one to a bare string.
-    let syntheticCommand: unknown =
-      Reventless.DcbTag.isVariantPayloadBearing(parentSchema, variantName)
-        ? {"TAG": variantName}->Obj.magic
-        : variantName->Obj.magic
     let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand))
     // See the note on the record's `mutationField` for why a non-exposed
     // variant gets the empty sentinel. It has no callable field, and the
@@ -796,6 +836,7 @@ let extractCommandDefs = (
   ~isAggregate,
   ~mutationFieldFor: string => string,
   ~commandAuthorization: unknown => Reventless.Authorization.permission,
+  ~commandTransition: unknown => Reventless.Transition.t<string>,
   commandSchema: S.t<unknown>,
 ): array<Reventless.Plugin.commandDef> =>
   switch commandSchema {
@@ -806,6 +847,7 @@ let extractCommandDefs = (
         ~mutationFieldFor,
         ~parentSchema=commandSchema,
         ~commandAuthorization,
+        ~commandTransition,
         v,
       )
     )
@@ -816,6 +858,7 @@ let extractCommandDefs = (
       ~mutationFieldFor,
       ~parentSchema=commandSchema,
       ~commandAuthorization,
+      ~commandTransition,
       commandSchema,
     )->Option.mapOr([], def => [def])
   }
@@ -1061,6 +1104,49 @@ let make = (
     }
   }
 
+  // ── One command name, one handler ──────────────────────────────────────────
+  //
+  // A DCB plugin routes a command by its bare type name: the runtime builds
+  // `handlersByType[typeName]` across every StateChangeSlice in the plugin and
+  // dispatches on the incoming command's TAG alone. Two slices declaring one name
+  // therefore have one handler between them — the second registration overwrites
+  // the first, and the plugin deploys.
+  //
+  // Refused here rather than logged there. The runtime notices only when it goes
+  // to stamp owner fields, by which point the deploy has succeeded and the losing
+  // slice is silently unreachable; a name is a compile-time fact and this is the
+  // last place that can see all of them at once.
+  //
+  // Aggregates are exempt and are not checked: their commands are addressed per
+  // component channel, so two aggregates sharing a command name is ordinary.
+  let dcbCommandOwners: dict<array<string>> = Dict.make()
+  stateChangeSlices->Array.forEach((module(SCS: ReventlessInfra.StateChangeSlice.T)) =>
+    Reventless.DcbTag.extractAllVariantNames(
+      SCS.Spec.commandSchema->S.castToUnknown,
+    )->Array.forEach(cmd => {
+      let owners = dcbCommandOwners->Dict.get(cmd)->Option.getOr([])
+      dcbCommandOwners->Dict.set(cmd, Array.concat(owners, [SCS.Spec.name]))
+    })
+  )
+  let clashes =
+    dcbCommandOwners
+    ->Dict.toArray
+    ->Array.filter(((_, owners)) => owners->Array.length > 1)
+    ->Array.toSorted((((a, _)), ((b, _))) => String.compare(a, b))
+  if clashes->Array.length > 0 {
+    JsError.throwWithMessage(
+      `${name}: ` ++
+      clashes
+      ->Array.map((((cmd, owners))) =>
+        `${owners->Array.join(" and ")} both declare the command "${cmd}"`
+      )
+      ->Array.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.`,
+    )
+  }
+
   // One list feeds both the store collection and the lint below, so a field is
   // read exactly once by either.
   let storeDeclarationSites: array<(string, S.t<unknown>)> =
@@ -1118,6 +1204,69 @@ let make = (
     )
   }
 
+  // Capabilities a slice declares its `translate` reaches for. Sorted and
+  // deduplicated for the same reason the store declarations are: the manifest is
+  // committed, so it must not churn on a re-build. Only outbound translation
+  // slices are handed `Capabilities.t`, so only they can declare.
+  let requiredCapabilities =
+    outboundTranslationSlices
+    ->Array.flatMap((module(OTS: ReventlessInfra.OutboundTranslationSlice.T)) =>
+      OTS.Spec.capabilityNeeds->Array.map(need => (
+        {
+          Reventless.Plugin.capability: Reventless.CapabilityNeed.toString(need),
+          component: OTS.Spec.name,
+        }: Reventless.Plugin.requiredCapabilityDeclaration
+      ))
+    )
+    ->Array.toSorted((a, b) =>
+      a.capability == b.capability
+        ? String.compare(a.component, b.component)
+        : String.compare(a.capability, b.capability)
+    )
+    ->Array.reduce([], (acc, d) =>
+      switch acc->Array.last {
+      | Some(prev) if prev == d => acc
+      | _ => acc->Array.concat([d])
+      }
+    )
+
+  // The traits grafted into this plugin, one entry per declaring component. The
+  // component name is added here rather than declared: a trait cannot know which
+  // component a host grafted it onto, and a host writing it down would be the one
+  // hand-typed string this whole mechanism exists to avoid. Sorted and
+  // deduplicated for the same reason the two declarations above are.
+  let traitDeclarations = {
+    let entry = (~component, decl: Reventless.Trait.t) => (
+      {
+        Reventless.Plugin.trait: decl.trait,
+        version: decl.version,
+        posture: Reventless.Trait.postureToString(decl.posture),
+        component,
+      }: Reventless.Plugin.traitDeclaration
+    )
+    [
+      aggregates->Array.flatMap((module(A: ReventlessInfra.Aggregate.T with type api = api)) =>
+        A.Spec.traits->Array.map(entry(~component=A.Spec.name, ...))
+      ),
+      stateChangeSlices->Array.flatMap((module(SCS: ReventlessInfra.StateChangeSlice.T)) =>
+        SCS.Spec.traits->Array.map(entry(~component=SCS.Spec.name, ...))
+      ),
+      outboundTranslationSlices->Array.flatMap((
+        module(OTS: ReventlessInfra.OutboundTranslationSlice.T),
+      ) => OTS.Spec.traits->Array.map(entry(~component=OTS.Spec.name, ...))),
+    ]
+    ->Array.flat
+    ->Array.toSorted((a, b) =>
+      a.trait == b.trait ? String.compare(a.component, b.component) : String.compare(a.trait, b.trait)
+    )
+    ->Array.reduce([], (acc, d) =>
+      switch acc->Array.last {
+      | Some(prev) if prev == d => acc
+      | _ => acc->Array.concat([d])
+      }
+    )
+  }
+
   // Heuristic-only matches — a field *named* like a stored-object ref with no
   // `@storageRef` — warn and provision nothing. Declaration outranks inference;
   // the warning names the annotation that would settle it.
@@ -1252,6 +1401,7 @@ let make = (
               ~variant=variantName,
             ),
           ~commandAuthorization=SCS.Spec.commandAuthorization->Obj.magic,
+          ~commandTransition=SCS.Spec.commandTransition->Obj.magic,
           SCS.Spec.commandSchema->S.castToUnknown,
         ),
         producedEventTypes: produced,
@@ -1276,6 +1426,7 @@ let make = (
           ~isAggregate=true,
           ~mutationFieldFor=variantName => Api_Naming.aggregateMutationField(~plugin=name, ~aggregate=A.Spec.name, ~command=variantName),
           ~commandAuthorization=A.Spec.commandAuthorization->Obj.magic,
+          ~commandTransition=A.Spec.commandTransition->Obj.magic,
           A.Spec.commandSchema->S.castToUnknown,
         ),
         producedEventTypes: produced,
@@ -1747,5 +1898,7 @@ let make = (
     extensionPoints: Some(extensionPointDefs),
     requiredStores: Some(requiredStores),
     requiredStoreDeclarations: Some(requiredStoreDeclarations),
+    traitDeclarations: Some(traitDeclarations),
+    requiredCapabilities: Some(requiredCapabilities),
   }
 }

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

@@ -9,14 +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";
@@ -343,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"));
   }
 }
 
@@ -591,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);
@@ -616,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]
@@ -647,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]);
   }
 }
 
@@ -791,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 => [
       [
@@ -874,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)));
   });
@@ -968,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),
@@ -983,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)),
@@ -1268,7 +1338,9 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     extensions: extensionDefs,
     extensionPoints: extensionPointDefs,
     requiredStores: requiredStores,
-    requiredStoreDeclarations: requiredStoreDeclarations
+    requiredStoreDeclarations: requiredStoreDeclarations,
+    requiredCapabilities: requiredCapabilities,
+    traitDeclarations: traitDeclarations
   };
 }
 

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

@@ -75,7 +75,9 @@ 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,

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

@@ -405,7 +405,9 @@ function Make(Spec) {
       errorSchema: PluginSpec$ReventlessCore.errorSchema,
       commandSchema: PluginSpec$ReventlessCore.commandSchema,
       moduleUrl: PluginSpec$ReventlessCore.moduleUrl,
-      commandAuthorization: PluginSpec$ReventlessCore.commandAuthorization
+      commandAuthorization: PluginSpec$ReventlessCore.commandAuthorization,
+      commandTransition: PluginSpec$ReventlessCore.commandTransition,
+      traits: PluginSpec$ReventlessCore.traits
     },
     moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
     mapIncomingCommand: mapIncomingCommand,

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

@@ -72,7 +72,9 @@ let Mapping = ExtensionPointMapping$ReventlessInfra.Make({
     errorSchema: UiFragmentRegistry$ReventlessCore.errorSchema,
     commandSchema: UiFragmentRegistry$ReventlessCore.commandSchema,
     moduleUrl: UiFragmentRegistry$ReventlessCore.moduleUrl,
-    commandAuthorization: UiFragmentRegistry$ReventlessCore.commandAuthorization
+    commandAuthorization: UiFragmentRegistry$ReventlessCore.commandAuthorization,
+    commandTransition: UiFragmentRegistry$ReventlessCore.commandTransition,
+    traits: UiFragmentRegistry$ReventlessCore.traits
   },
   moduleUrl: moduleUrl,
   mapIncomingCommand: mapIncomingCommand,

package/src/plugin/lifecycle/PluginBehavior.res

@@ -159,19 +159,19 @@ let decide = (state, command) =>
       Ok(Array.concat([VersionDisconnected(definition)], promoteEvents(state, v)))
     | _ => Ok([]) // not connected / unknown → tolerate stray disconnect
     }
-  | Activate(v) =>
-    switch state.known->Dict.get(v) {
+  | Activate({version}) =>
+    switch state.known->Dict.get(version) {
     | Some({status: Inactive | Retired, definition}) =>
       let base = [VersionActivated(definition)]
-      let supersede = if currentAfterConnect(state.known, v) == v {
+      let supersede = if currentAfterConnect(state.known, version) == version {
         switch state.current {
-        | Some(c) if c != v =>
+        | Some(c) if c != version =>
           switch state.known->Dict.get(c) {
           | Some({definition: defC}) => [
               VersionSuperseded({
                 supersededVersion: c,
                 supersededDefinition: defC,
-                newVersion: v,
+                newVersion: version,
                 newDefinition: definition,
               }),
             ]
@@ -187,18 +187,18 @@ let decide = (state, command) =>
     | Some({status: Disconnected}) => Error(IsDisconnected)
     | None => Error(UnknownVersion)
     }
-  | Deactivate(v) =>
-    switch state.known->Dict.get(v) {
+  | Deactivate({version}) =>
+    switch state.known->Dict.get(version) {
     | Some({status: Connected | Disconnected, definition}) =>
-      Ok(Array.concat([VersionDeactivated(definition)], promoteEvents(state, v)))
+      Ok(Array.concat([VersionDeactivated(definition)], promoteEvents(state, version)))
     | Some({status: Inactive | Retired}) => Ok([]) // idempotent / archived no-op
     | None => Error(UnknownVersion)
     }
-  | Retire(v) =>
-    switch state.known->Dict.get(v) {
+  | Retire({version}) =>
+    switch state.known->Dict.get(version) {
     | Some({status: Retired}) => Ok([]) // idempotent
     | Some({definition}) =>
-      Ok(Array.concat([VersionRetired(definition)], promoteEvents(state, v)))
+      Ok(Array.concat([VersionRetired(definition)], promoteEvents(state, version)))
     | None => Error(UnknownVersion)
     }
   | ReportIncompatibility(def) => Ok([IncompatiblePluginDetected(def)])

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

@@ -232,8 +232,8 @@ function decide(state, command) {
         };
       }
     case "Activate" :
-      let v$4 = command._0;
-      let match$4 = state.known[v$4];
+      let version = command.version;
+      let match$4 = state.known[version];
       if (match$4 === undefined) {
         return {
           TAG: "Error",
@@ -261,17 +261,17 @@ function decide(state, command) {
           _0: definition
         }];
       let supersede;
-      if (currentAfterConnect(state.known, v$4) === v$4) {
+      if (currentAfterConnect(state.known, version) === version) {
         let c = state.current;
         if (c !== undefined) {
-          if (c !== v$4) {
+          if (c !== version) {
             let match$5 = state.known[c];
             supersede = match$5 !== undefined ? [{
                   TAG: "VersionSuperseded",
                   _0: {
                     supersededVersion: c,
                     supersededDefinition: match$5.definition,
-                    newVersion: v$4,
+                    newVersion: version,
                     newDefinition: definition
                   }
                 }] : [];
@@ -290,8 +290,8 @@ function decide(state, command) {
       };
       break;
     case "Deactivate" :
-      let v$5 = command._0;
-      let match$6 = state.known[v$5];
+      let version$1 = command.version;
+      let match$6 = state.known[version$1];
       if (match$6 === undefined) {
         return {
           TAG: "Error",
@@ -314,12 +314,12 @@ function decide(state, command) {
         _0: [{
             TAG: "VersionDeactivated",
             _0: match$6.definition
-          }].concat(promoteEvents(state, v$5))
+          }].concat(promoteEvents(state, version$1))
       };
       break;
     case "Retire" :
-      let v$6 = command._0;
-      let match$7 = state.known[v$6];
+      let version$2 = command.version;
+      let match$7 = state.known[version$2];
       if (match$7 !== undefined) {
         if (match$7.status === "Retired") {
           return {
@@ -332,7 +332,7 @@ function decide(state, command) {
             _0: [{
                 TAG: "VersionRetired",
                 _0: match$7.definition
-              }].concat(promoteEvents(state, v$6))
+              }].concat(promoteEvents(state, version$2))
           };
         }
       } else {