@reventlessdev/reventless-infra 3.0.0-alpha.207 → 3.0.0-alpha.209

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.209 (2026-10-29)
+
+* feat(core)!: the caller's IP address leaves the messages a request causes ([aa9e8c7](https://github.com/ReventlessDev/reventless-core/commit/aa9e8c79c0360528a5cfeda2bb88d1da52f28674))
+
+### BREAKING CHANGES
+
+* `Message.generateMeta` no longer takes `~ip`. Drop the argument; a
+message that must carry the address declares it as a field of its own payload.
+
+Step PD3 of docs/plans/a-personal-field-is-marked-redacted-and-encrypted-at-the-seam.md.
+Claude-Session: https://claude.ai/code/session_01HiQfdxVEsHwLHRoHSUcus1
+
+
+
+# 3.0.0-alpha.208 (2026-10-29)
+
+* refactor!: a read model hears another plugin only through an Extension and a slice ([15c7cae](https://github.com/ReventlessDev/reventless-core/commit/15c7cae214d5aa04404779fcd87a8429aad1965c))
+### Features
+
+* **core:** a handler drops a command it has already handled ([605862b](https://github.com/ReventlessDev/reventless-core/commit/605862bba765b1501eb19d08f3924bf619159e21))
+* **infra:** a message a mapping derives gets a stable id and names its parent ([a72a08f](https://github.com/ReventlessDev/reventless-core/commit/a72a08f9af4440eff5fa36e9a364a426bc70918c))
+
+### BREAKING CHANGES
+
+* `ReventlessInfra.Extension.T.make` and the core
+`Extension_Builder.make` no longer take `~readModelNamesForSourceName` and
+`~publishToReadModels`. Both arguments did nothing; drop them at the call site.
+
+
+
 # 3.0.0-alpha.207 (2026-10-25)
 
 **Note:** Version bump only for package @reventlessdev/reventless-infra

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-infra",
-  "version": "3.0.0-alpha.207",
+  "version": "3.0.0-alpha.209",
   "description": "Infrastructure types for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -17,9 +17,9 @@
     "sury-ppx": "11.0.0",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.178"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.180",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.1"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/components/Extension.res

@@ -30,8 +30,6 @@ module type T = {
   let make: (
     ~publishToPluginExtensionPoint: CommandTopic.publishJsons,
     ~publishToAggregates: dict<CommandTopic.publishJsons>,
-    ~readModelNamesForSourceName: dict<array<string>>,
-    ~publishToReadModels: dict<EventCollector.enqueueEvent>,
     ~queryEngine: Reventless.QueryEngine.operations,
     ~opts: option<Pulumi.ComponentResource.options>,
   ) => component

package/src/types/ExtensionMapping.res

@@ -257,28 +257,32 @@ module Make = (MappingImpl: Mapping): (
   let compLog = (comp, msg) =>
     Effect.logInfo(msg)->Effect.annotateLogs("comp", comp)->Effect.runSync
 
-  let encodeMeta = (meta: Reventless.Message.meta, service) => {
-    ...meta,
-    service,
-    msgId: Message.uuid(),
-  }
-
   let doMapIncomingEvent = (
     mapIncomingEventImpl,
     {Reventless.Message.id: id, event, meta},
     pluginDef,
     queryEngine,
   ) => {
-    let encodeTargetCommandJson = (targetCmd, targetId) => {
+    // Every command here is derived from the published event: `index` is the
+    // action's position in the mapping's result, `item` a command's position
+    // inside a multi-command action, so a redelivered event yields the same
+    // `msgId`s and the handler can drop the repeat.
+    let encodeTargetCommandJson = (targetCmd, targetId, ~index, ~item) => {
       let cmdJson = targetCmd->Reventless.Message.encode(Delegate.commandSchema)
       {
         Reventless.Message.id: targetId,
-        meta: encodeMeta(meta, delegateName),
+        meta: Message.deriveStableMeta(~parent=meta, ~service=delegateName, ~index, ~item),
         commandJson: cmdJson,
       }
     }
 
-    let encodeExtensionPointCommandJson = (commandJson, ~id, ~extensionPointName, ~action) => {
+    let encodeExtensionPointCommandJson = (
+      commandJson,
+      ~id,
+      ~extensionPointName,
+      ~action,
+      ~index,
+    ) => {
       compLog(
         `Extension(${extensionPointName})`,
         `${action}: ${commandJson
@@ -287,49 +291,55 @@ module Make = (MappingImpl: Mapping): (
       )
       {
         Reventless.Message.id,
-        meta: encodeMeta(meta, extensionPointName),
+        meta: Message.deriveStableMeta(~parent=meta, ~service=extensionPointName, ~index),
         commandJson,
       }
     }
 
-    let encodeExtensionPointCommand = (command, ~id, ~extensionPointName, ~action) =>
+    let encodeExtensionPointCommand = (command, ~id, ~extensionPointName, ~action, ~index) =>
       command
       ->Reventless.Message.encode(Spec.commandSchema)
-      ->encodeExtensionPointCommandJson(~id, ~extensionPointName, ~action)
+      ->encodeExtensionPointCommandJson(~id, ~extensionPointName, ~action, ~index)
 
-    mapIncomingEventImpl(id, event, meta, pluginDef, queryEngine)->Array.map(x =>
+    mapIncomingEventImpl(id, event, meta, pluginDef, queryEngine)->Array.mapWithIndex((x, index) =>
       switch x {
       | PublishAggregateCommand(targetId, targetCmd) =>
-        AbstractPublishAggregateCommand(delegateName, targetCmd->encodeTargetCommandJson(targetId))
+        AbstractPublishAggregateCommand(
+          delegateName,
+          targetCmd->encodeTargetCommandJson(targetId, ~index, ~item=0),
+        )
       | PublishAggregateCommandAsync(promise) =>
         let toCommandJson = async promise => {
           let (targetId, targetCmd) = await promise
-          (delegateName, targetCmd->encodeTargetCommandJson(targetId))
+          (delegateName, targetCmd->encodeTargetCommandJson(targetId, ~index, ~item=0))
         }
         AbstractPublishAggregateCommandAsync(promise->toCommandJson)
       | PublishAggregateCommandsAsync(promise) =>
         let toCommandJsons = async promise =>
-          (await promise)->Array.map(((targetId, targetCmd)) => (
+          (await promise)->Array.mapWithIndex(((targetId, targetCmd), item) => (
             delegateName,
-            targetCmd->encodeTargetCommandJson(targetId),
+            targetCmd->encodeTargetCommandJson(targetId, ~index, ~item),
           ))
         AbstractPublishAggregateCommandsAsync(promise->toCommandJsons)
       | PublishStateChangeSliceCommand(targetCmd) =>
         AbstractPublishAggregateCommand(
           delegateName,
-          targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd)),
+          targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd), ~index, ~item=0),
         )
       | PublishStateChangeSliceCommandAsync(promise) =>
         let toCommandJson = async promise => {
           let targetCmd = await promise
-          (delegateName, targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd)))
+          (
+            delegateName,
+            targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd), ~index, ~item=0),
+          )
         }
         AbstractPublishAggregateCommandAsync(promise->toCommandJson)
       | PublishStateChangeSliceCommandsAsync(promise) =>
         let toCommandJsons = async promise =>
-          (await promise)->Array.map(targetCmd => (
+          (await promise)->Array.mapWithIndex((targetCmd, item) => (
             delegateName,
-            targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd)),
+            targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd), ~index, ~item),
           ))
         AbstractPublishAggregateCommandsAsync(promise->toCommandJsons)
       | PublishExtensionPointCommand(id, command) if Spec.name == PluginExtensionPointSpec.name =>
@@ -338,6 +348,7 @@ module Make = (MappingImpl: Mapping): (
             ~id,
             ~extensionPointName,
             ~action="Publish PluginExtensionPoint command",
+            ~index,
           ),
         )
       | PublishExtensionPointCommand(id, command) =>
@@ -347,6 +358,7 @@ module Make = (MappingImpl: Mapping): (
             ~id,
             ~extensionPointName,
             ~action="Publish ExtensionPoint command",
+            ~index,
           ),
         )
       | ForwardCommand({extensionPointName, id, commandJson}) =>
@@ -356,6 +368,7 @@ module Make = (MappingImpl: Mapping): (
             ~id,
             ~extensionPointName,
             ~action="Forward ExtensionPoint command",
+            ~index,
           ),
         )
       | HandleDirective(handler, directive) =>
@@ -383,7 +396,13 @@ module Make = (MappingImpl: Mapping): (
     } else {
       let {id, meta, event} =
         targetEvent'Json->Reventless.Message.decodeEvent'(Delegate.Id.schema, Delegate.eventSchema)
-      let encodeExtensionPointCommandJson = (commandJson, ~id, ~extensionPointName, ~action) => {
+      let encodeExtensionPointCommandJson = (
+        commandJson,
+        ~id,
+        ~extensionPointName,
+        ~action,
+        ~index,
+      ) => {
         compLog(
           `Extension(${delegateName})`,
           `${action}: ${commandJson
@@ -392,17 +411,20 @@ module Make = (MappingImpl: Mapping): (
         )
         {
           Reventless.Message.id,
-          meta: encodeMeta(meta, extensionPointName),
+          meta: Message.deriveStableMeta(~parent=meta, ~service=extensionPointName, ~index),
           commandJson,
         }
       }
 
-      let encodeExtensionPointCommand = (command, ~id, ~extensionPointName, ~action) =>
+      let encodeExtensionPointCommand = (command, ~id, ~extensionPointName, ~action, ~index) =>
         command
         ->Reventless.Message.encode(Spec.commandSchema)
-        ->encodeExtensionPointCommandJson(~id, ~extensionPointName, ~action)
+        ->encodeExtensionPointCommandJson(~id, ~extensionPointName, ~action, ~index)
 
-      mapOutgoingEventImpl(id->Delegate.Id.toString, event, meta, pluginDef)->Array.map(x =>
+      mapOutgoingEventImpl(id->Delegate.Id.toString, event, meta, pluginDef)->Array.mapWithIndex((
+        x,
+        index,
+      ) =>
         switch x {
         | PublishExtensionPointCommand(id, command) if Spec.name == PluginExtensionPointSpec.name =>
           AbstractPublishPluginExtensionPointCommand(
@@ -410,6 +432,7 @@ module Make = (MappingImpl: Mapping): (
               ~id,
               ~extensionPointName,
               ~action="Publish PluginExtensionPoint command",
+              ~index,
             ),
           )
 
@@ -420,6 +443,7 @@ module Make = (MappingImpl: Mapping): (
               ~id,
               ~extensionPointName,
               ~action="Publish ExtensionPoint command",
+              ~index,
             ),
           )
         | ForwardCommand({extensionPointName, id, commandJson}) =>
@@ -429,6 +453,7 @@ module Make = (MappingImpl: Mapping): (
               ~id,
               ~extensionPointName,
               ~action="Forward ExtensionPoint command",
+              ~index,
             ),
           )
         | HandleDirective(handler, directive) =>

package/src/types/ExtensionMapping.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
-import * as Uuid from "uuid";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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";
@@ -11,6 +10,7 @@ import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/component
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessInfra from "./Message.res.mjs";
 import * as PluginExtensionPointSpec$ReventlessInfra from "./PluginExtensionPointSpec.res.mjs";
 
 let schema = Sury.string;
@@ -98,46 +98,40 @@ function Make(MappingImpl) {
   };
   let derivePartitionId = targetCmd => DcbTag$Reventless.partitionValueOfTags(DcbTag$Reventless.extractTags(Delegate.commandSchema, targetCmd), getDerivedPartitionTag());
   let compLog = (comp, msg) => Effect.runSync(Effect.annotateLogs(Effect.logInfo(msg), "comp", comp));
-  let encodeMeta = (meta, service) => {
-    let newrecord = {...meta};
-    newrecord.msgId = Uuid.v4();
-    newrecord.service = service;
-    return newrecord;
-  };
   let mapIncomingEvent = (extra, extra$1, extra$2) => {
     let mapIncomingEventImpl = MappingImpl.mapIncomingEvent;
     let meta = extra.meta;
-    let encodeTargetCommandJson = (targetCmd, targetId) => {
+    let encodeTargetCommandJson = (targetCmd, targetId, index, item) => {
       let cmdJson = Message$Reventless.encode(targetCmd, Delegate.commandSchema);
       return {
         id: targetId,
-        meta: encodeMeta(meta, delegateName),
+        meta: Message$ReventlessInfra.deriveStableMeta(meta, delegateName, index, item),
         commandJson: cmdJson
       };
     };
-    let encodeExtensionPointCommandJson = (commandJson, id, extensionPointName, action) => {
+    let encodeExtensionPointCommandJson = (commandJson, id, extensionPointName, action, index) => {
       compLog(`Extension(` + extensionPointName + `)`, action + `: ` + AnsiStyle$Reventless.bold(Message$Reventless.variantNameOfJson(commandJson)) + `(` + id + `)`);
       return {
         id: id,
-        meta: encodeMeta(meta, extensionPointName),
+        meta: Message$ReventlessInfra.deriveStableMeta(meta, extensionPointName, index, undefined),
         commandJson: commandJson
       };
     };
-    let encodeExtensionPointCommand = (command, id, extensionPointName, action) => encodeExtensionPointCommandJson(Message$Reventless.encode(command, Spec.commandSchema), id, extensionPointName, action);
-    return mapIncomingEventImpl(extra.id, extra.event, meta, extra$1, extra$2).map(x => {
+    let encodeExtensionPointCommand = (command, id, extensionPointName, action, index) => encodeExtensionPointCommandJson(Message$Reventless.encode(command, Spec.commandSchema), id, extensionPointName, action, index);
+    return mapIncomingEventImpl(extra.id, extra.event, meta, extra$1, extra$2).map((x, index) => {
       switch (x.TAG) {
         case "PublishAggregateCommand" :
           return {
             TAG: "AbstractPublishAggregateCommand",
             _0: delegateName,
-            _1: encodeTargetCommandJson(x._1, x._0)
+            _1: encodeTargetCommandJson(x._1, x._0, index, 0)
           };
         case "PublishAggregateCommandAsync" :
           let toCommandJson = async promise => {
             let match = await promise;
             return [
               delegateName,
-              encodeTargetCommandJson(match[1], match[0])
+              encodeTargetCommandJson(match[1], match[0], index, 0)
             ];
           };
           return {
@@ -145,9 +139,9 @@ function Make(MappingImpl) {
             _0: toCommandJson(x._0)
           };
         case "PublishAggregateCommandsAsync" :
-          let toCommandJsons = async promise => (await promise).map(param => [
+          let toCommandJsons = async promise => (await promise).map((param, item) => [
             delegateName,
-            encodeTargetCommandJson(param[1], param[0])
+            encodeTargetCommandJson(param[1], param[0], index, item)
           ]);
           return {
             TAG: "AbstractPublishAggregateCommandsAsync",
@@ -158,14 +152,14 @@ function Make(MappingImpl) {
           return {
             TAG: "AbstractPublishAggregateCommand",
             _0: delegateName,
-            _1: encodeTargetCommandJson(targetCmd, derivePartitionId(targetCmd))
+            _1: encodeTargetCommandJson(targetCmd, derivePartitionId(targetCmd), index, 0)
           };
         case "PublishStateChangeSliceCommandAsync" :
           let toCommandJson$1 = async promise => {
             let targetCmd = await promise;
             return [
               delegateName,
-              encodeTargetCommandJson(targetCmd, derivePartitionId(targetCmd))
+              encodeTargetCommandJson(targetCmd, derivePartitionId(targetCmd), index, 0)
             ];
           };
           return {
@@ -173,9 +167,9 @@ function Make(MappingImpl) {
             _0: toCommandJson$1(x._0)
           };
         case "PublishStateChangeSliceCommandsAsync" :
-          let toCommandJsons$1 = async promise => (await promise).map(targetCmd => [
+          let toCommandJsons$1 = async promise => (await promise).map((targetCmd, item) => [
             delegateName,
-            encodeTargetCommandJson(targetCmd, derivePartitionId(targetCmd))
+            encodeTargetCommandJson(targetCmd, derivePartitionId(targetCmd), index, item)
           ]);
           return {
             TAG: "AbstractPublishAggregateCommandsAsync",
@@ -187,13 +181,13 @@ function Make(MappingImpl) {
           if (Spec.name === PluginExtensionPointSpec$ReventlessInfra.name) {
             return {
               TAG: "AbstractPublishPluginExtensionPointCommand",
-              _0: encodeExtensionPointCommand(command, id, extensionPointName, "Publish PluginExtensionPoint command")
+              _0: encodeExtensionPointCommand(command, id, extensionPointName, "Publish PluginExtensionPoint command", index)
             };
           } else {
             return {
               TAG: "AbstractPublishExtensionPointCommand",
               _0: extensionPointName,
-              _1: encodeExtensionPointCommand(command, id, extensionPointName, "Publish ExtensionPoint command")
+              _1: encodeExtensionPointCommand(command, id, extensionPointName, "Publish ExtensionPoint command", index)
             };
           }
         case "ForwardCommand" :
@@ -202,7 +196,7 @@ function Make(MappingImpl) {
           return {
             TAG: "AbstractPublishExtensionPointCommand",
             _0: extensionPointName$1,
-            _1: encodeExtensionPointCommandJson(match.commandJson, match.id, extensionPointName$1, "Forward ExtensionPoint command")
+            _1: encodeExtensionPointCommandJson(match.commandJson, match.id, extensionPointName$1, "Forward ExtensionPoint command", index)
           };
         case "HandleDirective" :
           let directive = x._1;
@@ -223,16 +217,16 @@ function Make(MappingImpl) {
     }
     let match = Message$Reventless.decodeEvent$p(extra, Delegate.Id.schema, Delegate.eventSchema);
     let meta = match.meta;
-    let encodeExtensionPointCommandJson = (commandJson, id, extensionPointName, action) => {
+    let encodeExtensionPointCommandJson = (commandJson, id, extensionPointName, action, index) => {
       compLog(`Extension(` + delegateName + `)`, action + `: ` + AnsiStyle$Reventless.bold(Message$Reventless.variantNameOfJson(commandJson)) + `(` + id + `)`);
       return {
         id: id,
-        meta: encodeMeta(meta, extensionPointName),
+        meta: Message$ReventlessInfra.deriveStableMeta(meta, extensionPointName, index, undefined),
         commandJson: commandJson
       };
     };
-    let encodeExtensionPointCommand = (command, id, extensionPointName, action) => encodeExtensionPointCommandJson(Message$Reventless.encode(command, Spec.commandSchema), id, extensionPointName, action);
-    return mapOutgoingEventImpl(Delegate.Id.toString(match.id), match.event, meta, extra$1).map(x => {
+    let encodeExtensionPointCommand = (command, id, extensionPointName, action, index) => encodeExtensionPointCommandJson(Message$Reventless.encode(command, Spec.commandSchema), id, extensionPointName, action, index);
+    return mapOutgoingEventImpl(Delegate.Id.toString(match.id), match.event, meta, extra$1).map((x, index) => {
       switch (x.TAG) {
         case "PublishExtensionPointCommand" :
           let command = x._1;
@@ -240,13 +234,13 @@ function Make(MappingImpl) {
           if (Spec.name === PluginExtensionPointSpec$ReventlessInfra.name) {
             return {
               TAG: "AbstractPublishPluginExtensionPointCommand",
-              _0: encodeExtensionPointCommand(command, id, extensionPointName, "Publish PluginExtensionPoint command")
+              _0: encodeExtensionPointCommand(command, id, extensionPointName, "Publish PluginExtensionPoint command", index)
             };
           } else {
             return {
               TAG: "AbstractPublishExtensionPointCommand",
               _0: extensionPointName,
-              _1: encodeExtensionPointCommand(command, id, extensionPointName, "Publish ExtensionPoint command")
+              _1: encodeExtensionPointCommand(command, id, extensionPointName, "Publish ExtensionPoint command", index)
             };
           }
         case "ForwardCommand" :
@@ -255,7 +249,7 @@ function Make(MappingImpl) {
           return {
             TAG: "AbstractPublishExtensionPointCommand",
             _0: extensionPointName$1,
-            _1: encodeExtensionPointCommandJson(match.commandJson, match.id, extensionPointName$1, "Forward ExtensionPoint command")
+            _1: encodeExtensionPointCommandJson(match.commandJson, match.id, extensionPointName$1, "Forward ExtensionPoint command", index)
           };
         case "HandleDirective" :
           let directive = x._1;

package/src/types/ExtensionPointMapping.res

@@ -170,7 +170,10 @@ module Make = (MappingImpl: Mapping): (
       CommandTopic.reference: reference,
       command: {Reventless.Message.id: id, command, meta},
     }) =>
-      mapIncomingEventImpl(id->Reventless.Id.String.toString, command, meta)->Array.map(x =>
+      mapIncomingEventImpl(id->Reventless.Id.String.toString, command, meta)->Array.mapWithIndex((
+        x,
+        index,
+      ) =>
         switch x {
         | PublishCommand(targetId, targetCmd) =>
           let cmdJson = targetCmd->Reventless.Message.encode(Delegate.commandSchema)
@@ -186,11 +189,7 @@ module Make = (MappingImpl: Mapping): (
             reference,
             {
               id: targetId,
-              meta: {
-                ...meta,
-                service: Delegate.name,
-                msgId: Message.uuid(),
-              },
+              meta: Message.deriveStableMeta(~parent=meta, ~service=Delegate.name, ~index),
               commandJson: targetCmd->Reventless.Message.encode(Delegate.commandSchema),
             },
           )
@@ -230,12 +229,15 @@ module Make = (MappingImpl: Mapping): (
     } else {
       let {id, meta, event} =
         targetEventJson'->Reventless.Message.decodeEvent'(Delegate.Id.schema, Delegate.eventSchema)
+      // The published event is derived from the Delegate's: `index` is the
+      // action's position, so a stream redelivery of the same event publishes
+      // the same `msgId`s.
       mapOutgoingEventImpl(
         id->Delegate.Id.toString,
         event,
         meta,
         queryEngine,
-      )->Array.map(eventAction =>
+      )->Array.mapWithIndex((eventAction, index) =>
         switch eventAction {
         | PublishEvent(id, event) =>
           let eventJson = event->Reventless.Message.encode(Spec.eventSchema)
@@ -245,11 +247,7 @@ module Make = (MappingImpl: Mapping): (
               ->Reventless.Message.variantNameOfJson
               ->Reventless.AnsiStyle.bold}(${id})`,
           )
-          let meta = {
-            ...meta,
-            service: Spec.name,
-            msgId: Message.uuid(),
-          }
+          let meta = Message.deriveStableMeta(~parent=meta, ~service=Spec.name, ~index)
           let eventJson' = Reventless.Message.composeEventJson'(id, meta, eventJson)
           AbstractPublishEvent(id, meta, eventJson')
         | PublishEventAsync(promise) =>
@@ -262,7 +260,8 @@ module Make = (MappingImpl: Mapping): (
                 ->Reventless.Message.variantNameOfJson
                 ->Reventless.AnsiStyle.bold}(${id}) (async)`,
             )
-            let eventJson' = Reventless.Message.composeEventJson'(id, meta, eventJson) // TODO: check if meta is correct
+            let meta = Message.deriveStableMeta(~parent=meta, ~service=Spec.name, ~index)
+            let eventJson' = Reventless.Message.composeEventJson'(id, meta, eventJson)
             (id, meta, eventJson')
           }
           AbstractPublishEventAsync(promise->toEvent')

package/src/types/ExtensionPointMapping.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Uuid from "uuid";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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";
@@ -8,6 +7,7 @@ import * as Effect from "effect/Effect";
 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 AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
+import * as Message$ReventlessInfra from "./Message.res.mjs";
 
 function Make(MappingImpl) {
   let Spec = MappingImpl.ExtensionPoint;
@@ -22,20 +22,19 @@ function Make(MappingImpl) {
       let reference = param.reference;
       let match = param.command;
       let meta = match.meta;
-      return mapIncomingEventImpl(Id$Reventless.$$String.toString(match.id), match.command, meta).map(x => {
+      return mapIncomingEventImpl(Id$Reventless.$$String.toString(match.id), match.command, meta).map((x, index) => {
         if (x.TAG === "PublishCommand") {
           let targetCmd = x._1;
           let targetId = x._0;
           let cmdJson = Message$Reventless.encode(targetCmd, Delegate.commandSchema);
           compLog(`ExtensionPoint(` + extensionPointName + `)`, `EP→` + delegateName + `: ` + AnsiStyle$Reventless.bold(Message$Reventless.variantNameOfJson(cmdJson)) + `(` + targetId + `)`);
-          let newrecord = {...meta};
           return {
             TAG: "AbstractPublishCommand",
             _0: delegateName,
             _1: reference,
             _2: {
               id: targetId,
-              meta: (newrecord.msgId = Uuid.v4(), newrecord.service = Delegate.name, newrecord),
+              meta: Message$ReventlessInfra.deriveStableMeta(meta, Delegate.name, index, undefined),
               commandJson: Message$Reventless.encode(targetCmd, Delegate.commandSchema)
             }
           };
@@ -59,20 +58,18 @@ function Make(MappingImpl) {
     }
     let match = Message$Reventless.decodeEvent$p(extra, Delegate.Id.schema, Delegate.eventSchema);
     let meta = match.meta;
-    return mapOutgoingEventImpl(Delegate.Id.toString(match.id), match.event, meta, extra$3).map(eventAction => {
+    return mapOutgoingEventImpl(Delegate.Id.toString(match.id), match.event, meta, extra$3).map((eventAction, index) => {
       switch (eventAction.TAG) {
         case "PublishEvent" :
           let id = eventAction._0;
           let eventJson = Message$Reventless.encode(eventAction._1, Spec.eventSchema);
           compLog(`ExtensionPoint(` + extensionPointName + `)`, `mapped ` + delegateName + ` → ` + AnsiStyle$Reventless.bold(Message$Reventless.variantNameOfJson(eventJson)) + `(` + id + `)`);
-          let newrecord = {...meta};
-          newrecord.msgId = Uuid.v4();
-          newrecord.service = Spec.name;
-          let eventJson$p = Message$Reventless.composeEventJson$p(id, newrecord, eventJson);
+          let meta$1 = Message$ReventlessInfra.deriveStableMeta(meta, Spec.name, index, undefined);
+          let eventJson$p = Message$Reventless.composeEventJson$p(id, meta$1, eventJson);
           return {
             TAG: "AbstractPublishEvent",
             _0: id,
-            _1: newrecord,
+            _1: meta$1,
             _2: eventJson$p
           };
         case "PublishEventAsync" :
@@ -81,10 +78,11 @@ function Make(MappingImpl) {
             let id = match[0];
             let eventJson = Message$Reventless.encode(match[1], Spec.eventSchema);
             compLog(`ExtensionPoint(` + extensionPointName + `)`, `mapped ` + delegateName + ` → ` + AnsiStyle$Reventless.bold(Message$Reventless.variantNameOfJson(eventJson)) + `(` + id + `) (async)`);
-            let eventJson$p = Message$Reventless.composeEventJson$p(id, meta, eventJson);
+            let meta$2 = Message$ReventlessInfra.deriveStableMeta(meta, Spec.name, index, undefined);
+            let eventJson$p = Message$Reventless.composeEventJson$p(id, meta$2, eventJson);
             return [
               id,
-              meta,
+              meta$2,
               eventJson$p
             ];
           };
@@ -113,4 +111,4 @@ function Make(MappingImpl) {
 export {
   Make,
 }
-/* uuid Not a pure module */
+/* Id-Reventless Not a pure module */

package/src/types/Message.res

@@ -1,3 +1,65 @@
 /** Generates a new UUID v4 string. */
 @module("uuid") @val
 external uuid: unit => string = "v4"
+
+/** The namespace `deriveStableMeta` mints ids in: one fixed value, so the same
+    input gives the same id in every process. */
+let derivedIdNamespace = Uuid.Namespace.custom("c4e9c2e6-8b3f-4f0e-9a52-6d2b4c7e1a90")
+
+/** The header `deriveStableMeta` sets, which marks a message whose `msgId` is a
+    function of its input. A handler reads it as "a repeat of this command can be
+    recognized", and `deriveMeta` strips it so the mark never outlives the id. */
+let stableIdHeader = "reventless-stable-id"
+
+/** Whether this message's `msgId` was derived from its input, so that a second
+    delivery carries the same id. */
+let hasStableMsgId = (meta: Reventless.Message.meta): bool =>
+  meta.headers->Option.flatMap(h => h->Dict.get(stableIdHeader))->Option.isSome
+
+let withStableIdHeader = (headers: option<dict<string>>): dict<string> => {
+  let out = headers->Option.mapOr(Dict.make(), Dict.copy)
+  out->Dict.set(stableIdHeader, "true")
+  out
+}
+
+/** The inherited headers without the stable-id mark: a message whose id is fresh
+    must not claim otherwise. `None` when nothing is left. */
+let withoutStableIdHeader = (headers: option<dict<string>>): option<dict<string>> =>
+  switch headers {
+  | Some(h) if h->Dict.has(stableIdHeader) =>
+    let out = h->Dict.copy
+    out->Dict.delete(stableIdHeader)
+    out->Dict.keysToArray->Array.length == 0 ? None : Some(out)
+  | other => other
+  }
+
+/**
+The meta of a message a mapping derives from `parent`.
+
+The envelope is the one `deriveMeta` documents: `causationId` is the parent's
+`msgId`, `correlationId` and the tracing fields are inherited, `service` is the
+emitter. The `msgId` is a function of the input: the parent's `msgId`, the
+emitter and the action's `index` in the mapping's result (`item` for one command
+of a multi-command action). A mapping run again on the same input produces the
+same ids, which is what lets a handler recognize a redelivered fact; two inputs
+or two actions of one input never collide. The `stableIdHeader` marks the result.
+*/
+let deriveStableMeta = (
+  ~parent: Reventless.Message.meta,
+  ~service,
+  ~index,
+  ~item=0,
+): Reventless.Message.meta => {
+  service,
+  time: Date.make()->Date.toISOString,
+  msgId: Uuid.v5(
+    ~name=`${parent.msgId}/${service}/${index->Int.toString}/${item->Int.toString}`,
+    ~namespace=derivedIdNamespace,
+  ),
+  correlationId: parent.correlationId,
+  causationId: parent.msgId,
+  user: ?parent.user,
+  traceparent: ?parent.traceparent,
+  schemaVersion: ?parent.schemaVersion,
+  headers: withStableIdHeader(parent.headers),
+}

package/src/types/Message.res.mjs

@@ -1,2 +1,60 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+
+import * as Uuid from "uuid";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let derivedIdNamespace = "c4e9c2e6-8b3f-4f0e-9a52-6d2b4c7e1a90";
+
+let stableIdHeader = "reventless-stable-id";
+
+function hasStableMsgId(meta) {
+  return Stdlib_Option.isSome(Stdlib_Option.flatMap(meta.headers, h => h[stableIdHeader]));
+}
+
+function withStableIdHeader(headers) {
+  let out = Stdlib_Option.mapOr(headers, {}, prim => Object.assign({}, prim));
+  out[stableIdHeader] = "true";
+  return out;
+}
+
+function withoutStableIdHeader(headers) {
+  if (headers === undefined) {
+    return headers;
+  }
+  if (!(stableIdHeader in headers)) {
+    return headers;
+  }
+  let out = Object.assign({}, headers);
+  Stdlib_Dict.$$delete(out, stableIdHeader);
+  if (Object.keys(out).length === 0) {
+    return;
+  } else {
+    return out;
+  }
+}
+
+function deriveStableMeta(parent, service, index, itemOpt) {
+  let item = itemOpt !== undefined ? itemOpt : 0;
+  return {
+    service: service,
+    time: new Date().toISOString(),
+    user: parent.user,
+    msgId: Uuid.v5(parent.msgId + `/` + service + `/` + index.toString() + `/` + item.toString(), derivedIdNamespace),
+    correlationId: parent.correlationId,
+    causationId: parent.msgId,
+    traceparent: parent.traceparent,
+    schemaVersion: parent.schemaVersion,
+    headers: withStableIdHeader(parent.headers)
+  };
+}
+
+export {
+  derivedIdNamespace,
+  stableIdHeader,
+  hasStableMsgId,
+  withStableIdHeader,
+  withoutStableIdHeader,
+  deriveStableMeta,
+}
+/* uuid Not a pure module */