@reventlessdev/reventless-core 3.0.0-alpha.262 → 3.0.0-alpha.264

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -4,6 +4,8 @@ module type T = {
   let handleCommands: (
     ~tagKeysByEventType: Dict.t<array<string>>=?,
     ~crossPartitionTagKeys: array<string>=?,
+    /** This slice's partition within its boundary; inferred from the slice alone when absent. */
+    ~partitionTag: Reventless.DcbTag.derivedPartitionTag=?,
     DcbEventLog.operations,
     Stream.t<
       CommandTopic.topicItem<Message.command'<Reventless.Id.String.t, Spec.command>>,
@@ -74,18 +76,32 @@ module Make = (
     {eventType, data: JSON.Object(data), tags, meta}
   }
 
-  // Computed once at functor init — used to extract entityId for publishJsonsAndWait outcomes.
-  let derivedPartitionTag = Reventless.DcbTag.derivePartitionTag([
-    (Spec.name, Behavior.moduleUrl, Spec.eventSchema->S.castToUnknown),
-  ])
+  // The partition inferred from this slice alone, for callers that do not thread
+  // the boundary's. Lazy and non-throwing: it only names ids in logs and outcomes,
+  // and a slice that needs its siblings to resolve must not fail to load for that.
+  let slicePartitionTag = Lazy.make(() =>
+    try Some(
+      Reventless.DcbTag.deriveSlicePartition({
+        name: Spec.name,
+        commandSchema: Spec.commandSchema->S.castToUnknown,
+        consumedEventSchema: Spec.consumedEventSchema->S.castToUnknown,
+        eventSchema: Spec.eventSchema->S.castToUnknown,
+        moduleUrl: Spec.moduleUrl,
+      }),
+    ) catch {
+    | _ => None
+    }
+  )
 
   // Extracts the entity id of a read event from its own tags, for logging
   // which events the decision model was built from. Prefers this slice's
-  // partition key (derived from the produced event), but consumed events from
-  // other sources are tagged by their own key (e.g. CatalogProductSynced →
-  // productId, not this slice's orderId), so fall back to the read event's own
-  // tag value(s) instead of logging no id.
-  let readEventId = (tags: array<Reventless.DcbTag.tag>): option<string> => {
+  // partition key, but consumed events from other sources are tagged by their
+  // own key (e.g. CatalogProductSynced → productId, not this slice's orderId),
+  // so fall back to the read event's own tag value(s) instead of logging no id.
+  let readEventId = (
+    ~partitionTag: option<Reventless.DcbTag.derivedPartitionTag>,
+    tags: array<Reventless.DcbTag.tag>,
+  ): option<string> => {
     let ownTagValues = () => {
       let vals =
         tags->Array.reduce([], (acc, t: Reventless.DcbTag.tag) =>
@@ -93,15 +109,14 @@ module Make = (
         )
       vals->Array.length == 0 ? None : Some(vals->Array.join(","))
     }
-    switch derivedPartitionTag {
-    | Simple(pt) =>
-      switch tags->Array.findMap((t: Reventless.DcbTag.tag) =>
-        t.key == pt.key ? Some(t.value) : None
-      ) {
-      | Some(v) => Some(v)
-      | None => ownTagValues()
+    switch partitionTag {
+    | Some(Composite(spec)) => Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
+    | Some(pt) =>
+      switch tags->Reventless.DcbTag.partitionValueOfTags(pt) {
+      | "" => ownTagValues()
+      | v => Some(v)
       }
-    | Composite(spec) => Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
+    | None => ownTagValues()
     }
   }
 
@@ -147,6 +162,7 @@ module Make = (
   let handleSingleCommand = (
     ~tagKeysByEventType,
     ~crossPartitionTagKeys,
+    ~partitionTag,
     dcbEventLog: DcbEventLog.operations,
     command': Message.command'<Reventless.Id.String.t, Spec.command>,
   ) => {
@@ -192,11 +208,12 @@ module Make = (
     EffectLogger.logInfo(~comp, `query: ${queryDetail}`)->Effect.runSync
 
     // Extract the entity ID from the command for use in Accepted outcomes.
-    let entityId = switch derivedPartitionTag {
-    | Simple(pt) => Reventless.DcbTag.getPartitionTagValue(query, pt)
-    | Composite(spec) =>
+    let entityId = switch partitionTag {
+    | Some(Reventless.DcbTag.Composite(spec)) =>
       let tags = Reventless.DcbTag.extractTags(Spec.commandSchema, command'.command)
       Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
+    | Some(Simple(pt)) => Reventless.DcbTag.getPartitionTagValue(query, pt)
+    | Some(ByEventType(_)) | None => None
     }
 
     // Fail closed: a query that can't be serialized yields `None`, not the empty
@@ -267,7 +284,12 @@ module Make = (
           ~eventType=raw.eventType,
           ~data=raw.data->JSON.Decode.object->Option.getOr(Dict.make()),
         )
-        decoded->Option.map(event => (event, raw.position, raw.eventType, readEventId(raw.tags)))
+        decoded->Option.map(event => (
+          event,
+          raw.position,
+          raw.eventType,
+          readEventId(~partitionTag, raw.tags),
+        ))
       })
       ->Stream.flatMap(opt =>
         switch opt {
@@ -474,14 +496,20 @@ module Make = (
   let handleCommands = (
     ~tagKeysByEventType=Dict.make(),
     ~crossPartitionTagKeys=[],
+    ~partitionTag=?,
     dcbEventLog,
     stream,
-  ) =>
+  ) => {
+    let partitionTag = switch partitionTag {
+    | Some(_) => partitionTag
+    | None => slicePartitionTag->Lazy.get
+    }
     stream
     ->Stream.mapEffect(({ReventlessInfra.CommandTopic.reference: reference, command}) =>
       handleSingleCommand(
         ~tagKeysByEventType,
         ~crossPartitionTagKeys,
+        ~partitionTag,
         dcbEventLog,
         command,
       )->Effect.map(result =>
@@ -492,4 +520,5 @@ module Make = (
       )
     )
     ->Stream.runCollect
+  }
 }

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -2,6 +2,7 @@
 
 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_Lazy from "@rescript/runtime/lib/es6/Stdlib_Lazy.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -22,12 +23,20 @@ function Make(Spec) {
     let comp = `StateChangeSlice(` + Spec.name + `)`;
     let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
     let queryEventTypes = decoder.eventTypes;
-    let derivedPartitionTag = DcbTag$Reventless.derivePartitionTag([[
-        Spec.name,
-        Behavior.moduleUrl,
-        Spec.eventSchema
-      ]]);
-    let readEventId = tags => {
+    let slicePartitionTag = Stdlib_Lazy.make(() => {
+      try {
+        return DcbTag$Reventless.deriveSlicePartition({
+          name: Spec.name,
+          commandSchema: Spec.commandSchema,
+          consumedEventSchema: Spec.consumedEventSchema,
+          eventSchema: Spec.eventSchema,
+          moduleUrl: Spec.moduleUrl
+        });
+      } catch (exn) {
+        return;
+      }
+    });
+    let readEventId = (partitionTag, tags) => {
       let ownTagValues = () => {
         let vals = Stdlib_Array.reduce(tags, [], (acc, t) => {
           if (acc.includes(t.value)) {
@@ -42,24 +51,26 @@ function Make(Spec) {
           return vals.join(",");
         }
       };
-      if (derivedPartitionTag.TAG !== "Simple") {
-        return DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
+      if (partitionTag === undefined) {
+        return ownTagValues();
       }
-      let pt = derivedPartitionTag._0;
-      let v = Stdlib_Array.findMap(tags, t => {
-        if (t.key === pt.key) {
-          return t.value;
-        }
-      });
-      if (v !== undefined) {
-        return v;
-      } else {
+      switch (partitionTag.TAG) {
+        case "Composite" :
+          return DcbTag$Reventless.getCompositePartitionKeyValue(tags, partitionTag._0);
+        case "Simple" :
+        case "ByEventType" :
+          break;
+      }
+      let v = DcbTag$Reventless.partitionValueOfTags(tags, partitionTag);
+      if (v === "") {
         return ownTagValues();
+      } else {
+        return v;
       }
     };
     let projectionCache = Lru$ReventlessCore.make(100);
     let resetCache = () => Lru$ReventlessCore.clear(projectionCache);
-    let handleSingleCommand = (tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, command$p) => {
+    let handleSingleCommand = (tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLog, command$p) => {
       let cmdJson = Message$ReventlessCore.commandJsonOfCommand$p(Id$Reventless.$$String.toString, Spec.commandSchema, command$p);
       Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, cmdJson.commandJson, `handling command: ` + LogFormat$ReventlessCore.cmdDetailNoId(cmdJson)));
       let query = DcbTag$Reventless.buildQueryFromCommand(queryEventTypes, Spec.commandSchema, command$p.command, tagKeysByEventType, crossPartitionTagKeys);
@@ -76,11 +87,21 @@ function Make(Spec) {
       }).join(" OR ");
       Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `query: ` + queryDetail));
       let entityId;
-      if (derivedPartitionTag.TAG === "Simple") {
-        entityId = DcbTag$Reventless.getPartitionTagValue(query, derivedPartitionTag._0);
+      if (partitionTag !== undefined) {
+        switch (partitionTag.TAG) {
+          case "Simple" :
+            entityId = DcbTag$Reventless.getPartitionTagValue(query, partitionTag._0);
+            break;
+          case "Composite" :
+            let tags = DcbTag$Reventless.extractTags(Spec.commandSchema, command$p.command);
+            entityId = DcbTag$Reventless.getCompositePartitionKeyValue(tags, partitionTag._0);
+            break;
+          case "ByEventType" :
+            entityId = undefined;
+            break;
+        }
       } else {
-        let tags = DcbTag$Reventless.extractTags(Spec.commandSchema, command$p.command);
-        entityId = DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
+        entityId = undefined;
       }
       let cacheKey = JSON.stringify(query);
       let cacheGet = () => {
@@ -131,7 +152,7 @@ function Make(Spec) {
             event,
             raw.position,
             raw.eventType,
-            readEventId(raw.tags)
+            readEventId(partitionTag, raw.tags)
           ]);
         }), opt => {
           if (opt !== undefined) {
@@ -290,12 +311,13 @@ function Make(Spec) {
       };
       return attempt(3);
     };
-    let handleCommands = (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, dcbEventLog, stream) => {
+    let handleCommands = (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, partitionTag, dcbEventLog, stream) => {
       let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
       let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+      let partitionTag$1 = partitionTag !== undefined ? partitionTag : Stdlib_Lazy.get(slicePartitionTag);
       return Stream.runCollect(Stream$1.mapEffect(stream, param => {
         let reference = param.reference;
-        return Effect.map(handleSingleCommand(tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, param.command), result => {
+        return Effect.map(handleSingleCommand(tagKeysByEventType, crossPartitionTagKeys, partitionTag$1, dcbEventLog, param.command), result => {
           if (result.TAG === "Ok") {
             return {
               TAG: "Ok",

package/src/plugin/component/Plugin_Structure.res

@@ -345,6 +345,40 @@ let reportTranslationTables = (
   }
 }
 
+let describePartition = (pt: Reventless.DcbTag.derivedPartitionTag) =>
+  switch pt {
+  | Simple({key}) => key
+  | Composite({keys}) => keys->Array.join(" + ")
+  | ByEventType(_) => "a key per event type"
+  }
+
+// An extension groups the commands it sends a DCB slice by the slice's partition
+// key, but it infers that key from the slice alone: the command and the events,
+// not what the slice reads. Where the plugin needs those reads — or the chapter —
+// to decide, the two can differ, and the extension would fail or group commands
+// by the wrong id at run time. `expected` is `None` when the plugin itself cannot
+// derive a partition; that failure is the builder's to report.
+let extensionPartitionFailure = (
+  ~label: string,
+  ~delegate: string,
+  ~expected: option<Reventless.DcbTag.derivedPartitionTag>,
+  ~actual: result<Reventless.DcbTag.derivedPartitionTag, string>,
+): option<string> =>
+  switch (expected, actual) {
+  | (None, _) => None
+  | (Some(e), Ok(a)) if e == a => None
+  | (Some(e), outcome) =>
+    let seen = switch outcome {
+    | Ok(a) => `groups its commands by ${a->describePartition}`
+    | Error(reason) => `cannot tell which key to group its commands by (${reason})`
+    }
+    Some(
+      `${label}: the extension ${seen}, but the plugin partitions ${delegate} by ${e->describePartition}. ` ++
+      `An extension sees only the slice's command and events, not what it reads or its chapter — ` ++
+      `add @partitionTag ${e->describePartition} to ${delegate}'s event.`,
+    )
+  }
+
 // A command's declared edge names states belonging to another component's enum,
 // and nothing forces a spec to pick the one its linked view declares. Both sides
 // are in hand here. A state the linked views do not declare raises (this runs at assembly,
@@ -636,7 +670,15 @@ let isCreateCommandName = name =>
     name->String.startsWith(p)
   )
 
-let commandLevelAndId = (~isAggregate, ~variantName, properties: dict<S.t<unknown>>) =>
+// A slice command's id field is the one carrying its slice's partition key, as the
+// boundary infers it; a `@partitionTag` or the first tagged field stands in only
+// where no key was inferred.
+let commandLevelAndId = (
+  ~isAggregate,
+  ~partitionKey: option<string>=?,
+  ~variantName,
+  properties: dict<S.t<unknown>>,
+) =>
   if isAggregate {
     if isCreateCommandName(variantName) {
       (Reventless.Plugin.Collection, None)
@@ -651,9 +693,18 @@ let commandLevelAndId = (~isAggregate, ~variantName, properties: dict<S.t<unknow
         fieldName != "TAG" &&
           (Reventless.DcbTag.isTagged(fieldSchema) || Reventless.DcbTag.isTaggedArray(fieldSchema))
       )
+    let keyOf = ((fieldName, fieldSchema)) =>
+      Reventless.DcbTag.isTaggedArray(fieldSchema)
+        ? Reventless.DcbTag.resolveArrayTagKey(fieldName, fieldSchema)
+        : Reventless.DcbTag.resolveTagKey(fieldName, fieldSchema)
     let taggedField =
-      taggedFields
-      ->Array.find(((_, fieldSchema)) => Reventless.DcbTag.isPartitionTag(fieldSchema))
+      partitionKey
+      ->Option.flatMap(key => taggedFields->Array.find(field => keyOf(field) == key))
+      ->Option.orElse(
+        taggedFields->Array.find(((_, fieldSchema)) =>
+          Reventless.DcbTag.isPartitionTag(fieldSchema)
+        ),
+      )
       ->Option.orElse(taggedFields->Array.get(0))
     switch taggedField {
     | Some((fieldName, _)) =>
@@ -700,6 +751,7 @@ let annotateArgTypes = (schema: JSON.t, argTypes: dict<string>): JSON.t => {
 
 let toCommandDef = (
   ~isAggregate,
+  ~partitionKey: option<string>=?,
   ~mutationFieldFor: string => string,
   ~parentSchema: S.t<unknown>,
   // The PPX-generated `command => permission`. Per VARIANT, not per component:
@@ -727,7 +779,12 @@ let toCommandDef = (
   // empty for a payload-less variant (e.g. `| Archive`), which compiles to a bare
   // `S.literal("Archive")` string rather than an `{TAG, ...}` object.
   let mkDef = (~variantName, ~properties) => {
-    let (guessedLevel, aggregateIdField) = commandLevelAndId(~isAggregate, ~variantName, properties)
+    let (guessedLevel, aggregateIdField) = commandLevelAndId(
+      ~isAggregate,
+      ~partitionKey?,
+      ~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
@@ -867,6 +924,7 @@ let toCommandDef = (
 
 let extractCommandDefs = (
   ~isAggregate,
+  ~partitionKey: option<string>=?,
   ~mutationFieldFor: string => string,
   ~commandAuthorization: unknown => Reventless.Authorization.permission,
   ~commandTransition: unknown => Reventless.Transition.t<string>,
@@ -878,6 +936,7 @@ let extractCommandDefs = (
     anyOf->Array.filterMap(v =>
       toCommandDef(
         ~isAggregate,
+        ~partitionKey?,
         ~mutationFieldFor,
         ~parentSchema=commandSchema,
         ~commandAuthorization,
@@ -890,6 +949,7 @@ let extractCommandDefs = (
     // Single-variant command types compile to a bare Object schema, not a Union.
     toCommandDef(
       ~isAggregate,
+      ~partitionKey?,
       ~mutationFieldFor,
       ~parentSchema=commandSchema,
       ~commandAuthorization,
@@ -1445,6 +1505,30 @@ let make = (
 
   // ── Build writable defs ────────────────────────────────────────────────────
 
+  // Non-throwing: this is a description of the plugin, and the builder is what
+  // refuses a boundary whose partitions do not resolve.
+  let dcbSliceSchemas =
+    stateChangeSlices->Array.map((module(SCS: ReventlessInfra.StateChangeSlice.T)) => {
+      Reventless.DcbTag.name: SCS.Spec.name,
+      commandSchema: SCS.Spec.commandSchema->S.castToUnknown,
+      consumedEventSchema: SCS.Spec.consumedEventSchema->S.castToUnknown,
+      eventSchema: SCS.Spec.eventSchema->S.castToUnknown,
+      moduleUrl: SCS.Spec.moduleUrl,
+    })
+  let {partitionBySlice}: Reventless.DcbScopeInference.partitionResolution =
+    dcbSliceSchemas
+    ->Array.map(Reventless.DcbTag.sliceShape)
+    ->Reventless.DcbScopeInference.resolvePartitions
+  let slicePartitionOf = switch Reventless.DcbTag.deriveBoundaryPartition(dcbSliceSchemas) {
+  | boundary =>
+    delegate =>
+      dcbSliceSchemas->Array.some(s => s.name == delegate)
+        ? boundary->Reventless.DcbTag.slicePartitionTag(delegate)
+        : None
+  | exception JsExn(_) => _ => None
+  }
+  let partitionFailures = []
+
   let stateChangeDefs =
     stateChangeSlices->Array.mapWithIndex((module(SCS: ReventlessInfra.StateChangeSlice.T), i) => {
       let (_, produced) = scsProduced->Array.getUnsafe(i)
@@ -1455,6 +1539,7 @@ let make = (
           Reventless.Plugin.name: SCS.Spec.name,
           commands: extractCommandDefs(
             ~isAggregate=false,
+            ~partitionKey=?partitionBySlice->Dict.get(SCS.Spec.name),
             ~mutationFieldFor=variantName =>
               Api_Naming.sliceMutationFieldFor(
                 ~plugin=name,
@@ -1592,6 +1677,12 @@ let make = (
     let eventsByCommand: Dict.t<array<string>> = Dict.make()
     E.mappings->Array.forEach((module(M: E.Mapping)) => {
       let label = `${E.Spec.name} → ${M.delegateName}`
+      extensionPartitionFailure(
+        ~label,
+        ~delegate=M.delegateName,
+        ~expected=slicePartitionOf(M.delegateName),
+        ~actual=M.delegatePartition(),
+      )->Option.forEach(f => partitionFailures->Array.push(f))
       pushAll(
         tableFailures,
         handledTableFailures(
@@ -1965,6 +2056,12 @@ let make = (
   })
 
   reportTranslationTables(~pluginName=name, ~failures=tableFailures, ~warnings=tableWarnings)
+  if partitionFailures->Array.length > 0 {
+    JsError.throwWithMessage(
+      `${name}: an extension cannot group its commands by the target slice's partition key.\n` ++
+      partitionFailures->Array.join("\n"),
+    )
+  }
 
   // Second pass, on purpose: commands are built well before `linkedViews` is
   // assembled, so the check cannot run inline where the defs are made.

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -13,6 +13,7 @@ import * as Trait$Reventless from "@reventlessdev/reventless-spec/src/types/Trai
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
@@ -23,6 +24,7 @@ import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.
 import * as CapabilityNeed$Reventless from "@reventlessdev/reventless-spec/src/semantic/CapabilityNeed.res.mjs";
 import * as SchemaType$ReventlessCore from "../../components/Api/SchemaType.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../../components/Api/SuryToJsonSchema.res.mjs";
 import * as Capability_Inference$ReventlessCore from "./Capability_Inference.res.mjs";
@@ -289,6 +291,29 @@ function reportTranslationTables(pluginName, failures, warnings) {
   }
 }
 
+function describePartition(pt) {
+  switch (pt.TAG) {
+    case "Simple" :
+      return pt._0.key;
+    case "Composite" :
+      return pt._0.keys.join(" + ");
+    case "ByEventType" :
+      return "a key per event type";
+  }
+}
+
+function extensionPartitionFailure(label, delegate, expected, actual) {
+  if (expected === undefined) {
+    return;
+  }
+  if (actual.TAG === "Ok" && Primitive_object.equal(expected, actual._0)) {
+    return;
+  }
+  let seen;
+  seen = actual.TAG === "Ok" ? `groups its commands by ` + describePartition(actual._0) : `cannot tell which key to group its commands by (` + actual._0 + `)`;
+  return label + `: the extension ` + seen + `, but the plugin partitions ` + delegate + ` by ` + describePartition(expected) + `. An extension sees only the slice's command and events, not what it reads or its chapter — ` + (`add @partitionTag ` + describePartition(expected) + ` to ` + delegate + `'s event.`);
+}
+
 function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView) {
   let unvalidated = {
     contents: 0
@@ -492,7 +517,7 @@ function isCreateCommandName(name) {
   ].some(p => name.startsWith(p));
 }
 
-function commandLevelAndId(isAggregate, variantName, properties) {
+function commandLevelAndId(isAggregate, partitionKey, variantName, properties) {
   if (isAggregate) {
     if (isCreateCommandName(variantName)) {
       return [
@@ -518,7 +543,16 @@ function commandLevelAndId(isAggregate, variantName, properties) {
       return false;
     }
   });
-  let taggedField = Stdlib_Option.orElse(taggedFields.find(param => DcbTag$Reventless.isPartitionTag(param[1])), taggedFields[0]);
+  let keyOf = param => {
+    let fieldSchema = param[1];
+    let fieldName = param[0];
+    if (DcbTag$Reventless.isTaggedArray(fieldSchema)) {
+      return DcbTag$Reventless.resolveArrayTagKey(fieldName, fieldSchema);
+    } else {
+      return DcbTag$Reventless.resolveTagKey(fieldName, fieldSchema);
+    }
+  };
+  let taggedField = Stdlib_Option.orElse(Stdlib_Option.orElse(Stdlib_Option.flatMap(partitionKey, key => taggedFields.find(field => keyOf(field) === key)), taggedFields.find(param => DcbTag$Reventless.isPartitionTag(param[1]))), taggedFields[0]);
   if (taggedField === undefined) {
     return [
       "Collection",
@@ -563,9 +597,9 @@ function annotateArgTypes(schema, argTypes) {
   return schema;
 }
 
-function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, derivedEdgeFor, v) {
+function toCommandDef(isAggregate, partitionKey, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, derivedEdgeFor, v) {
   let mkDef = (variantName, properties) => {
-    let match = commandLevelAndId(isAggregate, variantName, properties);
+    let match = commandLevelAndId(isAggregate, partitionKey, variantName, properties);
     let references = extractReferences(properties);
     let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
         TAG: variantName
@@ -649,12 +683,12 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
   }
 }
 
-function extractCommandDefs(isAggregate, mutationFieldFor, commandAuthorization, commandTransition, derivedEdgeForOpt, commandSchema) {
+function extractCommandDefs(isAggregate, partitionKey, mutationFieldFor, commandAuthorization, commandTransition, derivedEdgeForOpt, commandSchema) {
   let derivedEdgeFor = derivedEdgeForOpt !== undefined ? derivedEdgeForOpt : param => {};
   if (commandSchema.type === "anyOf") {
-    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, v));
+    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, partitionKey, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, v));
   } else {
-    return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, commandSchema), [], def => [def]);
+    return Stdlib_Option.mapOr(toCommandDef(isAggregate, partitionKey, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, commandSchema), [], def => [def]);
   }
 }
 
@@ -1036,6 +1070,37 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       requiredAccess: accessKeysFor(SVS.Spec.authorization)
     };
   });
+  let dcbSliceSchemas = stateChangeSlices.map(SCS => ({
+    name: SCS.Spec.name,
+    commandSchema: SCS.Spec.commandSchema,
+    consumedEventSchema: SCS.Spec.consumedEventSchema,
+    eventSchema: SCS.Spec.eventSchema,
+    moduleUrl: SCS.Spec.moduleUrl
+  }));
+  let match = DcbScopeInference$Reventless.resolvePartitions(dcbSliceSchemas.map(DcbTag$Reventless.sliceShape));
+  let partitionBySlice = match.partitionBySlice;
+  let slicePartitionOf;
+  let exit = 0;
+  let boundary;
+  try {
+    boundary = DcbTag$Reventless.deriveBoundaryPartition(dcbSliceSchemas);
+    exit = 1;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (exn.RE_EXN_ID === "JsExn") {
+      slicePartitionOf = param => {};
+    } else {
+      throw exn;
+    }
+  }
+  if (exit === 1) {
+    slicePartitionOf = delegate => {
+      if (dcbSliceSchemas.some(s => s.name === delegate)) {
+        return DcbTag$Reventless.slicePartitionTag(boundary, delegate);
+      }
+    };
+  }
+  let partitionFailures = [];
   let stateChangeDefs = stateChangeSlices.map((SCS, i) => {
     let match = scsProduced[i];
     let produced = match[1];
@@ -1043,7 +1108,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let consumed = match$1[1];
     return {
       name: SCS.Spec.name,
-      commands: extractCommandDefs(false, variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, extra => derivedEdgeFor(SCS.Spec.name, extra), SCS.Spec.commandSchema),
+      commands: extractCommandDefs(false, partitionBySlice[SCS.Spec.name], variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, extra => derivedEdgeFor(SCS.Spec.name, extra), SCS.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: consumed,
       linkedViews: linkedSvsFor(produced),
@@ -1058,7 +1123,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let produced = match[1];
     return {
       name: A.Spec.name,
-      commands: extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, extra => derivedEdgeFor(A.Spec.name, extra), A.Spec.commandSchema),
+      commands: extractCommandDefs(true, undefined, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, extra => derivedEdgeFor(A.Spec.name, extra), A.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: [],
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
@@ -1109,6 +1174,9 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let eventsByCommand = {};
     E.mappings.forEach(M => {
       let label = E.Spec.name + ` → ` + M.delegateName;
+      Stdlib_Option.forEach(extensionPartitionFailure(label, M.delegateName, slicePartitionOf(M.delegateName), M.delegatePartition()), f => {
+        partitionFailures.push(f);
+      });
       pushAll(tableFailures, handledTableFailures(label, M.handledEvents, epEventNames, M.delegateCommandNames.concat(epCommandNames)));
       pushAll(tableFailures, commandTableFailures(label, "issuedCommands", "comes from", M.issuedCommands.map(param => [
         param.name,
@@ -1330,6 +1398,9 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     });
   });
   reportTranslationTables(name, tableFailures, tableWarnings);
+  if (partitionFailures.length !== 0) {
+    Stdlib_JsError.throwWithMessage(name + `: an extension cannot group its commands by the target slice's partition key.\n` + partitionFailures.join("\n"));
+  }
   checkDeclaredTransitions(name, stateChangeDefs.concat(aggregateDefs), lifecycleStatesByView);
   checkLifecycleTopology(name, stateChangeDefs.concat(aggregateDefs), lifecycleStatesByView);
   reportRetiredStates(name, retiredFailures, retiredUnchecked);
@@ -1374,6 +1445,8 @@ export {
   probeMeta,
   probeQueryEngine,
   reportTranslationTables,
+  describePartition,
+  extensionPartitionFailure,
   checkDeclaredTransitions,
   lifecycleTopologyFindings,
   checkLifecycleTopology,

package/tests/adapter/RuntimeExtensionHookReachTest.res.mjs

@@ -22,7 +22,7 @@ async function publishJsons(cmds) {
   published.contents = published.contents.concat(cmds);
 }
 
-let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "Product", commandSchema, "StateChangeSlice", false);
+let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "Product", commandSchema, "StateChangeSlice", false, undefined);
 
 function addChair() {
   return {

package/tests/commandgenerator/CommandGeneratorCallbackTest.res

@@ -91,7 +91,7 @@ describe("CommandGenerator_Callback.generateCommand:", () => {
 
   describe("StateChangeSlice envelope id derivation", () => {
     testPromise(
-      "single @partitionTag: id derived from tagged field when args have no id",
+      "the slice's partition key: id derived from its field when args have no id",
       async () => {
         let payload = makeSlicePayload(
           ~command="CreateItem",

package/tests/commandgenerator/CommandGeneratorCallbackTest.res.mjs

@@ -85,7 +85,7 @@ globalThis.describe("CommandGenerator_Callback.generateCommand:", () => {
     });
   });
   globalThis.describe("StateChangeSlice envelope id derivation", () => {
-    globalThis.test("single @partitionTag: id derived from tagged field when args have no id", async () => {
+    globalThis.test("the slice's partition key: id derived from its field when args have no id", async () => {
       let payload = CommandGeneratorFixtures$ReventlessCore.makeSlicePayload("CreateItem", Object.fromEntries([
         [
           "itemId",