@reventlessdev/reventless-gwt 1.0.0-alpha.85 → 1.0.0-alpha.87

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.87 (2026-07-07)
+
+* feat(vscode-protocol)!: typed kind vocabularies (protocol v11, PascalCase wire) ([c087e76](https://github.com/ReventlessDev/reventless-core/commit/c087e76b8e2ed02ba98e7b0ce5c63eed35b39878))
+
+### BREAKING CHANGES
+
+* every kind vocabulary is uniformly PascalCase on the wire
+(handles→Handles, file→File, …) and protocolVersion bumps to 11. The event
+envelope is unchanged; unknown kinds degrade gracefully. Consumers keying on
+kind strings must respell. The new minCompatibleProtocol/isCompatible exports
+pin the advisory (warn, don't refuse) compat policy.
+
+- GraphOps predicates/baseKind/isFqKind become exhaustive matches; read edges typed
+- gwt emitters construct variants (DomainGraph, FormatterVsCode, DomainDeadCode)
+- golden fixture regenerated; one appended Other* unknown-kind sample per typed field
+- fixes two sample values that never occurred on the wire (orphanEvent, notEqual)
+- BridgeDriftTest pins both hand-written genType bridges against src/*.gen.ts
+  (surfaced missing position/failLocation re-exports — added)
+- plan → docs/plans/done/vscode-protocol-hardening.md
+
+
+
+# 1.0.0-alpha.86 (2026-07-06)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
 # 1.0.0-alpha.85 (2026-07-06)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.85",
+  "version": "1.0.0-alpha.87",
   "description": "Given-When-Then DSLs and CLI runner for Reventless slice testing",
   "license": "Apache-2.0",
   "bin": {
@@ -20,12 +20,12 @@
     "chokidar": "^3.6.0",
     "picocolors": "^1.1.1",
     "sury": "11.0.0-alpha.4",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/reventless-core": "3.0.0-alpha.143",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.89",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.67",
-    "@reventlessdev/reventless-vscode-protocol": "1.0.0-alpha.14"
+    "@reventlessdev/reventless-vscode-protocol": "1.0.0-alpha.16"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/DomainDeadCode.res

@@ -26,8 +26,13 @@
 // and "read models nothing resolves against" need data `pluginStructure` does not
 // carry (the EP declaration list / the id-resolver table) — deferred.
 
+// Finding kinds are the typed protocol vocabulary — constructing the variant here
+// (not a string literal) means a typo or rename is a compile error, and the emitter
+// forwards findings without conversion.
+module P = ReventlessVscodeProtocol.Protocol
+
 type finding = {
-  kind: string, // "OrphanEvent"
+  kind: P.deadCodeKind,
   pluginName: string, // plugin owning the producer
   componentName: string, // the producing aggregate / state-change slice
   detail: string, // the orphaned event type
@@ -76,7 +81,7 @@ let analyze = (
           | Some(_) => ()
           | None =>
             findings->Array.push({
-              kind: "OrphanEvent",
+              kind: OrphanEvent,
               pluginName,
               componentName: w.name,
               detail: evt,

package/src/DomainDeadCode.res.mjs

@@ -63,7 +63,10 @@ function analyze(structures) {
   return findings;
 }
 
+let P;
+
 export {
+  P,
   analyze,
 }
 /* No side effect */

package/src/FormatterVsCode.res

@@ -141,13 +141,15 @@ let emitDiscoveryItems = (files: array<(string, array<RunnerTypes.testResult>)>)
     }
     let component =
       ComponentMeta.componentOfTestFile(path)->Option.map((c): P.componentMeta => {
-        kind: c.kind,
+        // `ComponentKind.folderName` spellings ARE the typed vocabulary's constructor
+        // names, so the identity conversion lands every known kind on its constructor.
+        kind: P.componentKindOfString(c.kind),
         name: c.name,
       })
     emit(
       Item({
         id: fileId,
-        kind: "file",
+        kind: File,
         label: fileLabelOf(path),
         description: relativeToCwd(path),
         uri: fileUri,
@@ -174,7 +176,7 @@ let emitDiscoveryItems = (files: array<(string, array<RunnerTypes.testResult>)>)
               Item({
                 id,
                 parent,
-                kind: "suite",
+                kind: Suite,
                 label,
                 uri: ?loc->Option.map(l => uriOf(l.file)),
                 range: ?loc->Option.map(rangeOf),
@@ -197,7 +199,7 @@ let emitDiscoveryItems = (files: array<(string, array<RunnerTypes.testResult>)>)
         Item({
           id: testId,
           parent,
-          kind: "test",
+          kind: Test,
           label: t.name,
           uri: ?loc->Option.map(l => uriOf(l.file)),
           range: ?loc->Option.map(rangeOf),
@@ -225,7 +227,7 @@ let components = (comps: array<ComponentScan.component>) =>
     Components({
       components: comps->Array.map((c): P.componentRef => {
         dir: c.dir,
-        kind: c.kind,
+        kind: P.componentKindOfString(c.kind),
         name: c.name,
         files: c.files,
       }),
@@ -332,7 +334,10 @@ let messagePayload = (t: RunnerTypes.testResult): P.failMessage =>
     {
       message: hint.message,
       // The mismatch family — lets a client gate the apply-expected quick-fix.
-      kind: ?Some(Outcome.kindName(m)),
+      // `Outcome.kindName` stays string-returning (JUnit/JSON formatters consume it
+      // raw); its spellings are the assertionKind constructor names, so the identity
+      // conversion types it losslessly.
+      kind: ?Some(P.assertionKindOfString(Outcome.kindName(m))),
       expected: ?expected,
       actual: ?actual,
       location: ?location,

package/src/FormatterVsCode.res.mjs

@@ -163,7 +163,7 @@ function emitDiscoveryItems(files) {
     let e = {
       event: "item",
       id: path,
-      kind: "file",
+      kind: "File",
       label: e_3,
       description: e_4,
       uri: e_5,
@@ -193,7 +193,7 @@ function emitDiscoveryItems(files) {
           event: "item",
           id: id,
           parent: e_1,
-          kind: "suite",
+          kind: "Suite",
           label: label,
           uri: e_5,
           range: e_6
@@ -216,7 +216,7 @@ function emitDiscoveryItems(files) {
         event: "item",
         id: testId,
         parent: e_1,
-        kind: "test",
+        kind: "Test",
         label: e_3,
         uri: e_5,
         range: e_6

package/tests/DomainGraphTest.res

@@ -4,6 +4,7 @@
 // LocalHost integration; here hand-built fixtures pin the edge wiring.
 
 open JestGlobals
+open ReventlessVscodeProtocol.Protocol
 
 let command = (~name, ~mutationField, ~apiExposed=None): Reventless.Plugin.commandDef => {
   name,
@@ -103,13 +104,13 @@ describe("DomainGraph.build", () => {
       ~stateViewSlices=[queryable(~name="OrderView", ~consumes=["Shop.Placed"])],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(nodeKind(g, "Shop_Order_Place"))->toEqual(Some("Command"))
-    expect(nodeKind(g, "Shop:Order"))->toEqual(Some("Aggregate"))
-    expect(nodeKind(g, "Shop.Placed"))->toEqual(Some("Event"))
-    expect(nodeKind(g, "Shop:OrderView"))->toEqual(Some("StateViewSlice"))
-    expect(hasEdge(g, "Shop_Order_Place", "Shop:Order", "handles"))->toBe(true)
-    expect(hasEdge(g, "Shop:Order", "Shop.Placed", "emits"))->toBe(true)
-    expect(hasEdge(g, "Shop.Placed", "Shop:OrderView", "projects"))->toBe(true)
+    expect(nodeKind(g, "Shop_Order_Place"))->toEqual(Some(Command))
+    expect(nodeKind(g, "Shop:Order"))->toEqual(Some(Aggregate))
+    expect(nodeKind(g, "Shop.Placed"))->toEqual(Some(Event))
+    expect(nodeKind(g, "Shop:OrderView"))->toEqual(Some(StateViewSlice))
+    expect(hasEdge(g, "Shop_Order_Place", "Shop:Order", Handles))->toBe(true)
+    expect(hasEdge(g, "Shop:Order", "Shop.Placed", Emits))->toBe(true)
+    expect(hasEdge(g, "Shop.Placed", "Shop:OrderView", Projects))->toBe(true)
   })
 
   testPromise("payload-less events (in `events`, not producedEventTypes) still get an emitted node", async () => {
@@ -126,10 +127,10 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Catalog", shop)])
-    expect(nodeKind(g, "Catalog.Added"))->toEqual(Some("Event"))
-    expect(nodeKind(g, "Catalog.Archived"))->toEqual(Some("Event"))
-    expect(hasEdge(g, "Catalog:Category", "Catalog.Added", "emits"))->toBe(true)
-    expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", "emits"))->toBe(true)
+    expect(nodeKind(g, "Catalog.Added"))->toEqual(Some(Event))
+    expect(nodeKind(g, "Catalog.Archived"))->toEqual(Some(Event))
+    expect(hasEdge(g, "Catalog:Category", "Catalog.Added", Emits))->toBe(true)
+    expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", Emits))->toBe(true)
   })
 
   testPromise("a payload-less event also projects into the aggregate's linked view", async () => {
@@ -147,8 +148,8 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Catalog", shop)])
-    expect(hasEdge(g, "Catalog.Added", "Catalog:Categories", "projects"))->toBe(true)
-    expect(hasEdge(g, "Catalog.Archived", "Catalog:Categories", "projects"))->toBe(true)
+    expect(hasEdge(g, "Catalog.Added", "Catalog:Categories", Projects))->toBe(true)
+    expect(hasEdge(g, "Catalog.Archived", "Catalog:Categories", Projects))->toBe(true)
   })
 
   testPromise("an Internal StateViewSlice still gets a node + projects edge (dev graph shows it)", async () => {
@@ -162,8 +163,8 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(nodeKind(g, "Shop:AvailableView"))->toEqual(Some("StateViewSlice"))
-    expect(hasEdge(g, "Shop.Placed", "Shop:AvailableView", "projects"))->toBe(true)
+    expect(nodeKind(g, "Shop:AvailableView"))->toEqual(Some(StateViewSlice))
+    expect(hasEdge(g, "Shop.Placed", "Shop:AvailableView", Projects))->toBe(true)
   })
 
   testPromise("classic linkedViews draws each produced event into the linked read model", async () => {
@@ -172,8 +173,8 @@ describe("DomainGraph.build", () => {
       ~readModels=[queryable(~name="Orders")],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(hasEdge(g, "Shop.Placed", "Shop:Orders", "projects"))->toBe(true)
-    expect(hasEdge(g, "Shop.Shipped", "Shop:Orders", "projects"))->toBe(true)
+    expect(hasEdge(g, "Shop.Placed", "Shop:Orders", Projects))->toBe(true)
+    expect(hasEdge(g, "Shop.Shipped", "Shop:Orders", Projects))->toBe(true)
   })
 
   testPromise("automation slices are triggered by their consumed events", async () => {
@@ -182,8 +183,8 @@ describe("DomainGraph.build", () => {
       ~automationSlices=[automation(~name="Notify", ~consumes=["Shop.Placed"])],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(nodeKind(g, "Shop:Notify"))->toEqual(Some("AutomationSlice"))
-    expect(hasEdge(g, "Shop.Placed", "Shop:Notify", "triggers"))->toBe(true)
+    expect(nodeKind(g, "Shop:Notify"))->toEqual(Some(AutomationSlice))
+    expect(hasEdge(g, "Shop.Placed", "Shop:Notify", Triggers))->toBe(true)
   })
 
   testPromise("an automation routes to the specific command it raises on its target", async () => {
@@ -206,9 +207,9 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_ShipOrder", "delegatesTo"))->toBe(true)
+    expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_ShipOrder", DelegatesTo))->toBe(true)
     // Matched by name — the target's other command is not linked.
-    expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_Place", "delegatesTo"))->toBe(false)
+    expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_Place", DelegatesTo))->toBe(false)
   })
 
   testPromise("an inbound translation routes to the command it raises on its target", async () => {
@@ -223,8 +224,8 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(nodeKind(g, "Shop:ImportProduct"))->toEqual(Some("InboundTranslationSlice"))
-    expect(hasEdge(g, "Shop:ImportProduct", "Shop_Product_Add", "delegatesTo"))->toBe(true)
+    expect(nodeKind(g, "Shop:ImportProduct"))->toEqual(Some(InboundTranslationSlice))
+    expect(hasEdge(g, "Shop:ImportProduct", "Shop_Product_Add", DelegatesTo))->toBe(true)
   })
 
   testPromise("an outbound translation with a target routes to the command it raises", async () => {
@@ -237,7 +238,7 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", "delegatesTo"))->toBe(true)
+    expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", DelegatesTo))->toBe(true)
   })
 
   testPromise("an inbound translation naming an external system draws a box feeding it", async () => {
@@ -248,11 +249,11 @@ describe("DomainGraph.build", () => {
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
     // External box: drawn OUTSIDE the plugin (plugin: "") with a stable "ext:<name>" id.
-    expect(nodeKind(g, "ext:SupplierFeed"))->toEqual(Some("ExternalSystem"))
+    expect(nodeKind(g, "ext:SupplierFeed"))->toEqual(Some(ExternalSystem))
     expect(g.nodes->Array.find(n => n.id == "ext:SupplierFeed")->Option.map(n => n.plugin))->toEqual(Some(""))
     // Inbound direction: external → slice (unlabelled — the arrowhead carries the meaning).
-    expect(hasEdge(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn"))->toBe(true)
-    expect(edgeLabel(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn"))->toEqual(None)
+    expect(hasEdge(g, "ext:SupplierFeed", "Shop:ImportProduct", TranslatesIn))->toBe(true)
+    expect(edgeLabel(g, "ext:SupplierFeed", "Shop:ImportProduct", TranslatesIn))->toEqual(None)
   })
 
   testPromise("an outbound translation naming an external system feeds the box", async () => {
@@ -262,10 +263,10 @@ describe("DomainGraph.build", () => {
       ],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(nodeKind(g, "ext:EmailService"))->toEqual(Some("ExternalSystem"))
+    expect(nodeKind(g, "ext:EmailService"))->toEqual(Some(ExternalSystem))
     // Outbound direction: slice → external (unlabelled — the arrowhead carries the meaning).
-    expect(hasEdge(g, "Shop:SendEmail", "ext:EmailService", "translatesOut"))->toBe(true)
-    expect(edgeLabel(g, "Shop:SendEmail", "ext:EmailService", "translatesOut"))->toEqual(None)
+    expect(hasEdge(g, "Shop:SendEmail", "ext:EmailService", TranslatesOut))->toBe(true)
+    expect(edgeLabel(g, "Shop:SendEmail", "ext:EmailService", TranslatesOut))->toEqual(None)
   })
 
   testPromise("translation slices with no external system draw no box (opt-in)", async () => {
@@ -273,7 +274,7 @@ describe("DomainGraph.build", () => {
       ~inboundTranslationSlices=[inbound(~name="ImportProduct", ~target="Product")],
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
-    expect(g.nodes->Array.some(n => n.kind == "ExternalSystem"))->toBe(false)
+    expect(g.nodes->Array.some(n => n.kind == ExternalSystem))->toBe(false)
   })
 
   testPromise("two slices naming the same external system share one deduped box", async () => {
@@ -290,8 +291,8 @@ describe("DomainGraph.build", () => {
     let g = DomainGraph.build(~structures=[("PluginA", a), ("PluginB", b)])
     // One shared box (per-platform dedup by name) with both an out- and an in-edge.
     expect(g.nodes->Array.filter(n => n.id == "ext:EmailService")->Array.length)->toBe(1)
-    expect(hasEdge(g, "PluginA:SendEmailA", "ext:EmailService", "translatesOut"))->toBe(true)
-    expect(hasEdge(g, "ext:EmailService", "PluginB:FromEmail", "translatesIn"))->toBe(true)
+    expect(hasEdge(g, "PluginA:SendEmailA", "ext:EmailService", TranslatesOut))->toBe(true)
+    expect(hasEdge(g, "ext:EmailService", "PluginB:FromEmail", TranslatesIn))->toBe(true)
   })
 
   testPromise("an event produced by two write-sides is one node with two emit edges", async () => {
@@ -303,8 +304,8 @@ describe("DomainGraph.build", () => {
     )
     let g = DomainGraph.build(~structures=[("Shop", shop)])
     expect(g.nodes->Array.filter(n => n.id == "Shop.Touched")->Array.length)->toBe(1)
-    expect(hasEdge(g, "Shop:A", "Shop.Touched", "emits"))->toBe(true)
-    expect(hasEdge(g, "Shop:B", "Shop.Touched", "emits"))->toBe(true)
+    expect(hasEdge(g, "Shop:A", "Shop.Touched", Emits))->toBe(true)
+    expect(hasEdge(g, "Shop:B", "Shop.Touched", Emits))->toBe(true)
   })
 
   testPromise("an extension renders the cross-plugin event flow EP→event→Extension→delegate", async () => {
@@ -321,11 +322,11 @@ describe("DomainGraph.build", () => {
     }
     let g = DomainGraph.build(~structures=[("Catalog", catalog)])
     // EP (owned by Ordering) publishes its event; the Catalog extension consumes it…
-    expect(nodeKind(g, "Ordering:ep:Ordering.Orders"))->toEqual(Some("ExtensionPoint"))
-    expect(hasEdge(g, "Ordering:ep:Ordering.Orders", "Ordering.Orders.ItemOrdered", "publishes"))->toBe(true)
-    expect(hasEdge(g, "Ordering.Orders.ItemOrdered", "Catalog:ext:Ordering.Orders", "consumes"))->toBe(true)
+    expect(nodeKind(g, "Ordering:ep:Ordering.Orders"))->toEqual(Some(ExtensionPoint))
+    expect(hasEdge(g, "Ordering:ep:Ordering.Orders", "Ordering.Orders.ItemOrdered", Publishes))->toBe(true)
+    expect(hasEdge(g, "Ordering.Orders.ItemOrdered", "Catalog:ext:Ordering.Orders", Consumes))->toBe(true)
     // …and delegates to ProductDemand.
-    expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo"))->toBe(true)
+    expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", DelegatesTo))->toBe(true)
     // The protocol event is top-level (empty plugin) so it sits between the boxes…
     let protoEvent =
       g.nodes->Array.find(n => n.id == "Ordering.Orders.ItemOrdered")->Option.getOrThrow
@@ -360,12 +361,12 @@ describe("DomainGraph.build", () => {
     let g = DomainGraph.build(~structures=[("Catalog", catalog)])
     // Extension → the command it creates …
     expect(
-      hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog_ProductDemand_RecordDemand", "delegatesTo"),
+      hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog_ProductDemand_RecordDemand", DelegatesTo),
     )->toBe(true)
     // … the command is handled by the slice (so the full path is Extension → Command → slice) …
-    expect(hasEdge(g, "Catalog_ProductDemand_RecordDemand", "Catalog:ProductDemand", "handles"))->toBe(true)
+    expect(hasEdge(g, "Catalog_ProductDemand_RecordDemand", "Catalog:ProductDemand", Handles))->toBe(true)
     // … and the extension no longer points straight at the slice.
-    expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo"))->toBe(false)
+    expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", DelegatesTo))->toBe(false)
   })
 
   testPromise("an extension with no commands falls back to delegating to the write-side", async () => {
@@ -380,7 +381,7 @@ describe("DomainGraph.build", () => {
       extensions: [extension],
     }
     let g = DomainGraph.build(~structures=[("Catalog", catalog)])
-    expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo"))->toBe(true)
+    expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", DelegatesTo))->toBe(true)
   })
 
   testPromise("an owned extension point is fed by the producers of its source events", async () => {
@@ -405,14 +406,14 @@ describe("DomainGraph.build", () => {
       ~extensionPoints=[ep],
     )
     let g = DomainGraph.build(~structures=[("Catalog", catalog)])
-    expect(nodeKind(g, "Catalog:ep:Catalog.Products"))->toEqual(Some("ExtensionPoint"))
+    expect(nodeKind(g, "Catalog:ep:Catalog.Products"))->toEqual(Some(ExtensionPoint))
     // The producing write-side emits the source event…
-    expect(hasEdge(g, "Catalog:AddProduct", "Catalog.ProductAdded", "emits"))->toBe(true)
+    expect(hasEdge(g, "Catalog:AddProduct", "Catalog.ProductAdded", Emits))->toBe(true)
     // …which feeds the extension point — so EP focus reaches the producer.
-    expect(hasEdge(g, "Catalog.ProductAdded", "Catalog:ep:Catalog.Products", "feeds"))->toBe(true)
+    expect(hasEdge(g, "Catalog.ProductAdded", "Catalog:ep:Catalog.Products", Feeds))->toBe(true)
     // …but the EP has NO inbound command protocol (command = unit), so it routes
     // nothing: no backwards EP → Command edge mislabelling the producer's own command.
-    expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "routesTo"))->toBe(false)
+    expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", RoutesTo))->toBe(false)
   })
 
   testPromise("an extension point with an inbound command protocol routes to its delegate's commands", async () => {
@@ -436,7 +437,7 @@ describe("DomainGraph.build", () => {
       ~extensionPoints=[ep],
     )
     let g = DomainGraph.build(~structures=[("Catalog", catalog)])
-    expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "routesTo"))->toBe(true)
-    expect(hasEdge(g, "Catalog_AddProduct", "Catalog:AddProduct", "handles"))->toBe(true)
+    expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", RoutesTo))->toBe(true)
+    expect(hasEdge(g, "Catalog_AddProduct", "Catalog:AddProduct", Handles))->toBe(true)
   })
 })

package/tests/DomainGraphTest.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DomainGraph$ReventlessGwt from "../src/DomainGraph.res.mjs";
 
@@ -122,7 +123,7 @@ function structure(aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChange
 function hasEdge(g, from, to, kind) {
   return g.edges.some(e => {
     if (e.from === from && e.to === to) {
-      return e.kind === kind;
+      return Primitive_object.equal(e.kind, kind);
     } else {
       return false;
     }
@@ -132,7 +133,7 @@ function hasEdge(g, from, to, kind) {
 function edgeLabel(g, from, to, kind) {
   return Stdlib_Option.flatMap(g.edges.find(e => {
     if (e.from === from && e.to === to) {
-      return e.kind === kind;
+      return Primitive_object.equal(e.kind, kind);
     } else {
       return false;
     }
@@ -154,9 +155,9 @@ globalThis.describe("DomainGraph.build", () => {
     globalThis.expect(nodeKind(g, "Shop:Order")).toEqual("Aggregate");
     globalThis.expect(nodeKind(g, "Shop.Placed")).toEqual("Event");
     globalThis.expect(nodeKind(g, "Shop:OrderView")).toEqual("StateViewSlice");
-    globalThis.expect(hasEdge(g, "Shop_Order_Place", "Shop:Order", "handles")).toBe(true);
-    globalThis.expect(hasEdge(g, "Shop:Order", "Shop.Placed", "emits")).toBe(true);
-    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:OrderView", "projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop_Order_Place", "Shop:Order", "Handles")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:Order", "Shop.Placed", "Emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:OrderView", "Projects")).toBe(true);
   });
   globalThis.test("payload-less events (in `events`, not producedEventTypes) still get an emitted node", async () => {
     let shop = structure([writable("Category", undefined, ["Catalog.Added"], undefined, undefined, [
@@ -177,8 +178,8 @@ globalThis.describe("DomainGraph.build", () => {
       ]]);
     globalThis.expect(nodeKind(g, "Catalog.Added")).toEqual("Event");
     globalThis.expect(nodeKind(g, "Catalog.Archived")).toEqual("Event");
-    globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Added", "emits")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", "emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Added", "Emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", "Emits")).toBe(true);
   });
   globalThis.test("a payload-less event also projects into the aggregate's linked view", async () => {
     let shop = structure([writable("Category", undefined, ["Catalog.Added"], undefined, ["Categories"], [
@@ -197,8 +198,8 @@ globalThis.describe("DomainGraph.build", () => {
         "Catalog",
         shop
       ]]);
-    globalThis.expect(hasEdge(g, "Catalog.Added", "Catalog:Categories", "projects")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog.Archived", "Catalog:Categories", "projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog.Added", "Catalog:Categories", "Projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog.Archived", "Catalog:Categories", "Projects")).toBe(true);
   });
   globalThis.test("an Internal StateViewSlice still gets a node + projects edge (dev graph shows it)", async () => {
     let shop = structure([writable("Order", undefined, ["Shop.Placed"], undefined, undefined, undefined)], undefined, [queryable("AvailableView", ["Shop.Placed"], "Internal")], undefined, undefined, undefined, undefined, undefined);
@@ -207,7 +208,7 @@ globalThis.describe("DomainGraph.build", () => {
         shop
       ]]);
     globalThis.expect(nodeKind(g, "Shop:AvailableView")).toEqual("StateViewSlice");
-    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:AvailableView", "projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:AvailableView", "Projects")).toBe(true);
   });
   globalThis.test("classic linkedViews draws each produced event into the linked read model", async () => {
     let shop = structure([writable("Order", undefined, [
@@ -218,8 +219,8 @@ globalThis.describe("DomainGraph.build", () => {
         "Shop",
         shop
       ]]);
-    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:Orders", "projects")).toBe(true);
-    globalThis.expect(hasEdge(g, "Shop.Shipped", "Shop:Orders", "projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:Orders", "Projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Shipped", "Shop:Orders", "Projects")).toBe(true);
   });
   globalThis.test("automation slices are triggered by their consumed events", async () => {
     let shop = structure([writable("Order", undefined, ["Shop.Placed"], undefined, undefined, undefined)], undefined, undefined, undefined, [automation("Notify", ["Shop.Placed"], undefined, undefined)], undefined, undefined, undefined);
@@ -228,7 +229,7 @@ globalThis.describe("DomainGraph.build", () => {
         shop
       ]]);
     globalThis.expect(nodeKind(g, "Shop:Notify")).toEqual("AutomationSlice");
-    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:Notify", "triggers")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:Notify", "Triggers")).toBe(true);
   });
   globalThis.test("an automation routes to the specific command it raises on its target", async () => {
     let shop = structure(undefined, undefined, undefined, [writable("Ship", [
@@ -239,8 +240,8 @@ globalThis.describe("DomainGraph.build", () => {
         "Shop",
         shop
       ]]);
-    globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_ShipOrder", "delegatesTo")).toBe(true);
-    globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_Place", "delegatesTo")).toBe(false);
+    globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_ShipOrder", "DelegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_Place", "DelegatesTo")).toBe(false);
   });
   globalThis.test("an inbound translation routes to the command it raises on its target", async () => {
     let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Add", "Shop_Product_Add", undefined)], undefined, undefined, undefined, undefined)], undefined, undefined, [inbound("ImportProduct", ["ImportProduct.Add"], "Product", undefined)], undefined);
@@ -249,7 +250,7 @@ globalThis.describe("DomainGraph.build", () => {
         shop
       ]]);
     globalThis.expect(nodeKind(g, "Shop:ImportProduct")).toEqual("InboundTranslationSlice");
-    globalThis.expect(hasEdge(g, "Shop:ImportProduct", "Shop_Product_Add", "delegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:ImportProduct", "Shop_Product_Add", "DelegatesTo")).toBe(true);
   });
   globalThis.test("an outbound translation with a target routes to the command it raises", async () => {
     let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Sync", "Shop_Product_Sync", undefined)], undefined, undefined, undefined, undefined)], undefined, [outbound("ExportProduct", ["Shop.Added"], ["ExportProduct.Sync"], "Product", undefined)], undefined, undefined);
@@ -257,7 +258,7 @@ globalThis.describe("DomainGraph.build", () => {
         "Shop",
         shop
       ]]);
-    globalThis.expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", "delegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", "DelegatesTo")).toBe(true);
   });
   globalThis.test("an inbound translation naming an external system draws a box feeding it", async () => {
     let shop = structure(undefined, undefined, undefined, undefined, undefined, undefined, [inbound("ImportProduct", ["ImportProduct.Add"], "Product", "SupplierFeed")], undefined);
@@ -267,8 +268,8 @@ globalThis.describe("DomainGraph.build", () => {
       ]]);
     globalThis.expect(nodeKind(g, "ext:SupplierFeed")).toEqual("ExternalSystem");
     globalThis.expect(Stdlib_Option.map(g.nodes.find(n => n.id === "ext:SupplierFeed"), n => n.plugin)).toEqual("");
-    globalThis.expect(hasEdge(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn")).toBe(true);
-    globalThis.expect(edgeLabel(g, "ext:SupplierFeed", "Shop:ImportProduct", "translatesIn")).toEqual(undefined);
+    globalThis.expect(hasEdge(g, "ext:SupplierFeed", "Shop:ImportProduct", "TranslatesIn")).toBe(true);
+    globalThis.expect(edgeLabel(g, "ext:SupplierFeed", "Shop:ImportProduct", "TranslatesIn")).toEqual(undefined);
   });
   globalThis.test("an outbound translation naming an external system feeds the box", async () => {
     let shop = structure(undefined, undefined, undefined, undefined, undefined, [outbound("SendEmail", ["Shop.Placed"], undefined, Primitive_option.some(undefined), "EmailService")], undefined, undefined);
@@ -277,8 +278,8 @@ globalThis.describe("DomainGraph.build", () => {
         shop
       ]]);
     globalThis.expect(nodeKind(g, "ext:EmailService")).toEqual("ExternalSystem");
-    globalThis.expect(hasEdge(g, "Shop:SendEmail", "ext:EmailService", "translatesOut")).toBe(true);
-    globalThis.expect(edgeLabel(g, "Shop:SendEmail", "ext:EmailService", "translatesOut")).toEqual(undefined);
+    globalThis.expect(hasEdge(g, "Shop:SendEmail", "ext:EmailService", "TranslatesOut")).toBe(true);
+    globalThis.expect(edgeLabel(g, "Shop:SendEmail", "ext:EmailService", "TranslatesOut")).toEqual(undefined);
   });
   globalThis.test("translation slices with no external system draw no box (opt-in)", async () => {
     let shop = structure(undefined, undefined, undefined, undefined, undefined, undefined, [inbound("ImportProduct", undefined, "Product", undefined)], undefined);
@@ -302,8 +303,8 @@ globalThis.describe("DomainGraph.build", () => {
       ]
     ]);
     globalThis.expect(g.nodes.filter(n => n.id === "ext:EmailService").length).toBe(1);
-    globalThis.expect(hasEdge(g, "PluginA:SendEmailA", "ext:EmailService", "translatesOut")).toBe(true);
-    globalThis.expect(hasEdge(g, "ext:EmailService", "PluginB:FromEmail", "translatesIn")).toBe(true);
+    globalThis.expect(hasEdge(g, "PluginA:SendEmailA", "ext:EmailService", "TranslatesOut")).toBe(true);
+    globalThis.expect(hasEdge(g, "ext:EmailService", "PluginB:FromEmail", "TranslatesIn")).toBe(true);
   });
   globalThis.test("an event produced by two write-sides is one node with two emit edges", async () => {
     let shop = structure([
@@ -315,8 +316,8 @@ globalThis.describe("DomainGraph.build", () => {
         shop
       ]]);
     globalThis.expect(g.nodes.filter(n => n.id === "Shop.Touched").length).toBe(1);
-    globalThis.expect(hasEdge(g, "Shop:A", "Shop.Touched", "emits")).toBe(true);
-    globalThis.expect(hasEdge(g, "Shop:B", "Shop.Touched", "emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:A", "Shop.Touched", "Emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:B", "Shop.Touched", "Emits")).toBe(true);
   });
   globalThis.test("an extension renders the cross-plugin event flow EP→event→Extension→delegate", async () => {
     let extension_delegateNames = ["ProductDemand"];
@@ -354,9 +355,9 @@ globalThis.describe("DomainGraph.build", () => {
         catalog
       ]]);
     globalThis.expect(nodeKind(g, "Ordering:ep:Ordering.Orders")).toEqual("ExtensionPoint");
-    globalThis.expect(hasEdge(g, "Ordering:ep:Ordering.Orders", "Ordering.Orders.ItemOrdered", "publishes")).toBe(true);
-    globalThis.expect(hasEdge(g, "Ordering.Orders.ItemOrdered", "Catalog:ext:Ordering.Orders", "consumes")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Ordering:ep:Ordering.Orders", "Ordering.Orders.ItemOrdered", "Publishes")).toBe(true);
+    globalThis.expect(hasEdge(g, "Ordering.Orders.ItemOrdered", "Catalog:ext:Ordering.Orders", "Consumes")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "DelegatesTo")).toBe(true);
     let protoEvent = Stdlib_Option.getOrThrow(g.nodes.find(n => n.id === "Ordering.Orders.ItemOrdered"), undefined);
     globalThis.expect(protoEvent.plugin).toBe("");
     let ext = Stdlib_Option.getOrThrow(g.nodes.find(n => n.id === "Catalog:ext:Ordering.Orders"), undefined);
@@ -397,9 +398,9 @@ globalThis.describe("DomainGraph.build", () => {
         "Catalog",
         catalog
       ]]);
-    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog_ProductDemand_RecordDemand", "delegatesTo")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog_ProductDemand_RecordDemand", "Catalog:ProductDemand", "handles")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo")).toBe(false);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog_ProductDemand_RecordDemand", "DelegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog_ProductDemand_RecordDemand", "Catalog:ProductDemand", "Handles")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "DelegatesTo")).toBe(false);
   });
   globalThis.test("an extension with no commands falls back to delegating to the write-side", async () => {
     let extension_delegateNames = ["ProductDemand"];
@@ -436,7 +437,7 @@ globalThis.describe("DomainGraph.build", () => {
         "Catalog",
         catalog
       ]]);
-    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "DelegatesTo")).toBe(true);
   });
   globalThis.test("an owned extension point is fed by the producers of its source events", async () => {
     let ep_delegateNames = ["CatalogDcbEventLog"];
@@ -454,9 +455,9 @@ globalThis.describe("DomainGraph.build", () => {
         catalog
       ]]);
     globalThis.expect(nodeKind(g, "Catalog:ep:Catalog.Products")).toEqual("ExtensionPoint");
-    globalThis.expect(hasEdge(g, "Catalog:AddProduct", "Catalog.ProductAdded", "emits")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog.ProductAdded", "Catalog:ep:Catalog.Products", "feeds")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "routesTo")).toBe(false);
+    globalThis.expect(hasEdge(g, "Catalog:AddProduct", "Catalog.ProductAdded", "Emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog.ProductAdded", "Catalog:ep:Catalog.Products", "Feeds")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "RoutesTo")).toBe(false);
   });
   globalThis.test("an extension point with an inbound command protocol routes to its delegate's commands", async () => {
     let ep_delegateNames = ["AddProduct"];
@@ -473,8 +474,8 @@ globalThis.describe("DomainGraph.build", () => {
         "Catalog",
         catalog
       ]]);
-    globalThis.expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "routesTo")).toBe(true);
-    globalThis.expect(hasEdge(g, "Catalog_AddProduct", "Catalog:AddProduct", "handles")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "RoutesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog_AddProduct", "Catalog:AddProduct", "Handles")).toBe(true);
   });
 });