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

package/tests/plugin/PluginStructureTest.res

@@ -185,6 +185,19 @@ module PsDispatchShipmentSlice: ReventlessInfra.StateChangeSlice.T = {
   type component = scsComponent
   let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
 }
+module PsTransitionSwitchSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsTransitionSwitch
+  module Behavior = {
+    type state = PsTransitionSwitch.state
+    let initialState = PsTransitionSwitch.initialState
+    let evolve = PsTransitionSwitch.evolve
+    let decide = PsTransitionSwitch.decide
+    let moduleUrl = PsTransitionSwitch.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
+}
 module PsShipmentsViewSlice: ReventlessInfra.StateViewSlice.T = {
   module Spec = PsShipmentsView
   module Projection = {
@@ -290,12 +303,89 @@ describe("lifecycle topology", () => {
   })
 })
 
-describe("@transition cross-check", () => {
+describe("commandTransition — the edge as a switch", () => {
+  // The seam a variant spread needs. The removed attribute lowered to a dict on
+  // the parent union keyed by variant name, and a spread splices members, so a
+  // command a host did not declare could not be annotated at all. A switch over
+  // the command reaches every constructor, spliced or not, and the compiler
+  // makes it exhaustive.
+  let structure = Plugin_Structure.make(
+    ~name="TransitionSwitchPlugin",
+    ~stateChangeSlices=[module(PsTransitionSwitchSlice)],
+    ~stateViewSlices=[],
+  )
+  let slice = structure.stateChangeSlices->Array.getUnsafe(0)
+  let byName = name => slice.commands->Array.find(c => c.name == name)
+
+  testSync("the switch fills allowedStates and targetState", () => {
+    expect((
+      byName("Book")->Option.flatMap(c => c.allowedStates),
+      byName("Book")->Option.flatMap(c => c.targetState),
+    ))->toEqual((Some(["Draft"]), Some("Booked")))
+  })
+
+  testSync("a guard declares its from-set and no target", () => {
+    // A positive claim rather than an omission: legal in these states, and it
+    // moves the row nowhere. Distinguishable on the wire from both fields being
+    // None, and consumers are expected to honour it.
+    expect((
+      byName("Rebook")->Option.flatMap(c => c.allowedStates),
+      byName("Rebook")->Option.flatMap(c => c.targetState),
+    ))->toEqual((Some(["Booked"]), None))
+  })
+
+  testSync("Unrestricted declares nothing, leaving the command unconstrained", () => {
+    // Distinct from a from-set naming every state, which says the same thing to
+    // a menu and something different to a reader.
+    expect((
+      byName("Abandon")->Option.flatMap(c => c.allowedStates),
+      byName("Abandon")->Option.flatMap(c => c.targetState),
+    ))->toEqual((None, None))
+  })
+})
+
+describe("traitDeclarations — a graft leaves a trace", () => {
+  // The one signal a graft leaves that survives into a deployed plugin. Every
+  // other one — the package dependency, the variant spread, the rules alias, the
+  // conformance binding — is source-side and invisible to a running estate.
+  let structure = Plugin_Structure.make(
+    ~name="TraitPlugin",
+    ~stateChangeSlices=[module(PsTransitionSwitchSlice), module(PsShipOrderSlice)],
+    ~stateViewSlices=[],
+  )
+
+  testSync("a declaring component's trait reaches the structure", () => {
+    expect(
+      structure.traitDeclarations->Option.getOr([])->Array.map(d => (d.trait, d.component)),
+    )->toEqual([("@reventlessdev/trait-booking", "TransitionSwitch")])
+  })
+
+  testSync("the component name is filled in by the structure, not declared", () => {
+    // The trait exports its identity and posture; it cannot know which component a
+    // host grafted it onto, and a host writing that name down would be the one
+    // hand-typed string this mechanism exists to avoid.
+    expect(
+      structure.traitDeclarations
+      ->Option.getOr([])
+      ->Array.map(d => (d.version, d.posture, d.component)),
+    )->toEqual([("9.9.9", "SelfContained", "TransitionSwitch")])
+  })
+
+  testSync("a component that is nobody's graft contributes nothing", () => {
+    // `PsShipOrder` declares no traits, and the injected default is empty — so the
+    // absence of a graft is silence rather than a row.
+    expect(structure.traitDeclarations->Option.getOr([])->Array.length)->toBe(1)
+  })
+})
+
+describe("declared-edge cross-check", () => {
   // The exit criterion: a state no linked view declares stops the build, and the
   // message says which command, which state, and what it was checked against.
   // `DispatchShipment` produces `ShipmentDispatched`, which the `Shipments` view
   // consumes — so the two are linked, the view's lifecycle is in hand, and
-  // "Dispatchd" has somewhere to be wrong.
+  // "Dispatchd" has somewhere to be wrong. It compiles because the switch names
+  // the slice's OWN enum: the typechecker cannot see that the wrong lifecycle
+  // was picked, and this is the check that can.
   let buildBad = () =>
     try {
       Plugin_Structure.make(
@@ -410,11 +500,10 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ))->toEqual((Some(true), Some(false)))
     })
 
-    testSync("ShipOrder: @transition's target flows through the PPX to commandDef.targetState", () => {
-      // End-to-end: the reventless-ppx @transition annotation → markTargetState
-      // metadata → ApiTargetStateHelpers.getTargetState → commandDef. The
-      // un-annotated CancelShipment carries None (resolver falls back to
-      // name-stem).
+    testSync("ShipOrder: the switch's target flows through to commandDef.targetState", () => {
+      // End-to-end: the spec's `commandTransition`, evaluated per constructor
+      // against a synthetic command → commandDef. `CancelShipment` answers
+      // `Unrestricted` and carries None (resolver falls back to name-stem).
       let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
       let byName = name => shipOrder.commands->Array.find(c => c.name == name)
       expect((
@@ -423,10 +512,10 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ))->toEqual((Some("Shipped"), None))
     })
 
-    testSync("ShipOrder: @transition's from-set flows through to commandDef.allowedStates", () => {
-      // The other half of the same annotation, which the removed pair spelled
-      // separately: one attribute now fills both fields, so a command that
-      // declares a target cannot end up without the states it may run from.
+    testSync("ShipOrder: the switch's from-set flows through to commandDef.allowedStates", () => {
+      // The other half of the same declaration. An edge is one value, so a
+      // command that declares a target cannot end up without the states it may
+      // run from — the two fields are read off it together.
       let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
       let byName = name => shipOrder.commands->Array.find(c => c.name == name)
       expect((
@@ -1366,6 +1455,45 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         expect(Reventless.CapabilityManifest.fromStructure(structure).capabilities)->toEqual([])
       )
 
+      // A capability a slice declares rides the same manifest as the stores, so
+      // the platform generator reads one file. It carries no `field`: nothing
+      // annotated it, and naming one would be a fiction.
+      describe("declared capabilities", () => {
+        let withCapability = {
+          ...structure,
+          requiredCapabilities: Some([
+            ({capability: "Geocoding", component: "GeocodeAddress"}: Reventless.Plugin.requiredCapabilityDeclaration),
+            {capability: "Geocoding", component: "GeocodeDropOff"},
+          ]),
+          traitDeclarations: None,
+        }
+        let entries = Reventless.CapabilityManifest.fromStructure(withCapability).capabilities
+
+        testSync("two components needing one capability yield one entry", () =>
+          expect(entries->Array.map(e => e.key))->toEqual(["Geocoding"])
+        )
+
+        testSync("both declaring components are kept, with no field", () =>
+          expect((entries->Array.getUnsafe(0)).declaredBy)->toEqual([
+            ({component: "GeocodeAddress"}: Reventless.CapabilityManifest.provenance),
+            {component: "GeocodeDropOff"},
+          ])
+        )
+
+        // The generator downstream renders a real `Platform.capability` arm, and
+        // a name this build cannot map has no arm to render — so it is dropped
+        // here rather than passed through as an unrenderable key.
+        testSync("a capability this build does not know is dropped", () =>
+          expect(
+            Reventless.CapabilityManifest.fromStructure({
+              ...structure,
+              requiredCapabilities: Some([{capability: "Telepathy", component: "Guess"}]),
+              traitDeclarations: None,
+            }).capabilities,
+          )->toEqual([])
+        )
+      })
+
       testSync("rendering is deterministic and newline-terminated", () => {
         let rendered = Reventless.CapabilityManifest.renderForStructure(withStores)
         expect(rendered)->toBe(
@@ -1671,7 +1799,7 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       let manifest = Reventless.CapabilityManifest.fromStructure(withHeuristicField)
       expect(
         manifest.capabilities->Array.every(entry =>
-          entry.declaredBy->Array.every(site => site.field != "photoUrl")
+          entry.declaredBy->Array.every(site => site.field != Some("photoUrl"))
         ),
       )->toBe(true)
     })
@@ -1856,3 +1984,54 @@ describe("the subscriber's half of the table", () => {
     )->toBe(1)
   )
 })
+
+// ── One command name, one handler ────────────────────────────────────────────
+//
+// A DCB plugin routes a command by its bare type name, so two slices declaring
+// one name have one handler between them. 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 — so the structure refuses it instead.
+
+describe("duplicate DCB command names", () => {
+  // The same slice twice is the smallest possible collision, and it needs no
+  // fixture that exists only to collide.
+  testSync("two slices declaring one command are refused", () =>
+    expect(
+      switch Plugin_Structure.make(
+        ~name="TestPlugin",
+        ~stateChangeSlices=[module(PsShipOrderSlice), module(PsShipOrderSlice)],
+      ) {
+      | _ => false
+      | exception _ => true
+      },
+    )->toBe(true)
+  )
+
+  testSync("the refusal names the command and both slices", () =>
+    switch Plugin_Structure.make(
+      ~name="TestPlugin",
+      ~stateChangeSlices=[module(PsShipOrderSlice), module(PsShipOrderSlice)],
+    ) {
+    | _ => expect("no refusal")->toBe("a refusal naming the command")
+    | exception JsExn(e) =>
+      let message = e->JsExn.message->Option.getOr("")
+      expect((
+        message->String.includes("ShipOrder"),
+        message->String.includes("routes a command by its bare name"),
+      ))->toEqual((true, true))
+    }
+  )
+
+  // Distinct names are the ordinary case and must stay silent.
+  testSync("distinct command names are fine", () =>
+    expect(
+      switch Plugin_Structure.make(
+        ~name="TestPlugin",
+        ~stateChangeSlices=[module(PsPlaceOrderSlice), module(PsShipOrderSlice)],
+      ) {
+      | _ => true
+      | exception _ => false
+      },
+    )->toBe(true)
+  )
+})

package/tests/plugin/PluginStructureTest.res.mjs

@@ -30,6 +30,7 @@ import * as PsShipmentsView$ReventlessCore from "./StateViewSlice/PsShipmentsVie
 import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
 import * as PsCategoriesView$ReventlessCore from "./StateViewSlice/PsCategoriesView.res.mjs";
 import * as PsDispatchShipment$ReventlessCore from "./StateChangeSlice/PsDispatchShipment.res.mjs";
+import * as PsTransitionSwitch$ReventlessCore from "./StateChangeSlice/PsTransitionSwitch.res.mjs";
 import * as Capability_Inference$ReventlessCore from "../../src/plugin/component/Capability_Inference.res.mjs";
 import * as PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
 
@@ -53,6 +54,8 @@ let PsPlaceOrderSlice_Spec = {
   eventSchema: PsPlaceOrder$ReventlessCore.eventSchema,
   commandSchema: PsPlaceOrder$ReventlessCore.commandSchema,
   commandAuthorization: PsPlaceOrder$ReventlessCore.commandAuthorization,
+  commandTransition: PsPlaceOrder$ReventlessCore.commandTransition,
+  traits: PsPlaceOrder$ReventlessCore.traits,
   readConsistency: PsPlaceOrder$ReventlessCore.readConsistency
 };
 
@@ -83,6 +86,8 @@ let PsShipOrderSlice_Spec = {
   eventSchema: PsShipOrder$ReventlessCore.eventSchema,
   commandSchema: PsShipOrder$ReventlessCore.commandSchema,
   commandAuthorization: PsShipOrder$ReventlessCore.commandAuthorization,
+  commandTransition: PsShipOrder$ReventlessCore.commandTransition,
+  traits: PsShipOrder$ReventlessCore.traits,
   readConsistency: PsShipOrder$ReventlessCore.readConsistency
 };
 
@@ -243,6 +248,8 @@ let PsAttachInvoiceSlice_Spec = {
   eventSchema: PsAttachInvoice$ReventlessCore.eventSchema,
   commandSchema: PsAttachInvoice$ReventlessCore.commandSchema,
   commandAuthorization: PsAttachInvoice$ReventlessCore.commandAuthorization,
+  commandTransition: PsAttachInvoice$ReventlessCore.commandTransition,
+  traits: PsAttachInvoice$ReventlessCore.traits,
   readConsistency: PsAttachInvoice$ReventlessCore.readConsistency
 };
 
@@ -273,6 +280,8 @@ let PsUploadAvatarSlice_Spec = {
   eventSchema: PsUploadAvatar$ReventlessCore.eventSchema,
   commandSchema: PsUploadAvatar$ReventlessCore.commandSchema,
   commandAuthorization: PsUploadAvatar$ReventlessCore.commandAuthorization,
+  commandTransition: PsUploadAvatar$ReventlessCore.commandTransition,
+  traits: PsUploadAvatar$ReventlessCore.traits,
   readConsistency: PsUploadAvatar$ReventlessCore.readConsistency
 };
 
@@ -303,6 +312,8 @@ let PsUploadImagesSlice_Spec = {
   eventSchema: PsUploadImages$ReventlessCore.eventSchema,
   commandSchema: PsUploadImages$ReventlessCore.commandSchema,
   commandAuthorization: PsUploadImages$ReventlessCore.commandAuthorization,
+  commandTransition: PsUploadImages$ReventlessCore.commandTransition,
+  traits: PsUploadImages$ReventlessCore.traits,
   readConsistency: PsUploadImages$ReventlessCore.readConsistency
 };
 
@@ -333,6 +344,8 @@ let PsTypoStoreSlice_Spec = {
   eventSchema: PsTypoStore$ReventlessCore.eventSchema,
   commandSchema: PsTypoStore$ReventlessCore.commandSchema,
   commandAuthorization: PsTypoStore$ReventlessCore.commandAuthorization,
+  commandTransition: PsTypoStore$ReventlessCore.commandTransition,
+  traits: PsTypoStore$ReventlessCore.traits,
   readConsistency: PsTypoStore$ReventlessCore.readConsistency
 };
 
@@ -363,6 +376,8 @@ let PsChangePhotoSlice_Spec = {
   eventSchema: PsChangePhoto$ReventlessCore.eventSchema,
   commandSchema: PsChangePhoto$ReventlessCore.commandSchema,
   commandAuthorization: PsChangePhoto$ReventlessCore.commandAuthorization,
+  commandTransition: PsChangePhoto$ReventlessCore.commandTransition,
+  traits: PsChangePhoto$ReventlessCore.traits,
   readConsistency: PsChangePhoto$ReventlessCore.readConsistency
 };
 
@@ -393,6 +408,8 @@ let PsReserveStockSlice_Spec = {
   eventSchema: PsReserveStock$ReventlessCore.eventSchema,
   commandSchema: PsReserveStock$ReventlessCore.commandSchema,
   commandAuthorization: PsReserveStock$ReventlessCore.commandAuthorization,
+  commandTransition: PsReserveStock$ReventlessCore.commandTransition,
+  traits: PsReserveStock$ReventlessCore.traits,
   readConsistency: PsReserveStock$ReventlessCore.readConsistency
 };
 
@@ -423,6 +440,8 @@ let PsDispatchShipmentSlice_Spec = {
   eventSchema: PsDispatchShipment$ReventlessCore.eventSchema,
   commandSchema: PsDispatchShipment$ReventlessCore.commandSchema,
   commandAuthorization: PsDispatchShipment$ReventlessCore.commandAuthorization,
+  commandTransition: PsDispatchShipment$ReventlessCore.commandTransition,
+  traits: PsDispatchShipment$ReventlessCore.traits,
   readConsistency: PsDispatchShipment$ReventlessCore.readConsistency
 };
 
@@ -433,12 +452,44 @@ let PsDispatchShipmentSlice = {
   make: make$13
 };
 
+let Behavior$9 = {
+  initialState: false,
+  evolve: PsTransitionSwitch$ReventlessCore.evolve,
+  decide: PsTransitionSwitch$ReventlessCore.decide,
+  moduleUrl: PsTransitionSwitch$ReventlessCore.moduleUrl
+};
+
+function make$14(param, param$1, param$2, param$3, param$4, param$5) {
+  return 0;
+}
+
+let PsTransitionSwitchSlice_Spec = {
+  name: PsTransitionSwitch$ReventlessCore.name,
+  moduleUrl: PsTransitionSwitch$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsTransitionSwitch$ReventlessCore.consumedEventSchema,
+  errorSchema: PsTransitionSwitch$ReventlessCore.errorSchema,
+  eventSchema: PsTransitionSwitch$ReventlessCore.eventSchema,
+  commandSchema: PsTransitionSwitch$ReventlessCore.commandSchema,
+  commandAuthorization: PsTransitionSwitch$ReventlessCore.commandAuthorization,
+  commandTransition: PsTransitionSwitch$ReventlessCore.commandTransition,
+  traits: PsTransitionSwitch$ReventlessCore.traits,
+  readConsistency: PsTransitionSwitch$ReventlessCore.readConsistency
+};
+
+let PsTransitionSwitchSlice = {
+  Spec: PsTransitionSwitchSlice_Spec,
+  Behavior: Behavior$9,
+  isAsync: false,
+  make: make$14
+};
+
 let Projection$5 = {
   project: PsShipmentsView$ReventlessCore.project,
   moduleUrl: PsShipmentsView$ReventlessCore.moduleUrl
 };
 
-function make$14(param, param$1, param$2) {
+function make$15(param, param$1, param$2) {
   return 0;
 }
 
@@ -456,7 +507,7 @@ let PsShipmentsViewSlice_Spec = {
 let PsShipmentsViewSlice = {
   Spec: PsShipmentsViewSlice_Spec,
   Projection: Projection$5,
-  make: make$14
+  make: make$15
 };
 
 let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
@@ -529,7 +580,70 @@ globalThis.describe("lifecycle topology", () => {
   });
 });
 
-globalThis.describe("@transition cross-check", () => {
+globalThis.describe("commandTransition — the edge as a switch", () => {
+  let structure = Plugin_Structure$ReventlessCore.make("TransitionSwitchPlugin", undefined, undefined, [], [PsTransitionSwitchSlice], undefined, undefined, undefined, undefined, undefined, undefined);
+  let slice = structure.stateChangeSlices[0];
+  let byName = name => slice.commands.find(c => c.name === name);
+  globalThis.test("the switch fills allowedStates and targetState", () => {
+    globalThis.expect([
+      Stdlib_Option.flatMap(byName("Book"), c => c.allowedStates),
+      Stdlib_Option.flatMap(byName("Book"), c => c.targetState)
+    ]).toEqual([
+      ["Draft"],
+      "Booked"
+    ]);
+  });
+  globalThis.test("a guard declares its from-set and no target", () => {
+    globalThis.expect([
+      Stdlib_Option.flatMap(byName("Rebook"), c => c.allowedStates),
+      Stdlib_Option.flatMap(byName("Rebook"), c => c.targetState)
+    ]).toEqual([
+      ["Booked"],
+      undefined
+    ]);
+  });
+  globalThis.test("Unrestricted declares nothing, leaving the command unconstrained", () => {
+    globalThis.expect([
+      Stdlib_Option.flatMap(byName("Abandon"), c => c.allowedStates),
+      Stdlib_Option.flatMap(byName("Abandon"), c => c.targetState)
+    ]).toEqual([
+      undefined,
+      undefined
+    ]);
+  });
+});
+
+globalThis.describe("traitDeclarations — a graft leaves a trace", () => {
+  let structure = Plugin_Structure$ReventlessCore.make("TraitPlugin", undefined, undefined, [], [
+    PsTransitionSwitchSlice,
+    PsShipOrderSlice
+  ], undefined, undefined, undefined, undefined, undefined, undefined);
+  globalThis.test("a declaring component's trait reaches the structure", () => {
+    globalThis.expect(Stdlib_Option.getOr(structure.traitDeclarations, []).map(d => [
+      d.trait,
+      d.component
+    ])).toEqual([[
+        "@reventlessdev/trait-booking",
+        "TransitionSwitch"
+      ]]);
+  });
+  globalThis.test("the component name is filled in by the structure, not declared", () => {
+    globalThis.expect(Stdlib_Option.getOr(structure.traitDeclarations, []).map(d => [
+      d.version,
+      d.posture,
+      d.component
+    ])).toEqual([[
+        "9.9.9",
+        "SelfContained",
+        "TransitionSwitch"
+      ]]);
+  });
+  globalThis.test("a component that is nobody's graft contributes nothing", () => {
+    globalThis.expect(Stdlib_Option.getOr(structure.traitDeclarations, []).length).toBe(1);
+  });
+});
+
+globalThis.describe("declared-edge cross-check", () => {
   let buildBad = () => {
     try {
       Plugin_Structure$ReventlessCore.make("TransitionPlugin", undefined, undefined, [PsShipmentsViewSlice], [PsDispatchShipmentSlice], undefined, undefined, undefined, undefined, undefined, undefined);
@@ -642,7 +756,7 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         false
       ]);
     });
-    globalThis.test("ShipOrder: @transition's target flows through the PPX to commandDef.targetState", () => {
+    globalThis.test("ShipOrder: the switch's target flows through to commandDef.targetState", () => {
       let shipOrder = structure.stateChangeSlices[1];
       let byName = name => shipOrder.commands.find(c => c.name === name);
       globalThis.expect([
@@ -653,7 +767,7 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         undefined
       ]);
     });
-    globalThis.test("ShipOrder: @transition's from-set flows through to commandDef.allowedStates", () => {
+    globalThis.test("ShipOrder: the switch's from-set flows through to commandDef.allowedStates", () => {
       let shipOrder = structure.stateChangeSlices[1];
       let byName = name => shipOrder.commands.find(c => c.name === name);
       globalThis.expect([
@@ -1448,6 +1562,78 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.test("a structure declaring nothing yields an empty list, not a missing manifest", () => {
         globalThis.expect(CapabilityManifest$Reventless.fromStructure(structure).capabilities).toEqual([]);
       });
+      globalThis.describe("declared capabilities", () => {
+        let withCapability_readModels = structure.readModels;
+        let withCapability_stateViewSlices = structure.stateViewSlices;
+        let withCapability_stateChangeSlices = structure.stateChangeSlices;
+        let withCapability_aggregates = structure.aggregates;
+        let withCapability_automationSlices = structure.automationSlices;
+        let withCapability_outboundTranslationSlices = structure.outboundTranslationSlices;
+        let withCapability_inboundTranslationSlices = structure.inboundTranslationSlices;
+        let withCapability_extensions = structure.extensions;
+        let withCapability_extensionPoints = structure.extensionPoints;
+        let withCapability_requiredStores = structure.requiredStores;
+        let withCapability_requiredStoreDeclarations = structure.requiredStoreDeclarations;
+        let withCapability_requiredCapabilities = [
+          {
+            capability: "Geocoding",
+            component: "GeocodeAddress"
+          },
+          {
+            capability: "Geocoding",
+            component: "GeocodeDropOff"
+          }
+        ];
+        let withCapability = {
+          readModels: withCapability_readModels,
+          stateViewSlices: withCapability_stateViewSlices,
+          stateChangeSlices: withCapability_stateChangeSlices,
+          aggregates: withCapability_aggregates,
+          automationSlices: withCapability_automationSlices,
+          outboundTranslationSlices: withCapability_outboundTranslationSlices,
+          inboundTranslationSlices: withCapability_inboundTranslationSlices,
+          extensions: withCapability_extensions,
+          extensionPoints: withCapability_extensionPoints,
+          requiredStores: withCapability_requiredStores,
+          requiredStoreDeclarations: withCapability_requiredStoreDeclarations,
+          requiredCapabilities: withCapability_requiredCapabilities,
+          traitDeclarations: undefined
+        };
+        let entries = CapabilityManifest$Reventless.fromStructure(withCapability).capabilities;
+        globalThis.test("two components needing one capability yield one entry", () => {
+          globalThis.expect(entries.map(e => e.key)).toEqual(["Geocoding"]);
+        });
+        globalThis.test("both declaring components are kept, with no field", () => {
+          globalThis.expect(entries[0].declaredBy).toEqual([
+            {
+              component: "GeocodeAddress"
+            },
+            {
+              component: "GeocodeDropOff"
+            }
+          ]);
+        });
+        globalThis.test("a capability this build does not know is dropped", () => {
+          globalThis.expect(CapabilityManifest$Reventless.fromStructure({
+            readModels: structure.readModels,
+            stateViewSlices: structure.stateViewSlices,
+            stateChangeSlices: structure.stateChangeSlices,
+            aggregates: structure.aggregates,
+            automationSlices: structure.automationSlices,
+            outboundTranslationSlices: structure.outboundTranslationSlices,
+            inboundTranslationSlices: structure.inboundTranslationSlices,
+            extensions: structure.extensions,
+            extensionPoints: structure.extensionPoints,
+            requiredStores: structure.requiredStores,
+            requiredStoreDeclarations: structure.requiredStoreDeclarations,
+            requiredCapabilities: [{
+                capability: "Telepathy",
+                component: "Guess"
+              }],
+            traitDeclarations: undefined
+          }).capabilities).toEqual([]);
+        });
+      });
       globalThis.test("rendering is deterministic and newline-terminated", () => {
         let rendered = CapabilityManifest$Reventless.renderForStructure(withStores);
         globalThis.expect(rendered).toBe(`{
@@ -1662,7 +1848,7 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       let withHeuristicField = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [PsChangePhotoSlice], undefined, undefined, undefined, undefined, undefined, undefined);
       globalThis.expect(withHeuristicField.requiredStores).toEqual(["TestPlugin.productPhotos"]);
       let manifest = CapabilityManifest$Reventless.fromStructure(withHeuristicField);
-      globalThis.expect(manifest.capabilities.every(entry => entry.declaredBy.every(site => site.field !== "photoUrl"))).toBe(true);
+      globalThis.expect(manifest.capabilities.every(entry => entry.declaredBy.every(site => Primitive_object.notequal(site.field, "photoUrl")))).toBe(true);
     });
     globalThis.test("the warning names the field and the settling annotation", () => {
       let text = Capability_Inference$ReventlessCore.message(commandWarnings[0]);
@@ -1858,6 +2044,59 @@ globalThis.describe("the subscriber's half of the table", () => {
   });
 });
 
+globalThis.describe("duplicate DCB command names", () => {
+  globalThis.test("two slices declaring one command are refused", () => {
+    let tmp;
+    try {
+      Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [
+        PsShipOrderSlice,
+        PsShipOrderSlice
+      ], undefined, undefined, undefined, undefined, undefined, undefined);
+      tmp = false;
+    } catch (exn) {
+      tmp = true;
+    }
+    globalThis.expect(tmp).toBe(true);
+  });
+  globalThis.test("the refusal names the command and both slices", () => {
+    let val;
+    try {
+      val = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [
+        PsShipOrderSlice,
+        PsShipOrderSlice
+      ], undefined, undefined, undefined, undefined, undefined, undefined);
+    } catch (raw_e) {
+      let e = Primitive_exceptions.internalToException(raw_e);
+      if (e.RE_EXN_ID === "JsExn") {
+        let message = Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "");
+        globalThis.expect([
+          message.includes("ShipOrder"),
+          message.includes("routes a command by its bare name")
+        ]).toEqual([
+          true,
+          true
+        ]);
+        return;
+      }
+      throw e;
+    }
+    globalThis.expect("no refusal").toBe("a refusal naming the command");
+  });
+  globalThis.test("distinct command names are fine", () => {
+    let tmp;
+    try {
+      Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [
+        PsPlaceOrderSlice,
+        PsShipOrderSlice
+      ], undefined, undefined, undefined, undefined, undefined, undefined);
+      tmp = true;
+    } catch (exn) {
+      tmp = false;
+    }
+    globalThis.expect(tmp).toBe(true);
+  });
+});
+
 export {
   PsPlaceOrderSlice,
   PsShipOrderSlice,
@@ -1873,6 +2112,7 @@ export {
   PsChangePhotoSlice,
   PsReserveStockSlice,
   PsDispatchShipmentSlice,
+  PsTransitionSwitchSlice,
   PsShipmentsViewSlice,
   structure,
 }

package/tests/plugin/StateChangeSlice/PsAttachInvoice.res.mjs

@@ -36,6 +36,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "AttachInvoice";
 
 let Id;
@@ -59,5 +65,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsChangePhoto.res.mjs

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