@reventlessdev/reventless-spec 3.0.0-alpha.137 → 3.0.0-alpha.139

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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.139 (2026-09-21)
+
+### Features
+
+* **spec:** one Id type per identity ([203be38](https://github.com/ReventlessDev/reventless-core/commit/203be389b9047db0a7a0294fe3c1c04ba5119965))
+* **spec:** the runtime reads identities ([417c5f6](https://github.com/ReventlessDev/reventless-core/commit/417c5f613b031a08c7849a81c75de6a8bbeb841b))
+
+
+# 3.0.0-alpha.138 (2026-09-20)
+
+* fix(spec)!: let an explicit partition tag declare an identity the name cannot ([01d82c0](https://github.com/ReventlessDev/reventless-core/commit/01d82c0714a31f31d55c466eae9100cf4dcc85f0))
+
+### BREAKING CHANGES
+
+* a @partitionTag on a field whose name is not *Id / *Ids was
+inert and now takes effect, so such a slice's partition key — and with it its
+storage key, fence and read scope — changes to the annotated field. Nothing else
+moves: the annotation was doing nothing before, so no slice that resolved a key
+resolves a different one.
+
+
+
 # 3.0.0-alpha.137 (2026-09-20)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.137",
+  "version": "3.0.0-alpha.139",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/components/DcbScopeInference.res

@@ -34,8 +34,28 @@ The three rules (over the representation):
    on `ProductAdded`) are payload ⇒ not indexed ⇒ the sibling-leak GSI write never
    happens.
 */
-/** A `*Id` / `*Ids`-shaped field, identified by name only (no schema, no tag flag). */
-type idField = {name: string, isList: bool}
+/** A field the slice graph treats as an entity identity.
+
+    Normally that is a `*Id` / `*Ids`-shaped name — the convention is the signal,
+    and this module stays schema-agnostic by taking the name alone.
+
+    `byTag` marks the exception: an identity the *name* does not declare, which an
+    adapter recognised from an explicit `@partitionTag`. A domain's own identifier
+    is often not suffixed — `sku`, `isbn`, `vin` — and without this the annotation
+    naming one would be extracted as a hint and then dropped, because `seedOf`
+    only honours a hint already among the produced keys. So the escape hatch would
+    have worked for every field except the ones that need it.
+
+    It is carried rather than folded in because removing the annotation removes
+    the identity, which is exactly what the redundancy check has to know: a hint
+    inference cannot reach without it is never redundant. */
+type idField = {
+  name: string,
+  isList: bool,
+  byTag?: bool,
+  /** The tag key, when the field's type says it (an identity) rather than its name. */
+  key?: string,
+}
 
 /** One variant arm: its constructor name and the `*Id` fields it carries. */
 type eventShape = {eventType: string, idFields: array<idField>}
@@ -83,10 +103,13 @@ type derived = {
 /**
 The tag key for a `*Id`-shaped field. A plural `*Ids: array<string>` shares the
 singular producer's key (trailing `s` stripped — `productIds` -> `productId`);
-a scalar `*Id` uses the field name verbatim. Mirrors the PPX's `*Ids` rule.
+a scalar `*Id` uses the field name verbatim. Mirrors the PPX's `*Ids` rule. An
+identity-typed field carries its key, whatever it is called.
 */
 let tagKeyOf = (f: idField): string =>
-  if f.isList && f.name->String.endsWith("s") {
+  if f.key->Option.isSome {
+    f.key->Option.getUnsafe
+  } else if f.isList && f.name->String.endsWith("s") {
     f.name->String.slice(~start=0, ~end=f.name->String.length - 1)
   } else {
     f.name

package/src/components/DcbScopeInference.res.mjs

@@ -6,7 +6,9 @@ import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 
 function tagKeyOf(f) {
-  if (f.isList && f.name.endsWith("s")) {
+  if (Stdlib_Option.isSome(f.key)) {
+    return f.key;
+  } else if (f.isList && f.name.endsWith("s")) {
     return f.name.slice(0, f.name.length - 1 | 0);
   } else {
     return f.name;

package/src/components/DcbTag.res

@@ -126,6 +126,23 @@ let dcbTagKeyOverrideId: S.Metadata.Id.t<string> = S.Metadata.Id.make(
   ~name="tagKeyOverride",
 )
 
+/**
+Type-preserving forms of the markers below, for a field whose schema is not a
+bare `S.string` — an identity (`OrderId.schema->DcbTag.mark`) keeps its type and
+its semantic, and the tag key follows the identity unless `markForKey` says
+otherwise.
+*/
+let mark = (schema: S.t<'a>): S.t<'a> => schema->S.Metadata.set(~id=dcbTagId, true)
+
+let markForKey = (schema: S.t<'a>, ~key: string): S.t<'a> =>
+  schema->mark->S.Metadata.set(~id=dcbTagKeyOverrideId, key)
+
+let markPartition = (schema: S.t<'a>): S.t<'a> =>
+  schema->mark->S.Metadata.set(~id=dcbPartitionTagId, true)
+
+let markCrossPartition = (schema: S.t<'a>): S.t<'a> =>
+  schema->mark->S.Metadata.set(~id=dcbCrossPartitionId, true)
+
 /**
 A sury string schema annotated as a DCB tag field.
 
@@ -148,7 +165,7 @@ and array element types.
 ```
 */
 let string: S.t<string> =
-  S.string->S.Metadata.set(~id=dcbTagId, true)
+  S.string->mark
 
 /**
 A sury string schema annotated as a DCB tag field with an explicit tag-key override.
@@ -171,8 +188,7 @@ annotations carrying a string payload.
 // productIds: ["p1", "p2"] → tags [{key: "productId", value: "p1"}, {key: "productId", value: "p2"}]
 ```
 */
-let stringForKey = (~key: string): S.t<string> =>
-  S.string->S.Metadata.set(~id=dcbTagId, true)->S.Metadata.set(~id=dcbTagKeyOverrideId, key)
+let stringForKey = (~key: string): S.t<string> => S.string->markForKey(~key)
 
 /**
 A sury int schema annotated as a DCB tag field.
@@ -198,7 +214,7 @@ optional (auto-selected) when only one tagged field exists.
 ```
 */
 let partition: S.t<string> =
-  S.string->S.Metadata.set(~id=dcbTagId, true)->S.Metadata.set(~id=dcbPartitionTagId, true)
+  S.string->markPartition
 
 /**
 A sury string schema annotated as a DCB tag field with *cross-partition* read
@@ -224,7 +240,7 @@ entities but can be partitioned by only one (course-subscription capacity,
 ```
 */
 let crossPartition: S.t<string> =
-  S.string->S.Metadata.set(~id=dcbTagId, true)->S.Metadata.set(~id=dcbCrossPartitionId, true)
+  S.string->markCrossPartition
 
 /**
 A sury string schema marking a field as a composite partition key member.
@@ -355,19 +371,21 @@ let isCrossPartitionTaggedArray = (fieldSchema: S.t<unknown>) =>
 
 /**
 Resolves the tag key for a scalar tagged field: the explicit override metadata if
-present, otherwise the field name.
+present, else the field's identity, otherwise the field name.
 */
 let resolveTagKey = (fieldName: string, fieldSchema: S.t<unknown>): string =>
-  S.Metadata.get(fieldSchema, ~id=dcbTagKeyOverrideId)->Option.getOr(fieldName)
+  switch S.Metadata.get(fieldSchema, ~id=dcbTagKeyOverrideId) {
+  | Some(key) => key
+  | None => fieldSchema->Semantic.identityKey->Option.getOr(fieldName)
+  }
 
 /**
-Resolves the tag key for an array tagged field. The override metadata sits on the
-inner element schema; falls back to the field name when no override is set.
+Resolves the tag key for an array tagged field. The override metadata and the
+identity sit on the inner element schema; falls back to the field name.
 */
 let resolveArrayTagKey = (fieldName: string, fieldSchema: S.t<unknown>): string =>
   switch fieldSchema {
-  | Array({additionalItems: Schema(itemSchema)}) =>
-    S.Metadata.get(itemSchema, ~id=dcbTagKeyOverrideId)->Option.getOr(fieldName)
+  | Array({additionalItems: Schema(itemSchema)}) => resolveTagKey(fieldName, itemSchema)
   | _ => fieldName
   }
 
@@ -970,51 +988,33 @@ let buildQueryFromCommand = (
 // --- Extract tagged field names from event schema ---
 
 /**
-Extracts the names of all DCB-tagged fields across all variants of an event schema.
-
-Returns a sorted, deduplicated list of field names annotated with
-`@s.matches(DcbTag.string)` or `@s.matches(DcbTag.int)`.
+The tag keys of all DCB-tagged fields across all variants of an event schema,
+resolved as the tags themselves are, so an index is named after the key its tags
+carry. Sorted and deduplicated.
 
 For `CatalogEventLog.event` returns `["categoryId", "productId"]`.
 */
 let extractTaggedFields = (schema: S.t<'event>): array<string> => {
-  switch schema->toUnknownSchema {
-  | AnyOf({anyOf}) =>
-    // For union types, collect tagged fields from all variants
-    let allFields = anyOf->Array.flatMap(variantSchema =>
-      switch variantSchema {
-      | Object({properties}) =>
-        properties
-        ->Dict.toArray
-        ->Array.filterMap(((fieldName, fieldSchema)) =>
-          if isTagged(fieldSchema) {
-            Some(fieldName)
-          } else {
-            None
-          }
-        )
-      | _ => []
-      }
-    )
-    // Deduplicate field names using Set
-    let fieldSet = Set.make()
-    allFields->Array.forEach(field => fieldSet->Set.add(field))
-    Array.fromIterator(fieldSet->Set.values)->Array.toSorted((a, b) => String.compare(a, b))
-
-  | Object({properties}) =>
+  let ofProperties = properties =>
     properties
     ->Dict.toArray
     ->Array.filterMap(((fieldName, fieldSchema)) =>
-      if isTagged(fieldSchema) {
-        Some(fieldName)
-      } else {
-        None
+      isTagged(fieldSchema) ? Some(resolveTagKey(fieldName, fieldSchema)) : None
+    )
+  let keys = switch schema->toUnknownSchema {
+  | AnyOf({anyOf}) =>
+    anyOf->Array.flatMap(variantSchema =>
+      switch variantSchema {
+      | Object({properties}) => ofProperties(properties)
+      | _ => []
       }
     )
-    ->Array.toSorted((a, b) => String.compare(a, b))
-
+  | Object({properties}) => ofProperties(properties)
   | _ => []
   }
+  let seen = Set.make()
+  keys->Array.forEach(k => seen->Set.add(k))
+  Array.fromIterator(seen->Set.values)->Array.toSorted((a, b) => String.compare(a, b))
 }
 
 /**
@@ -1084,29 +1084,56 @@ which is this module's half of the split.
 */
 let idFieldsOfProperties = (properties: dict<S.t<unknown>>): array<DcbScopeInference.idField> => {
   let isIdName = (name: string) => name->String.endsWith("Ids") || name->String.endsWith("Id")
-  properties
-  ->Dict.toArray
-  ->Array.flatMap(((name, fieldSchema)) =>
+  // An explicit `@partitionTag` declares an identity the naming convention cannot
+  // express — a domain's own identifier is often unsuffixed (`sku`, `isbn`).
+  // Without this the hint is extracted and then ignored, since `seedOf` honours
+  // only a hint already among the produced keys, so the escape hatch would work
+  // for every field except the ones that need it. Flagged, not folded in: taking
+  // the annotation away takes the identity with it, which is what the redundancy
+  // check has to be able to tell.
+  // A field's type outranks its name: `buyer: CustomerId.t` is keyed `customerId`,
+  // and so is `orderId: CustomerId.t`. An explicit `@dcbTag("k")` still wins.
+  let typedKey = (fieldSchema: S.t<unknown>, isList) => {
+    let valueSchema = switch (isList, fieldSchema) {
+    | (true, Array({additionalItems: Schema(item)})) => item
+    | _ => fieldSchema
+    }
+    valueSchema->Semantic.identityKey->Option.map(_ => resolveTagKey("", valueSchema))
+  }
+  let untypedIdentity = (name, fieldSchema, isList) =>
     if isIdName(name) {
-      let isList = switch fieldSchema {
-      | Array(_) => true
-      | _ => false
-      }
-      [{DcbScopeInference.name, isList}]
+      Some({DcbScopeInference.name, isList})
+    } else if isPartitionTag(fieldSchema) {
+      Some({DcbScopeInference.name, isList, byTag: true})
     } else {
+      None
+    }
+  let identity = (name, fieldSchema, isList) =>
+    switch typedKey(fieldSchema, isList) {
+    | Some(key) => Some({DcbScopeInference.name, isList, key})
+    | None => untypedIdentity(name, fieldSchema, isList)
+    }
+  properties
+  ->Dict.toArray
+  ->Array.flatMap(((name, fieldSchema)) => {
+    let isList = switch fieldSchema {
+    | Array(_) => true
+    | _ => false
+    }
+    switch identity(name, fieldSchema, isList) {
+    | Some(f) => [f]
+    | None =>
       switch nestedRecordProperties(fieldSchema) {
       | Some((nested, nestedIsList)) =>
         nested
         ->Dict.toArray
-        ->Array.filterMap(((nestedName, _)) =>
-          isIdName(nestedName)
-            ? Some({DcbScopeInference.name: nestedName, isList: nestedIsList})
-            : None
+        ->Array.filterMap(((nestedName, nestedSchema)) =>
+          identity(nestedName, nestedSchema, nestedIsList)
         )
       | None => []
       }
     }
-  )
+  })
 }
 
 /**
@@ -1135,7 +1162,8 @@ let eventShapesOfSchema = (schema: S.t<'a>): array<DcbScopeInference.eventShape>
 // --- Partition tag derivation ---
 
 /**
-Extracts field names annotated with `@s.matches(DcbTag.partition)` from an event schema.
+Extracts the tag keys of fields annotated with `@s.matches(DcbTag.partition)` from an
+event schema: the field name, unless an override or an identity says otherwise.
 */
 let extractPartitionTagFields = (schema: S.t<'event>): array<string> => {
   switch schema->toUnknownSchema {
@@ -1147,7 +1175,7 @@ let extractPartitionTagFields = (schema: S.t<'event>): array<string> => {
         ->Dict.toArray
         ->Array.filterMap(((fieldName, fieldSchema)) =>
           if isPartitionTag(fieldSchema) {
-            Some(fieldName)
+            Some(resolveTagKey(fieldName, fieldSchema))
           } else {
             None
           }
@@ -1164,7 +1192,7 @@ let extractPartitionTagFields = (schema: S.t<'event>): array<string> => {
     ->Dict.toArray
     ->Array.filterMap(((fieldName, fieldSchema)) =>
       if isPartitionTag(fieldSchema) {
-        Some(fieldName)
+        Some(resolveTagKey(fieldName, fieldSchema))
       } else {
         None
       }

package/src/components/DcbTag.res.mjs

@@ -32,17 +32,33 @@ let dcbCompositePartitionMemberId = Sury.$Metadata_Id_make("dcb", "compositePart
 
 let dcbTagKeyOverrideId = Sury.$Metadata_Id_make("dcb", "tagKeyOverride");
 
+function mark(schema) {
+  return Sury.$Metadata_set(schema, dcbTagId, true);
+}
+
+function markForKey(schema, key) {
+  return Sury.$Metadata_set(Sury.$Metadata_set(schema, dcbTagId, true), dcbTagKeyOverrideId, key);
+}
+
+function markPartition(schema) {
+  return Sury.$Metadata_set(Sury.$Metadata_set(schema, dcbTagId, true), dcbPartitionTagId, true);
+}
+
+function markCrossPartition(schema) {
+  return Sury.$Metadata_set(Sury.$Metadata_set(schema, dcbTagId, true), dcbCrossPartitionId, true);
+}
+
 let string = Sury.$Metadata_set(Sury.string, dcbTagId, true);
 
 function stringForKey(key) {
-  return Sury.$Metadata_set(Sury.$Metadata_set(Sury.string, dcbTagId, true), dcbTagKeyOverrideId, key);
+  return markForKey(Sury.string, key);
 }
 
 let int = Sury.$Metadata_set(Sury.int, dcbTagId, true);
 
-let partition = Sury.$Metadata_set(Sury.$Metadata_set(Sury.string, dcbTagId, true), dcbPartitionTagId, true);
+let partition = markPartition(Sury.string);
 
-let crossPartition = Sury.$Metadata_set(Sury.$Metadata_set(Sury.string, dcbTagId, true), dcbCrossPartitionId, true);
+let crossPartition = markCrossPartition(Sury.string);
 
 function compositePartitionMember(position, sepOpt) {
   let sep = sepOpt !== undefined ? sepOpt : "/";
@@ -169,7 +185,12 @@ function isCrossPartitionTaggedArray(fieldSchema) {
 }
 
 function resolveTagKey(fieldName, fieldSchema) {
-  return Stdlib_Option.getOr(Sury.$Metadata_get(fieldSchema, dcbTagKeyOverrideId), fieldName);
+  let key = Sury.$Metadata_get(fieldSchema, dcbTagKeyOverrideId);
+  if (key !== undefined) {
+    return key;
+  } else {
+    return Stdlib_Option.getOr(Semantic$Reventless.identityKey(fieldSchema), fieldName);
+  }
 }
 
 function resolveArrayTagKey(fieldName, fieldSchema) {
@@ -180,7 +201,7 @@ function resolveArrayTagKey(fieldName, fieldSchema) {
   if (itemSchema === "strip" || itemSchema === "strict") {
     return fieldName;
   } else {
-    return Stdlib_Option.getOr(Sury.$Metadata_get(itemSchema, dcbTagKeyOverrideId), fieldName);
+    return resolveTagKey(fieldName, itemSchema);
   }
 }
 
@@ -627,33 +648,34 @@ function buildQueryFromCommand(eventTypes, schema, value, tagKeysByEventTypeOpt,
 }
 
 function extractTaggedFields(schema) {
+  let ofProperties = properties => Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldSchema = param[1];
+    if (Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbTagId))) {
+      return resolveTagKey(param[0], fieldSchema);
+    }
+  });
+  let keys;
   switch (schema.type) {
     case "object" :
-      return Stdlib_Array.filterMap(Object.entries(schema.properties), param => {
-        if (Stdlib_Option.isSome(Sury.$Metadata_get(param[1], dcbTagId))) {
-          return param[0];
-        }
-      }).toSorted(Primitive_string.compare);
+      keys = ofProperties(schema.properties);
+      break;
     case "anyOf" :
-      let allFields = schema.anyOf.flatMap(variantSchema => {
+      keys = schema.anyOf.flatMap(variantSchema => {
         if (variantSchema.type === "object") {
-          return Stdlib_Array.filterMap(Object.entries(variantSchema.properties), param => {
-            if (Stdlib_Option.isSome(Sury.$Metadata_get(param[1], dcbTagId))) {
-              return param[0];
-            }
-          });
+          return ofProperties(variantSchema.properties);
         } else {
           return [];
         }
       });
-      let fieldSet = new Set();
-      allFields.forEach(field => {
-        fieldSet.add(field);
-      });
-      return Array.from(fieldSet.values()).toSorted(Primitive_string.compare);
+      break;
     default:
-      return [];
+      keys = [];
   }
+  let seen = new Set();
+  keys.forEach(k => {
+    seen.add(k);
+  });
+  return Array.from(seen.values()).toSorted(Primitive_string.compare);
 }
 
 function crossPartitionKeysOfProperties(properties) {
@@ -703,31 +725,53 @@ function idFieldsOfProperties(properties) {
       return name.endsWith("Id");
     }
   };
+  let typedKey = (fieldSchema, isList) => {
+    let valueSchema;
+    if (isList && fieldSchema.type === "array") {
+      let item = fieldSchema.additionalItems;
+      valueSchema = item === "strip" || item === "strict" ? fieldSchema : item;
+    } else {
+      valueSchema = fieldSchema;
+    }
+    return Stdlib_Option.map(Semantic$Reventless.identityKey(valueSchema), param => resolveTagKey("", valueSchema));
+  };
+  let identity = (name, fieldSchema, isList) => {
+    let key = typedKey(fieldSchema, isList);
+    if (key !== undefined) {
+      return {
+        name: name,
+        isList: isList,
+        key: key
+      };
+    } else if (isIdName(name)) {
+      return {
+        name: name,
+        isList: isList
+      };
+    } else if (Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbPartitionTagId))) {
+      return {
+        name: name,
+        isList: isList,
+        byTag: true
+      };
+    } else {
+      return;
+    }
+  };
   return Object.entries(properties).flatMap(param => {
     let fieldSchema = param[1];
-    let name = param[0];
-    if (isIdName(name)) {
-      let isList;
-      isList = fieldSchema.type === "array";
-      return [{
-          name: name,
-          isList: isList
-        }];
+    let isList;
+    isList = fieldSchema.type === "array";
+    let f = identity(param[0], fieldSchema, isList);
+    if (f !== undefined) {
+      return [f];
     }
     let match = nestedRecordProperties(fieldSchema);
     if (match === undefined) {
       return [];
     }
     let nestedIsList = match[1];
-    return Stdlib_Array.filterMap(Object.entries(match[0]), param => {
-      let nestedName = param[0];
-      if (isIdName(nestedName)) {
-        return {
-          name: nestedName,
-          isList: nestedIsList
-        };
-      }
-    });
+    return Stdlib_Array.filterMap(Object.entries(match[0]), param => identity(param[0], param[1], nestedIsList));
   });
 }
 
@@ -768,16 +812,18 @@ function extractPartitionTagFields(schema) {
   switch (schema.type) {
     case "object" :
       return Stdlib_Array.filterMap(Object.entries(schema.properties), param => {
-        if (Stdlib_Option.isSome(Sury.$Metadata_get(param[1], dcbPartitionTagId))) {
-          return param[0];
+        let fieldSchema = param[1];
+        if (Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbPartitionTagId))) {
+          return resolveTagKey(param[0], fieldSchema);
         }
       });
     case "anyOf" :
       let allFields = schema.anyOf.flatMap(variantSchema => {
         if (variantSchema.type === "object") {
           return Stdlib_Array.filterMap(Object.entries(variantSchema.properties), param => {
-            if (Stdlib_Option.isSome(Sury.$Metadata_get(param[1], dcbPartitionTagId))) {
-              return param[0];
+            let fieldSchema = param[1];
+            if (Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbPartitionTagId))) {
+              return resolveTagKey(param[0], fieldSchema);
             }
           });
         } else {
@@ -1038,6 +1084,10 @@ export {
   dcbCrossPartitionId,
   dcbCompositePartitionMemberId,
   dcbTagKeyOverrideId,
+  mark,
+  markForKey,
+  markPartition,
+  markCrossPartition,
   string,
   stringForKey,
   int,

package/src/components/DcbValidation.res

@@ -501,29 +501,62 @@ let validatePartitionHintsVsInference = (
   shapes->Array.forEach(s =>
     switch s.partitionHint {
     | Some(hint) if DcbScopeInference.producedKeys(s)->Array.includes(hint) =>
+      // "Without the annotation" has to mean without everything the annotation
+      // brought. A field that is an identity only because it carries the tag
+      // (`byTag`) stops being one when the tag goes, so dropping only the hint
+      // would ask whether inference reaches a key it can no longer see — and
+      // answer yes, reporting a load-bearing annotation as removable.
+      let withoutTag = (e: DcbScopeInference.eventShape) => {
+        ...e,
+        idFields: e.idFields->Array.filter(f => f.byTag != Some(true)),
+      }
+      // A hint naming an identity that exists only because of the annotation is
+      // **necessary**, and fits neither verdict this check was built to give.
+      // Called redundant it would be removed and the key would vanish; called
+      // contradictory it would be "corrected" to whatever name-shaped field
+      // happens to sit beside it — which is the author's choice overruled, not a
+      // mistake found. Both readings come from assuming the field is an identity
+      // either way, which is true only when the name says so.
+      let declaredByTag =
+        s.produced->Array.some(e =>
+          e.idFields->Array.some(f => f.name == hint && f.byTag == Some(true))
+        )
       let unaided = DcbScopeInference.resolvePartitions(
-        shapes->Array.map(o => o.sliceName == s.sliceName ? {...o, partitionHint: None} : o),
+        shapes->Array.map(o =>
+          o.sliceName == s.sliceName
+            ? {
+                ...o,
+                partitionHint: None,
+                produced: o.produced->Array.map(withoutTag),
+                consumed: o.consumed->Array.map(withoutTag),
+              }
+            : o
+        ),
       )
-      switch unaided.partitionBySlice->Dict.get(s.sliceName) {
-      | Some(inferred) if inferred == hint =>
-        redundancies->Array.push({
-          sliceName: s.sliceName,
-          message: `@partitionTag ${hint} is what inference derives without it — the annotation is redundant and can be removed.`,
-        })
-      | Some(inferred) =>
-        contradictions->Array.push({
-          sliceName: s.sliceName,
-          message: `@partitionTag names ${hint}, but inference derives ${inferred} from the slice graph — ${hint} is read from another entity. Remove the annotation, or move it to ${inferred}.`,
-        })
-      | None =>
-        let candidates = unaided.candidatesBySlice->Dict.get(s.sliceName)->Option.getOr([])
-        if !(candidates->Array.includes(hint)) {
+      if declaredByTag {
+        ()
+      } else {
+        switch unaided.partitionBySlice->Dict.get(s.sliceName) {
+        | Some(inferred) if inferred == hint =>
+          redundancies->Array.push({
+            sliceName: s.sliceName,
+            message: `@partitionTag ${hint} is what inference derives without it — the annotation is redundant and can be removed.`,
+          })
+        | Some(inferred) =>
           contradictions->Array.push({
             sliceName: s.sliceName,
-            message: `@partitionTag names ${hint}, which this slice only reads as a reference to another entity (candidates: ${candidates->Array.join(
-                ", ",
-              )}). Move the annotation to the slice's own key.`,
+            message: `@partitionTag names ${hint}, but inference derives ${inferred} from the slice graph — ${hint} is read from another entity. Remove the annotation, or move it to ${inferred}.`,
           })
+        | None =>
+          let candidates = unaided.candidatesBySlice->Dict.get(s.sliceName)->Option.getOr([])
+          if !(candidates->Array.includes(hint)) {
+            contradictions->Array.push({
+              sliceName: s.sliceName,
+              message: `@partitionTag names ${hint}, which this slice only reads as a reference to another entity (candidates: ${candidates->Array.join(
+                  ", ",
+                )}). Move the annotation to the slice's own key.`,
+            })
+          }
         }
       }
     | _ => ()

package/src/components/DcbValidation.res.mjs

@@ -437,14 +437,30 @@ function validatePartitionHintsVsInference(shapes) {
     if (!DcbScopeInference$Reventless.producedKeys(s).includes(hint)) {
       return;
     }
+    let withoutTag = e => ({
+      eventType: e.eventType,
+      idFields: e.idFields.filter(f => Primitive_object.notequal(f.byTag, true))
+    });
+    let declaredByTag = s.produced.some(e => e.idFields.some(f => {
+      if (f.name === hint) {
+        return Primitive_object.equal(f.byTag, true);
+      } else {
+        return false;
+      }
+    }));
     let unaided = DcbScopeInference$Reventless.resolvePartitions(shapes.map(o => {
       if (o.sliceName !== s.sliceName) {
         return o;
       }
       let newrecord = {...o};
       newrecord.partitionHint = undefined;
+      newrecord.produced = o.produced.map(withoutTag);
+      newrecord.consumed = o.consumed.map(withoutTag);
       return newrecord;
     }));
+    if (declaredByTag) {
+      return;
+    }
     let inferred = unaided.partitionBySlice[s.sliceName];
     if (inferred !== undefined) {
       if (inferred === hint) {

package/src/components/Reference.res

@@ -39,6 +39,32 @@ let to_ = (~plugin=?, ~key=?, entity: string): S.t<string> => {
   }
 }
 
+/**
+`to_` for a field whose schema is not a bare `S.string`: the schema keeps its
+type, and an identity it carries moves onto the reference's target rather than
+being overwritten.
+*/
+let mark = (schema: S.t<'a>, ~plugin=?, ~key=?, entity: string): S.t<'a> => {
+  let identity = Semantic.identityKey(schema)
+  let base =
+    schema
+    ->S.Metadata.set(~id=DcbTag.dcbTagId, true)
+    ->Semantic.mark(~id=Semantic.Id.reference, ~payload=ReferenceTo({entity, plugin, ?identity}))
+  switch key {
+  | Some(k) => base->S.Metadata.set(~id=DcbTag.dcbTagKeyOverrideId, k)
+  | None => base
+  }
+}
+
+/** `toWithoutDcbTag` for a field whose schema is not a bare `S.string`. */
+let markWithoutDcbTag = (schema: S.t<'a>, ~plugin=?, entity: string): S.t<'a> => {
+  let identity = Semantic.identityKey(schema)
+  schema->Semantic.mark(
+    ~id=Semantic.Id.reference,
+    ~payload=ReferenceTo({entity, plugin, ?identity}),
+  )
+}
+
 /** Returns the reference target if the schema carries `Reference.to_(...)` metadata. */
 let getTarget = (schema: S.t<unknown>): option<target> =>
   switch Semantic.get(schema) {

package/src/components/Reference.res.mjs

@@ -21,6 +21,35 @@ function to_(plugin, key, entity) {
   }
 }
 
+function mark(schema, plugin, key, entity) {
+  let identity = Semantic$Reventless.identityKey(schema);
+  let base = Semantic$Reventless.mark(Sury.$Metadata_set(schema, DcbTag$Reventless.dcbTagId, true), Semantic$Reventless.Id.reference, {
+    TAG: "ReferenceTo",
+    _0: {
+      entity: entity,
+      plugin: plugin,
+      identity: identity
+    }
+  });
+  if (key !== undefined) {
+    return Sury.$Metadata_set(base, DcbTag$Reventless.dcbTagKeyOverrideId, key);
+  } else {
+    return base;
+  }
+}
+
+function markWithoutDcbTag(schema, plugin, entity) {
+  let identity = Semantic$Reventless.identityKey(schema);
+  return Semantic$Reventless.mark(schema, Semantic$Reventless.Id.reference, {
+    TAG: "ReferenceTo",
+    _0: {
+      entity: entity,
+      plugin: plugin,
+      identity: identity
+    }
+  });
+}
+
 function getTarget(schema) {
   let match = Semantic$Reventless.get(schema);
   if (match === undefined) {
@@ -92,6 +121,8 @@ function toWithoutDcbTag(plugin, entity) {
 
 export {
   to_,
+  mark,
+  markWithoutDcbTag,
   getTarget,
   getFieldTarget,
   collectFieldTargets,

package/src/semantic/Semantic.res

@@ -10,7 +10,7 @@ The payload is a typed variant because the vocabulary is framework-owned and
 closed — which also keeps `Reference.getTarget` total.
 */
 /** Which entity a reference field points to. */
-type referenceTarget = {entity: string, plugin: option<string>}
+type referenceTarget = {entity: string, plugin: option<string>, identity?: string}
 
 /** Which object store the value lives in. `plugin` is absent for the declaring
     plugin's own store; `threshold` is `@offload`'s per-field byte cut, `None`
@@ -50,6 +50,8 @@ type payload =
   | ReferenceTo(referenceTarget)
   | StoredIn(storeTarget)
   | MemberOf(memberTarget)
+  /** Which identity an id is: named by its key (`orderId`). */
+  | IdentityOf({key: string})
 
 /** A field's semantic: the vocabulary id, plus its detail. */
 type t = {id: string, payload: payload}
@@ -111,6 +113,10 @@ module Id = {
   // The first composite that is a union rather than an object. Collapses fields,
   // so adopting it changes the wire and rebuilds a derived view.
   let geolocation = "geolocation"
+
+  // Which entity an id names, carried by the type `Id.Make` produces. A string on
+  // the wire, so adopting one changes nothing stored.
+  let identity = "identity"
 }
 
 /** One transparent-string semantic: a `semantic/` module whose `type t` is a
@@ -242,6 +248,16 @@ let rec getFrom = (schema: S.t<unknown>): option<t> =>
 
 let get = (fieldSchema: S.t<'a>): option<t> => fieldSchema->S.castToUnknown->getFrom
 
+/** The identity a field's value is (`orderId`), read through `option<…>`. A
+    reference to an identity carries it on its target, since a schema holds one
+    semantic. */
+let identityKey = (fieldSchema: S.t<'a>): option<string> =>
+  switch get(fieldSchema) {
+  | Some({payload: IdentityOf({key})}) => Some(key)
+  | Some({payload: ReferenceTo({?identity})}) => identity
+  | _ => None
+  }
+
 /** Whether a field's schema carries this specific semantic. */
 let has = (fieldSchema: S.t<'a>, ~id: string): bool =>
   switch get(fieldSchema) {

package/src/semantic/Semantic.res.mjs

@@ -51,7 +51,8 @@ let Id = {
   dateRange: "dateRange",
   geoPoint: "geoPoint",
   lifecycleTrail: "lifecycleTrail",
-  geolocation: "geolocation"
+  geolocation: "geolocation",
+  identity: "identity"
 };
 
 let brandedStrings = [
@@ -205,6 +206,25 @@ function getFrom(schema) {
 
 let get = getFrom;
 
+function identityKey(fieldSchema) {
+  let match = getFrom(fieldSchema);
+  if (match === undefined) {
+    return;
+  }
+  let match$1 = match.payload;
+  if (typeof match$1 !== "object") {
+    return;
+  }
+  switch (match$1.TAG) {
+    case "ReferenceTo" :
+      return match$1._0.identity;
+    case "IdentityOf" :
+      return match$1.key;
+    default:
+      return;
+  }
+}
+
 function has(fieldSchema, id) {
   let s = getFrom(fieldSchema);
   if (s !== undefined) {
@@ -225,6 +245,7 @@ export {
   unionVariant,
   getFrom,
   get,
+  identityKey,
   has,
 }
 /* semanticId Not a pure module */

package/src/types/Id.res

@@ -2,8 +2,9 @@
 Module type for aggregate and read model identifiers.
 
 Every Reventless component declares its own `Id` module satisfying this type.
-The abstract `type t` prevents accidentally mixing identifiers from different
-aggregates at compile time.
+The abstract `type t` keeps ids apart from plain strings, but not from each
+other: every alias of `Id.String` (which is what the ppx injects) is the same
+type. Only `Id.Make` gives an entity an id type of its own.
 
 @example
 ```rescript
@@ -62,8 +63,9 @@ module StringPure = {
 /**
 A sealed string-based `Id.T` implementation for use in production aggregate specs.
 
-Unlike `StringPure`, the `t` type is abstract, preventing accidental cross-aggregate
-ID mixing. Use `Id.StringPure` in tests when string literals are needed.
+Unlike `StringPure`, the `t` type is abstract, so an id is not a plain string. It is
+sealed once, so every alias shares one type; use `Id.Make` for an id type per
+entity. Use `Id.StringPure` in tests when string literals are needed.
 
 @example
 ```rescript
@@ -73,3 +75,31 @@ let name = "Category"
 ```
 */
 module String: T = StringPure
+
+/** An `Id.T` that names one entity, by its key (`orderId`). */
+module type Identity = {
+  include T with type input = string
+  let key: string
+}
+
+/**
+One distinct type per identity. Each application yields a fresh abstract `t`, so
+an `OrderId.t` cannot be passed where a `CustomerId.t` is expected. A string on
+the wire; the schema carries the `identity` semantic, which is how the runtime
+knows which entity a field names whatever the field is called.
+
+@example
+```rescript
+// src/Order/OrderId.res
+include Reventless.Id.Make({let key = "orderId"})
+```
+*/
+module Make = (
+  K: {
+    let key: string
+  },
+): Identity => {
+  include StringPure
+  let key = K.key
+  let schema = schema->Semantic.mark(~id=Semantic.Id.identity, ~payload=IdentityOf({key: K.key}))
+}

package/src/types/Id.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Sury from "sury";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Semantic$Reventless from "../semantic/Semantic.res.mjs";
 
 let schema = Sury.string;
 
@@ -12,6 +13,21 @@ let StringPure = {
   cmp: cmp
 };
 
+function Make(K) {
+  let schema$1 = Semantic$Reventless.mark(schema, Semantic$Reventless.Id.identity, {
+    TAG: "IdentityOf",
+    key: K.key
+  });
+  return {
+    schema: schema$1,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: cmp,
+    key: K.key
+  };
+}
+
 function String_make(prim) {
   return prim;
 }
@@ -35,5 +51,6 @@ let $$String = {
 export {
   StringPure,
   $$String,
+  Make,
 }
 /* schema Not a pure module */