@reventlessdev/reventless-core 3.0.0-alpha.266 → 3.0.0-alpha.268

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.268 (2026-09-21)
+
+### Bug Fixes
+
+* **core:** a creating command's own id derives no reference ([58a921c](https://github.com/ReventlessDev/reventless-core/commit/58a921c84352f6522e7c175387927e32365aa94a))
+
+
+# 3.0.0-alpha.267 (2026-09-21)
+
+### Bug Fixes
+
+* **core:** an event mapping that commands its own source no longer hangs ([d30ce6b](https://github.com/ReventlessDev/reventless-core/commit/d30ce6b360707d933732fa2c90aba49c03dda006))
+* feat(spec)!: typed projection keys ([fc6a018](https://github.com/ReventlessDev/reventless-core/commit/fc6a01811ba788f3289e84a435a09f77fa627e1a))
+### Features
+
+* **core:** references derived from identities, and identity checks ([7cb1376](https://github.com/ReventlessDev/reventless-core/commit/7cb1376e56cdb4e4d5ab5954cd97fd37fd3ba258))
+
+### BREAKING CHANGES
+
+* a projection that keys a row by a payload `string`, or uses
+the envelope id as a `string`, converts explicitly with
+`Target.Id.makeFromString` / `Source.Id.toString`. `StateChangeSlice.Spec` no
+longer requires `module Id`.
+
+
+
 # 3.0.0-alpha.266 (2026-09-21)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.266",
+  "version": "3.0.0-alpha.268",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -31,19 +31,19 @@
     "@reventlessdev/rescript-effect": "0.1.0-alpha.33",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.12",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.12",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.12",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.21",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.12",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.37",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.167",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.139"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.168",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.140"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.80"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.81"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Projection.res

@@ -6,16 +6,6 @@ module Set = Belt.Set.String
 
 let log = Logger.fromEnv()
 
-module Mapping = {
-  module MakeGenericSource = (Mapping: Reventless.Projection.Mapping): (
-    Mapper.GenericSource with type t = Mapping.sourceEvent
-  ) => {
-    let name = Mapping.sourceName
-    type t = Mapping.sourceEvent
-    let decode' = json => json->Message.decodeEvent'(S.string, Mapping.sourceEventSchema)
-  }
-}
-
 // Lazy: the message thunk (and any `stateToString` it triggers) runs only when
 // debug logging is enabled, so projection actions don't serialize state on the
 // hot path at the default Info level.

package/src/Projection.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Sury from "sury";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -22,18 +21,6 @@ import * as LogFormat$ReventlessCore from "./util/LogFormat.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
-function MakeGenericSource(Mapping) {
-  let decode$p = json => Message$ReventlessCore.decodeEvent$p(json, Sury.string, Mapping.sourceEventSchema);
-  return {
-    name: Mapping.sourceName,
-    decode$p: decode$p
-  };
-}
-
-let Mapping = {
-  MakeGenericSource: MakeGenericSource
-};
-
 function logAction(makeStr) {
   log.debugLazy("Projection", makeStr);
 }
@@ -786,7 +773,6 @@ let $$Set;
 export {
   $$Set,
   log,
-  Mapping,
   logAction,
   overlaysFor,
   applyOverlays,

package/src/ProjectionMapper.res

@@ -34,8 +34,14 @@ module Make = (
       module GenericMapping = {
         let sourceName = M.sourceName
         let acceptedTags = Reventless.DcbTag.extractAllVariantNames(M.sourceEventSchema)
-        module Source = Projection.Mapping.MakeGenericSource(M)
-        let project = MapperNto1.makeGenericMap(Source.decode', M.project)
+        // The storage edge: the envelope and the table carry strings, the
+        // projection typed ids — the same strings, decoded and encoded here.
+        let decode = json => json->Message.decodeEvent'(M.SourceId.schema, M.sourceEventSchema)
+        let project = MapperNto1.makeGenericMap(decode, msg =>
+          msg
+          ->M.project
+          ->Reventless.Projection.mapActionId(~to_=M.targetIdToString, ~from=M.targetIdFromString)
+        )
       }
       module(GenericMapping: Mapping)
     })

package/src/ProjectionMapper.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
 import * as Message$ReventlessCore from "./Message.res.mjs";
 import * as MapperNto1$ReventlessCore from "./MapperNto1.res.mjs";
-import * as Projection$ReventlessCore from "./Projection.res.mjs";
 
 function MakeGenericTargetFromStateTarget(StateTarget) {
   let decode = json => Message$ReventlessCore.decode(json, StateTarget.stateSchema);
@@ -27,8 +27,8 @@ function Make(Target) {
     };
     let mappings = Mappings.mappings.map(M => {
       let acceptedTags = DcbTag$Reventless.extractAllVariantNames(M.sourceEventSchema);
-      let Source = Projection$ReventlessCore.Mapping.MakeGenericSource(M);
-      let project = MapperNto1$ReventlessCore.makeGenericMap(Source.decode$p, M.project);
+      let decode = json => Message$ReventlessCore.decodeEvent$p(json, M.SourceId.schema, M.sourceEventSchema);
+      let project = MapperNto1$ReventlessCore.makeGenericMap(decode, msg => Projection$Reventless.mapActionId(M.project(msg), M.targetIdToString, M.targetIdFromString));
       return {
         sourceName: M.sourceName,
         acceptedTags: acceptedTags,

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -7,7 +7,7 @@ import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/Plugin
 
 let pluginId = "Platform";
 
-let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, undefined, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
+let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(undefined, true, undefined, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
 
 let pluginAggregate_producedEventTypes = [];
 

package/src/admin/UiFragmentRegistry/StateView/UiFragments.res.mjs

@@ -40,6 +40,8 @@ let name = "UiFragments";
 
 let Id;
 
+let Key;
+
 let subIdConfig;
 
 let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateView/UiFragments.res.mjs";
@@ -54,6 +56,7 @@ export {
   stateSchema,
   consumedEventSchema,
   config,
+  Key,
   subIdConfig,
   moduleUrl,
   authorization,

package/src/components/EventMapper/EventMapper_Builder.res

@@ -79,8 +79,26 @@ module Make = (
           ~opts,
         )
 
+        // Not awaited, for the reason AutomationSlice_Builder gives: a mapping that
+        // commands its own source (Placed → Ship) appends an event this handler's
+        // fiber must dequeue, while the fiber is still waiting on the command. The
+        // bus then waits on itself, and so does the request that started it. Only
+        // the local runtime runs this handler; a deployed one uses its entry point.
+        let publishJsonsDetached = jsons => {
+          let _ = publishJsons(jsons)->Promise.catch(exn => {
+            log.error(
+              ~comp="EventMapper",
+              `detached publish error: ${exn
+                ->JsExn.fromException
+                ->Option.flatMap(JsExn.message)
+                ->Option.getOr("unknown")}`,
+            )
+            Promise.resolve()
+          })
+          Promise.resolve()
+        }
         module EventCollectorHandler = EventMapper_Callback.MakeEventCollectorHandler({
-          let publishJsons = publishJsons
+          let publishJsons = publishJsonsDetached
           let count = count
           let addToCounterTarget = addToCounterTarget
           let commonEventsHandler = CounterHandler.commonEventsHandler

package/src/components/EventMapper/EventMapper_Builder.res.mjs

@@ -1,9 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Counter$ReventlessCore from "../Counter/Counter.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
@@ -53,8 +55,15 @@ function Make(Target) {
             kind: "EventMapper",
             name: name
           }, opts);
+          let publishJsonsDetached = jsons => {
+            Stdlib_Promise.$$catch(publishJsons(jsons), exn => {
+              log.error("EventMapper", undefined, `detached publish error: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown"));
+              return Promise.resolve();
+            });
+            return Promise.resolve();
+          };
           let EventCollectorHandler = EventMapper_Callback$ReventlessCore.MakeEventCollectorHandler({
-            publishJsons: publishJsons,
+            publishJsons: publishJsonsDetached,
             count: param.count,
             addToCounterTarget: param.addToCounterTarget,
             commonEventsHandler: CounterHandler.commonEventsHandler

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -124,7 +124,17 @@ module Make = (
                   let (eventType, dataDict) = rawEvent->Message.splitMessage
                   switch decoder.decode(~eventType, ~data=dataDict) {
                   | Some(event) =>
-                    let actions = try Projection.project({event, meta, recordedAt}) catch {
+                    let actions = try Projection.project({
+                      event,
+                      meta,
+                      recordedAt,
+                    })->Array.map(
+                      Reventless.Projection.mapActionId(
+                        _,
+                        ~to_=Spec.Key.toString,
+                        ~from=Spec.Key.makeFromString,
+                      ),
+                    ) catch {
                     | exn =>
                       let errMsg =
                         exn

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -12,6 +12,7 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
@@ -108,7 +109,7 @@ function Make(RuntimeEnvironment) {
                   event: Primitive_option.valFromOption(event),
                   meta: meta,
                   recordedAt: recordedAt
-                });
+                }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
               } catch (raw_exn) {
                 let exn$1 = Primitive_exceptions.internalToException(raw_exn);
                 let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -40,7 +40,14 @@ module Make = (
       | Some(event) =>
         idx := idx.contents + 1
         let id = raw.tags->Array.get(0)->Option.map(tag => tag.value)->Option.getOr("?")
-        let actions = Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})
+        let actions =
+          Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})->Array.map(
+            Reventless.Projection.mapActionId(
+              _,
+              ~to_=Spec.Key.toString,
+              ~from=Spec.Key.makeFromString,
+            ),
+          )
         let actionsStr = LogFormat.actionNames(actions)
         EffectLogger.logInfo(
           ~comp,

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -6,6 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
 import * as Projection$ReventlessCore from "../../Projection.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
@@ -32,7 +33,7 @@ function Make(Spec) {
           event: event,
           meta: raw.meta,
           recordedAt: raw.recordedAt
-        });
+        }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
         allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, raw.meta.time, Spec.stateSchema)));

package/src/plugin/component/Plugin_Structure.res

@@ -587,31 +587,96 @@ let labelFieldsFromStateSchema = (
 // Mirrors the command walk for emitted events. Module-level so Platform_Admin,
 // whose components never pass through `make`, derives its defs the same way.
 
+/**
+The plugin's views by the identity each is keyed by, which is what lets a typed
+id find the view that lists it without an `@ref`. `report` says where the type
+cannot decide: several views keyed by the identity, none, or an `@ref` naming a
+view keyed by another.
+*/
+type identityViews = {
+  viewsByKey: dict<array<string>>,
+  viewNames: array<string>,
+  report: string => unit,
+}
+
+// The reference a typed id implies, and the check on one it declares.
+let identityReference = (
+  identityViews: identityViews,
+  ~fieldName,
+  fieldSchema: S.t<unknown>,
+  declared: array<(string, Reventless.Reference.target)>,
+): array<(string, Reventless.Reference.target)> =>
+  switch Reventless.Semantic.fieldIdentityKey(fieldSchema) {
+  | None => declared
+  | Some(key) =>
+    let keyed = identityViews.viewsByKey->Dict.get(key)->Option.getOr([])
+    switch declared {
+    | [] =>
+      switch keyed {
+      | [view] => [(fieldName, {Reventless.Semantic.entity: view, plugin: None, identity: key})]
+      | [] =>
+        identityViews.report(
+          `${fieldName} is a ${key}, and no view in this plugin is keyed by it, so it references nothing. List the identity in a view, or reference another plugin's with @ref("Plugin.View").`,
+        )
+        []
+      | several =>
+        identityViews.report(
+          `${fieldName} is a ${key}, and ${several->Array.join(
+              " and ",
+            )} are all keyed by it. Say which it references with @ref.`,
+        )
+        []
+      }
+    | _ =>
+      declared->Array.forEach(((_, target)) =>
+        if (
+          target.plugin->Option.isNone &&
+          identityViews.viewNames->Array.includes(target.entity) &&
+          !(keyed->Array.includes(target.entity))
+        ) {
+          identityViews.report(
+            `${fieldName} is a ${key}, and its @ref names ${target.entity}, which is not keyed by it.`,
+          )
+        }
+      )
+      declared
+    }
+  }
+
 // A variant's cross-entity references, shared by the command and event walks.
 // `getFieldTarget`, not `getTarget`: an `array<string>` field declares it on the
 // element schema.
-let extractReferences = (properties: dict<S.t<unknown>>): array<Reventless.Plugin.fieldReference> =>
+let extractReferences = (
+  ~identityViews: option<identityViews>=?,
+  // The id a creating command mints. Its identity names the row the command
+  // brings into existence, not one it refers to, so nothing is derived for it.
+  ~minted: option<string>=?,
+  properties: dict<S.t<unknown>>,
+): array<Reventless.Plugin.fieldReference> =>
   properties
   ->Dict.toArray
-  ->Array.flatMap(((fieldName, fieldSchema)) =>
+  ->Array.flatMap(((fieldName, fieldSchema)) => {
     // `collectFieldTargets`, not `getFieldTarget`: a reference declared on a field
     // of a record the field holds (an order line's `productId`) is one this
     // command declares, and it arrives named by its own path. Commands and events
     // both come through here, which is what stops one of them learning about
     // nesting and the other not.
-    Reventless.Reference.collectFieldTargets(fieldName, fieldSchema)->Array.map(((
-      path,
-      target,
-    )): Reventless.Plugin.fieldReference => {
+    let declared = Reventless.Reference.collectFieldTargets(fieldName, fieldSchema)
+    let targets = switch identityViews {
+    | Some(views) if minted != Some(fieldName) =>
+      identityReference(views, ~fieldName, fieldSchema, declared)
+    | _ => declared
+    }
+    targets->Array.map(((path, target)): Reventless.Plugin.fieldReference => {
       Reventless.Plugin.fieldName: path,
       entity: target.entity,
       plugin: target.plugin,
     })
-  )
+  })
 
-let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
+let toEventDef = (~identityViews=?, v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
   let mkDef = (~variantName, ~properties) => {
-    let references = extractReferences(properties)
+    let references = extractReferences(~identityViews?, properties)
 
     (
       {
@@ -640,10 +705,12 @@ let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
   }
 }
 
-let extractEventDefs = (eventSchema: S.t<unknown>): array<Reventless.Plugin.eventDef> =>
+let extractEventDefs = (~identityViews=?, eventSchema: S.t<unknown>): array<
+  Reventless.Plugin.eventDef,
+> =>
   switch eventSchema {
-  | AnyOf({anyOf}) => anyOf->Array.filterMap(toEventDef)
-  | _ => toEventDef(eventSchema)->Option.mapOr([], def => [def])
+  | AnyOf({anyOf}) => anyOf->Array.filterMap(v => toEventDef(~identityViews?, v))
+  | _ => toEventDef(~identityViews?, eventSchema)->Option.mapOr([], def => [def])
   }
 
 // Errors walk identically to events; only the def type differs, so a consumer
@@ -750,6 +817,7 @@ let annotateArgTypes = (schema: JSON.t, argTypes: dict<string>): JSON.t => {
 }
 
 let toCommandDef = (
+  ~identityViews: option<identityViews>=?,
   ~isAggregate,
   ~partitionKey: option<string>=?,
   ~mutationFieldFor: string => string,
@@ -785,7 +853,6 @@ let toCommandDef = (
       ~variantName,
       properties,
     )
-    let references = extractReferences(properties)
     // Evaluated against a synthetic value per constructor, the same shape the
     // resolver builds at call time: a payload-bearing variant compiles to
     // `{TAG, ...}`, a payload-less one to a bare string.
@@ -849,6 +916,11 @@ let toCommandDef = (
     | None => Reventless.Transition.targetState(declared)
     }
     let level = derived->Option.flatMap(d => d.level)->Option.getOr(guessedLevel)
+    let references = extractReferences(
+      ~identityViews?,
+      ~minted=?level == Reventless.Plugin.Collection ? aggregateIdField : None,
+      properties,
+    )
     // API-exposed iff the whole command isn't @noApi and this variant
     // isn't in its @noApi-variants set — mirrors the API-generation filter
     // (Plugin_Helpers / PluginBaseFragment). Drives the event-graph API badge.
@@ -923,6 +995,7 @@ let toCommandDef = (
 }
 
 let extractCommandDefs = (
+  ~identityViews: option<identityViews>=?,
   ~isAggregate,
   ~partitionKey: option<string>=?,
   ~mutationFieldFor: string => string,
@@ -935,6 +1008,7 @@ let extractCommandDefs = (
   | AnyOf({anyOf}) =>
     anyOf->Array.filterMap(v =>
       toCommandDef(
+        ~identityViews?,
         ~isAggregate,
         ~partitionKey?,
         ~mutationFieldFor,
@@ -948,6 +1022,7 @@ let extractCommandDefs = (
   | _ =>
     // Single-variant command types compile to a bare Object schema, not a Union.
     toCommandDef(
+      ~identityViews?,
       ~isAggregate,
       ~partitionKey?,
       ~mutationFieldFor,
@@ -1536,6 +1611,53 @@ let make = (
   }
   let partitionFailures = []
 
+  // Each view's key as an identity: a read model's `Spec.Id` when it is one, else
+  // the key field's type, else the key field's name, so a view keyed by an untyped
+  // `productId` still lists the `productId` identity.
+  let keyIdentityOf = (stateSchema: S.t<unknown>, idField: option<string>) =>
+    idField->Option.map(field =>
+      switch stateSchema {
+      | Object({properties}) =>
+        properties->Dict.get(field)->Option.flatMap(Reventless.Semantic.identityKey)
+      | _ => None
+      }->Option.getOr(field)
+    )
+  let viewKeys = Array.concat(
+    readModels->Array.mapWithIndex((
+      module(R: ReventlessInfra.ReadModel.T with type api = api and type role = role),
+      i,
+    ) => {
+      let def = readModelDefs->Array.getUnsafe(i)
+      let key = switch R.Spec.Id.schema->Reventless.Semantic.identityKey {
+      | Some(_) as declared => declared
+      | None => keyIdentityOf(R.Spec.stateSchema->S.castToUnknown, def.idField)
+      }
+      (R.Spec.name, key)
+    }),
+    stateViewSlices->Array.mapWithIndex((module(SVS: ReventlessInfra.StateViewSlice.T), i) => {
+      let def = stateViewDefs->Array.getUnsafe(i)
+      (SVS.Spec.name, keyIdentityOf(SVS.Spec.stateSchema->S.castToUnknown, def.idField))
+    }),
+  )
+  let viewsByKey: dict<array<string>> = Dict.make()
+  viewKeys->Array.forEach(((view, key)) =>
+    key->Option.forEach(k =>
+      viewsByKey->Dict.set(k, viewsByKey->Dict.get(k)->Option.getOr([])->Array.concat([view]))
+    )
+  )
+  // Warned rather than refused, like the key-field gap: the field still decodes,
+  // it just links nowhere. Once per message, since a field recurs across variants.
+  let reported: Set.t<string> = Set.make()
+  let identityViews = {
+    viewsByKey,
+    viewNames: viewKeys->Array.map(((view, _)) => view),
+    report: message =>
+      if !(reported->Set.has(message)) {
+        reported->Set.add(message)
+        log.warn(~comp="Plugin_Structure", `${name}: ${message}`)
+      },
+  }
+
   let stateChangeDefs =
     stateChangeSlices->Array.mapWithIndex((module(SCS: ReventlessInfra.StateChangeSlice.T), i) => {
       let (_, produced) = scsProduced->Array.getUnsafe(i)
@@ -1545,6 +1667,7 @@ let make = (
         {
           Reventless.Plugin.name: SCS.Spec.name,
           commands: extractCommandDefs(
+            ~identityViews,
             ~isAggregate=false,
             ~partitionKey=?partitionBySlice->Dict.get(SCS.Spec.name),
             ~mutationFieldFor=variantName =>
@@ -1563,7 +1686,7 @@ let make = (
           consumedEventTypes: consumed,
           linkedViews: linkedSvsFor(produced),
           consistencyRead: consistencyReadFor(consumed),
-          events: extractEventDefs(SCS.Spec.eventSchema->S.castToUnknown),
+          events: extractEventDefs(~identityViews, SCS.Spec.eventSchema->S.castToUnknown),
           errors: extractErrorDefs(SCS.Spec.errorSchema->S.castToUnknown),
           chapter: chapterOf(SCS.Spec.name),
         }: Reventless.Plugin.writableDef
@@ -1580,6 +1703,7 @@ let make = (
       {
         Reventless.Plugin.name: A.Spec.name,
         commands: extractCommandDefs(
+          ~identityViews,
           ~isAggregate=true,
           ~mutationFieldFor=variantName =>
             Api_Naming.aggregateMutationField(
@@ -1596,7 +1720,7 @@ let make = (
         consumedEventTypes: [],
         linkedViews: Array.concat(linkedSvsFor(produced), linkedReadModelsFor(A.Spec.name)),
         consistencyRead: None,
-        events: extractEventDefs(A.Spec.eventSchema->S.castToUnknown),
+        events: extractEventDefs(~identityViews, A.Spec.eventSchema->S.castToUnknown),
         errors: extractErrorDefs(A.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(A.Spec.name),
       }: Reventless.Plugin.writableDef