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

package/tests/api/ApiNoApiTest.res

@@ -1,6 +1,52 @@
 open JestGlobals
 open ApiNoApiHelpers
 
+// The exclusion has to survive a variant spread. Splicing copies a union's
+// members, not its metadata, so an exclusion recorded only on the union vanishes
+// on the way into the host — and the host publishes as a mutation and a
+// subscription a command whose author marked it internal. No error, no warning.
+//
+// Built the way the PPX builds it (`markNoApiVariants` on a freshly made union),
+// then spliced the way the compiler splices it (concatenating `anyOf`), so this
+// exercises the real path rather than a hand-stamped stand-in.
+let member = name =>
+  S.object(o => {
+    let _ = o.field("TAG", S.literal(name))
+  })->S.castToUnknown
+
+let sourceUnion =
+  S.union([member("Public"), member("Internal")])->ReventlessInfra.Api.markNoApiVariants([
+    "Internal",
+  ])
+
+let spliced = switch sourceUnion {
+| AnyOf({anyOf}) => S.union(Array.concat([member("HostOwn")], anyOf))
+| _ => sourceUnion
+}
+
+describe("a spread carries its exclusions", () => {
+  testSync("the source union still reports its own exclusion", () =>
+    expect(getExcludedVariants(sourceUnion)->Option.map(Set.toArray))->toEqual(Some(["Internal"]))
+  )
+
+  testSync("a host that splices the members inherits the exclusion", () =>
+    expect(getExcludedVariants(spliced)->Option.map(Set.toArray))->toEqual(Some(["Internal"]))
+  )
+
+  // The failure this closes, stated as the thing it must not do: the spliced
+  // internal variant must not appear among the host's callable fields.
+  testSync("the spliced internal variant is filtered out of a host's fields", () =>
+    expect(filterNoApiVariants(["HostOwn", "Public", "Internal"], spliced))->toEqual([
+      "HostOwn",
+      "Public",
+    ])
+  )
+
+  testSync("nothing else is filtered", () =>
+    expect(filterNoApiVariants(["HostOwn", "Public"], spliced))->toEqual(["HostOwn", "Public"])
+  )
+})
+
 describe("ApiNoApiHelpers:", () => {
   testSync("isNoApi returns false for schema without noApi metadata", () => {
     let schema = S.string->S.castToUnknown

package/tests/api/ApiNoApiTest.res.mjs

@@ -5,6 +5,49 @@ 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";
 import * as ApiNoApiHelpers$ReventlessCore from "../../src/components/Api/ApiNoApiHelpers.res.mjs";
 
+function member(name) {
+  return Sury.object(o => {
+    o.f("TAG", Sury.literal(name));
+  });
+}
+
+let sourceUnion = Api$ReventlessInfra.markNoApiVariants(Sury.union([
+  member("Public"),
+  member("Internal")
+]), ["Internal"]);
+
+let spliced;
+
+spliced = sourceUnion.type === "anyOf" ? Sury.union([member("HostOwn")].concat(sourceUnion.anyOf)) : sourceUnion;
+
+globalThis.describe("a spread carries its exclusions", () => {
+  globalThis.test("the source union still reports its own exclusion", () => {
+    globalThis.expect(Stdlib_Option.map(ApiNoApiHelpers$ReventlessCore.getExcludedVariants(sourceUnion), prim => Array.from(prim))).toEqual(["Internal"]);
+  });
+  globalThis.test("a host that splices the members inherits the exclusion", () => {
+    globalThis.expect(Stdlib_Option.map(ApiNoApiHelpers$ReventlessCore.getExcludedVariants(spliced), prim => Array.from(prim))).toEqual(["Internal"]);
+  });
+  globalThis.test("the spliced internal variant is filtered out of a host's fields", () => {
+    globalThis.expect(ApiNoApiHelpers$ReventlessCore.filterNoApiVariants([
+      "HostOwn",
+      "Public",
+      "Internal"
+    ], spliced)).toEqual([
+      "HostOwn",
+      "Public"
+    ]);
+  });
+  globalThis.test("nothing else is filtered", () => {
+    globalThis.expect(ApiNoApiHelpers$ReventlessCore.filterNoApiVariants([
+      "HostOwn",
+      "Public"
+    ], spliced)).toEqual([
+      "HostOwn",
+      "Public"
+    ]);
+  });
+});
+
 globalThis.describe("ApiNoApiHelpers:", () => {
   globalThis.test("isNoApi returns false for schema without noApi metadata", () => {
     let schema = Sury.string;
@@ -95,4 +138,9 @@ globalThis.describe("ApiNoApiHelpers:", () => {
   });
 });
 
-/*  Not a pure module */
+export {
+  member,
+  sourceUnion,
+  spliced,
+}
+/* sourceUnion Not a pure module */

package/tests/api/GraphQL_FragmentGeneratorTest.res.mjs

@@ -24,9 +24,17 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let OrderSliceCmd = {
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 function mutationFor(fragment, needle) {
@@ -196,9 +204,17 @@ function commandAuthorization$1(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition$1(param) {
+  return "Unrestricted";
+}
+
+let traits$1 = [];
+
 let AddProductCmd = {
   commandSchema: commandSchema$1,
-  commandAuthorization: commandAuthorization$1
+  commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1
 };
 
 let commandSchema$2 = Sury.union([
@@ -217,9 +233,17 @@ function commandAuthorization$2(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition$2(param) {
+  return "Unrestricted";
+}
+
+let traits$2 = [];
+
 let ChangePriceCmd = {
   commandSchema: commandSchema$2,
-  commandAuthorization: commandAuthorization$2
+  commandAuthorization: commandAuthorization$2,
+  commandTransition: commandTransition$2,
+  traits: traits$2
 };
 
 globalThis.describe("semantic composites are named once, not once per field", () => {

package/tests/commandgenerator/CommandGeneratorFixtures.res.mjs

@@ -32,6 +32,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let CmdGenAggSpec = {
   Id: undefined,
   name: name,
@@ -39,7 +45,9 @@ let CmdGenAggSpec = {
   eventSchema: eventSchema,
   errorSchema: errorSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let moduleUrl$1 = import.meta.url;
@@ -106,7 +114,9 @@ let TestGenerator = CommandGenerator_Callback$ReventlessCore.Make(MockPublishSpe
   errorSchema: errorSchema,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 });
 
 let singleTagCommandSchema = Sury.$schema(s => ({

package/tests/commandtopic/CommandOutcomeHookTest.res.mjs

@@ -65,6 +65,8 @@ let SliceHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,
   commandSchema: DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema,
   commandAuthorization: DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization,
+  commandTransition: DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition,
+  traits: DcbFixtures$ReventlessCore.TestCommandSpec.traits,
   readConsistency: DcbFixtures$ReventlessCore.TestCommandSpec.readConsistency
 })(SliceBehavior);
 

package/tests/commandtopic/CommandTopicCallbackFixtures.res.mjs

@@ -25,11 +25,19 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let TestSpec = {
   Id: undefined,
   name: name,
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let capturedItems = {
@@ -64,7 +72,9 @@ let TestOps_Spec = {
   Id: Id$Reventless.StringPure,
   name: name,
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let TestOps = {

package/tests/dcb/DcbFixtures.res.mjs

@@ -156,6 +156,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let TestCommandSpec_initialState = {
   exists: false,
   currentName: undefined
@@ -173,6 +179,8 @@ let TestCommandSpec = {
   evolve: evolve,
   decide: decide,
   commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
   readConsistency: "EscalateOnRetry"
 };
 

package/tests/dcb/DcbStateChangeSliceTest.res.mjs

@@ -61,6 +61,8 @@ let TestHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,
   commandSchema: DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema,
   commandAuthorization: DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization,
+  commandTransition: DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition,
+  traits: DcbFixtures$ReventlessCore.TestCommandSpec.traits,
   readConsistency: DcbFixtures$ReventlessCore.TestCommandSpec.readConsistency
 })(TestCommandBehavior);
 
@@ -78,6 +80,10 @@ let errorSchema = DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema;
 
 let commandAuthorization = DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization;
 
+let commandTransition = DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition;
+
+let traits = DcbFixtures$ReventlessCore.TestCommandSpec.traits;
+
 let StrongSpec_Id = DcbFixtures$ReventlessCore.TestCommandSpec.Id;
 
 let StrongSpec_initialState = DcbFixtures$ReventlessCore.TestCommandSpec.initialState;
@@ -98,6 +104,8 @@ let StrongSpec = {
   evolve: StrongSpec_evolve,
   decide: StrongSpec_decide,
   commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
   readConsistency: "AlwaysStrong"
 };
 
@@ -115,6 +123,10 @@ let errorSchema$1 = DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema;
 
 let commandAuthorization$1 = DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization;
 
+let commandTransition$1 = DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition;
+
+let traits$1 = DcbFixtures$ReventlessCore.TestCommandSpec.traits;
+
 let EventualSpec_Id = DcbFixtures$ReventlessCore.TestCommandSpec.Id;
 
 let EventualSpec_initialState = DcbFixtures$ReventlessCore.TestCommandSpec.initialState;
@@ -135,6 +147,8 @@ let EventualSpec = {
   evolve: EventualSpec_evolve,
   decide: EventualSpec_decide,
   commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
   readConsistency: "AlwaysEventual"
 };
 
@@ -147,6 +161,8 @@ let StrongHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: eventSchema,
   commandSchema: commandSchema,
   commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
   readConsistency: "AlwaysStrong"
 })(TestCommandBehavior);
 
@@ -159,6 +175,8 @@ let EventualHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: eventSchema$1,
   commandSchema: commandSchema$1,
   commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
   readConsistency: "AlwaysEventual"
 })(TestCommandBehavior);
 

package/tests/eventmapper/EventMapperFixtures.res.mjs

@@ -153,12 +153,20 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let CmdTargetSpec = {
   Id: undefined,
   name: name$3,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl$2,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 function map(id, event, _queryEngine) {
@@ -233,7 +241,9 @@ let OrderMappings_Target = {
   name: name$3,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl$2,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let OrderMappings = {
@@ -262,7 +272,9 @@ let CountOrderMappings_Target = {
   name: name$3,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl$2,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let CountOrderMappings = {

package/tests/extensionpoint/ExtensionPointFixtures.res.mjs

@@ -30,13 +30,21 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let TestEPSpec = {
   name: name,
   commandSchema: commandSchema,
   eventSchema: eventSchema,
   directiveSchema: directiveSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let capturedPublishedCmds = {

package/tests/extensionpoint/ExtensionPointOperationsTest.res.mjs

@@ -25,13 +25,21 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let OpsEPSpec = {
   name: name,
   commandSchema: commandSchema,
   eventSchema: eventSchema,
   directiveSchema: directiveSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let capturedPublished = {

package/tests/message/MessageTest.res

@@ -133,6 +133,8 @@ describe("Message should", () => {
         extensionPoints: None,
         requiredStores: None,
         requiredStoreDeclarations: None,
+        requiredCapabilities: None,
+        traitDeclarations: None,
       })),
       dcbEventLog: None,
       kind: Domain,

package/tests/message/MessageTest.res.mjs

@@ -124,7 +124,9 @@ globalThis.describe("Message should", () => {
           extensions: [],
           extensionPoints: undefined,
           requiredStores: undefined,
-          requiredStoreDeclarations: undefined
+          requiredStoreDeclarations: undefined,
+          requiredCapabilities: undefined,
+          traitDeclarations: undefined
         }
       },
       dcbEventLog: undefined,

package/tests/plugin/PluginStructureAccessTest.res.mjs

@@ -28,6 +28,8 @@ let PsGatedCommandsSlice_Spec = {
   eventSchema: PsGatedCommands$ReventlessCore.eventSchema,
   commandSchema: PsGatedCommands$ReventlessCore.commandSchema,
   commandAuthorization: PsGatedCommands$ReventlessCore.commandAuthorization,
+  commandTransition: PsGatedCommands$ReventlessCore.commandTransition,
+  traits: PsGatedCommands$ReventlessCore.traits,
   readConsistency: PsGatedCommands$ReventlessCore.readConsistency
 };
 

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,6 +303,87 @@ describe("lifecycle topology", () => {
   })
 })
 
+describe("commandTransition — the edge as a switch", () => {
+  // The seam a variant spread needs. `@transition` lowers to a dict on the
+  // parent union keyed by variant name, and a spread splices members, so a
+  // command a host did not declare cannot 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", () => {
+    // The same positive claim the one-sided `@transition` makes: legal in these
+    // states, and it moves the row nowhere.
+    expect((
+      byName("Rebook")->Option.flatMap(c => c.allowedStates),
+      byName("Rebook")->Option.flatMap(c => c.targetState),
+    ))->toEqual((Some(["Booked"]), None))
+  })
+
+  testSync("the switch wins over an @transition on the same command", () => {
+    // `Rebook` carries both, and they disagree on purpose: the attribute says
+    // Draft. Two sources of truth need a stated winner, and it is the one the
+    // compiler checked.
+    expect(byName("Rebook")->Option.flatMap(c => c.allowedStates))->toEqual(Some(["Booked"]))
+  })
+
+  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("@transition 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.
@@ -1366,6 +1460,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 +1804,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 +1989,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)
+  )
+})