@reventlessdev/reventless-aws 3.0.0-alpha.418 → 3.0.0-alpha.420

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.420 (2026-11-01)
+
+### Features
+
+* **core:** a component's log line carries the ids of the message it is about ([9c26267](https://github.com/ReventlessDev/reventless-core/commit/9c26267ca6d03ff66b8406caa32243e205e29b5a))
+
+
+# 3.0.0-alpha.419 (2026-11-01)
+
+### Features
+
+* **core:** a command's outcome, the flow through automations, and each view change are told ([dcaeed2](https://github.com/ReventlessDev/reventless-core/commit/dcaeed2fabe2047a21797b459f2931618474dec3))
+
+
 # 3.0.0-alpha.418 (2026-11-01)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.418",
+  "version": "3.0.0-alpha.420",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -22,19 +22,19 @@
     "sury": "11.0.0",
     "uuid": "^13.0.0",
     "yaml": "^2.8.3",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.37",
-    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.38",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.24",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.37",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.38",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.25",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.325",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.220",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.189",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.42",
     "@reventlessdev/rescript-web": "1.0.0-alpha.8",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.191"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.221",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.191",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.327",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.192",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.42"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs

@@ -31,10 +31,10 @@ function handleQueueEvent(queue, handleJsonCommands) {
             ReceiptHandle: result._0
           };
         }
-        Effect.runSync(EffectLogger$ReventlessCore.logError("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "handleQueueEvent: Couldn't handle command with ReceiptHandle: " + result._0));
+        Effect.runSync(EffectLogger$ReventlessCore.logError("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, undefined, "handleQueueEvent: Couldn't handle command with ReceiptHandle: " + result._0));
       }), x => x);
       if (deleteEntries.length !== 0) {
-        return Effect.catchAll(Effect.tap(Util_SQS_Runtime$ReventlessAws.deleteMessages(deleteEntries, queue), () => EffectLogger$ReventlessCore.logInfo("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "handleQueueEvent: Deleted all commands from queue")), errorMsg => EffectLogger$ReventlessCore.logError("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "handleQueueEvent: Couldn't deleteMessageBatch: " + errorMsg));
+        return Effect.catchAll(Effect.tap(Util_SQS_Runtime$ReventlessAws.deleteMessages(deleteEntries, queue), () => EffectLogger$ReventlessCore.logInfo("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, undefined, "handleQueueEvent: Deleted all commands from queue")), errorMsg => EffectLogger$ReventlessCore.logError("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, undefined, "handleQueueEvent: Couldn't deleteMessageBatch: " + errorMsg));
       } else {
         return Effect.succeed();
       }
@@ -52,7 +52,7 @@ function publishJsons(queue, queueService) {
         return await Effect.runPromise(Util_SQS_Runtime$ReventlessAws.send(queue, queueService, jsons[0]));
       }
     } else {
-      Effect.runPromise(EffectLogger$ReventlessCore.logInfo("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, "publishJsons: No commands to send"));
+      Effect.runPromise(EffectLogger$ReventlessCore.logInfo("CommandTopicChannel_SQS_Runtime-ReventlessAws", undefined, undefined, "publishJsons: No commands to send"));
       return;
     }
   };

package/src/adapter/EventCollector/EventCollectorChannel_SQS_Runtime.res.mjs

@@ -73,11 +73,11 @@ function handleDynamoDbEvent(handleEvents) {
 }
 
 function enqueueEvent(queue, delay, _id, messageBody) {
-  return Effect.runPromise(Effect.map(Effect.flatMap(EffectLogger$ReventlessCore.logInfo("EventCollectorChannel_SQS_Runtime-ReventlessAws", undefined, "enqueueEvent: " + delay.toString() + " " + messageBody + " " + queue.name), () => Effect.promise(() => Util_SQS_Runtime$ReventlessAws.sendMessage(queue, delay, messageBody))), () => {}));
+  return Effect.runPromise(Effect.map(Effect.flatMap(EffectLogger$ReventlessCore.logInfo("EventCollectorChannel_SQS_Runtime-ReventlessAws", undefined, undefined, "enqueueEvent: " + delay.toString() + " " + messageBody + " " + queue.name), () => Effect.promise(() => Util_SQS_Runtime$ReventlessAws.sendMessage(queue, delay, messageBody))), () => {}));
 }
 
 function enqueueFifoEvent(queue, delay, id, messageBody) {
-  return Effect.runPromise(Effect.map(Effect.flatMap(EffectLogger$ReventlessCore.logInfo("EventCollectorChannel_SQS_Runtime-ReventlessAws", undefined, "enqueueFifoEvent: " + delay.toString() + " " + messageBody + " " + queue.name), () => Effect.promise(() => Util_SQS_Runtime$ReventlessAws.sendFifoMessage(queue, delay, Util_SQS_Runtime$ReventlessAws.safeGroupId(id), messageBody))), () => {}));
+  return Effect.runPromise(Effect.map(Effect.flatMap(EffectLogger$ReventlessCore.logInfo("EventCollectorChannel_SQS_Runtime-ReventlessAws", undefined, undefined, "enqueueFifoEvent: " + delay.toString() + " " + messageBody + " " + queue.name), () => Effect.promise(() => Util_SQS_Runtime$ReventlessAws.sendFifoMessage(queue, delay, Util_SQS_Runtime$ReventlessAws.safeGroupId(id), messageBody))), () => {}));
 }
 
 export {

package/src/adapter/EventLog/EventLogStorage_DynamoDb_Runtime.res.mjs

@@ -248,7 +248,7 @@ function replayStream(table) {
 }
 
 function replay(table) {
-  return id => Effect$1.runPromise(Effect$1.catchAll(Stream.runCollect(replayStream(table)(id, undefined)), msg => Effect$1.flatMap(EffectLogger$ReventlessCore.logError("EventLogStorage_DynamoDb_Runtime-ReventlessAws", undefined, `Couldn't replay events for id ` + id + ` after retries: ` + msg), () => Effect$1.fail(msg))));
+  return id => Effect$1.runPromise(Effect$1.catchAll(Stream.runCollect(replayStream(table)(id, undefined)), msg => Effect$1.flatMap(EffectLogger$ReventlessCore.logError("EventLogStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `Couldn't replay events for id ` + id + ` after retries: ` + msg), () => Effect$1.fail(msg))));
 }
 
 function appendStream(table) {

package/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs

@@ -56,7 +56,7 @@ function load(table) {
   })), err => {
     let tableName = table.name;
     let msg = QueryDb$ReventlessCore.storageErrorToString(err);
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `load: Couldn't load state for ` + id + ` from ` + tableName + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `load: Couldn't load state for ` + id + ` from ` + tableName + `: ` + msg), () => ({
       TAG: "Error",
       _0: err
     }));
@@ -73,13 +73,13 @@ function save(table) {
       case "Init" :
         tmp = Effect$1.flatMap(Util_DynamoDb_Runtime$ReventlessAws.putIfNotExistsWithRetries(table.hashKey, table.rangeKey, table, id, json$1), result => {
           if (result.TAG === "Ok") {
-            return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: saved Init state to ` + tableName + `: id=` + id), () => ({
+            return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `save: saved Init state to ` + tableName + `: id=` + id), () => ({
               TAG: "Ok",
               _0: undefined
             }));
           }
           let errorMsg = result._0;
-          return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: Couldn't save Init state to ` + tableName + `, id=` + id + `: ` + errorMsg), () => ({
+          return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `save: Couldn't save Init state to ` + tableName + `, id=` + id + `: ` + errorMsg), () => ({
             TAG: "Error",
             _0: {
               TAG: "NotSavedToStorage",
@@ -96,13 +96,13 @@ function save(table) {
     if (exit === 1) {
       tmp = Effect$1.flatMap(Util_DynamoDb_Runtime$ReventlessAws.putWithRetries(table, id, json$1), result => {
         if (result.TAG === "Ok") {
-          return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: saved state to ` + tableName + `: id=` + id), () => ({
+          return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `save: saved state to ` + tableName + `: id=` + id), () => ({
             TAG: "Ok",
             _0: undefined
           }));
         }
         let errorMsg = result._0;
-        return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: Couldn't save state to ` + tableName + `, id=` + id + `: ` + errorMsg), () => ({
+        return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `save: Couldn't save state to ` + tableName + `, id=` + id + `: ` + errorMsg), () => ({
           TAG: "Error",
           _0: {
             TAG: "NotSavedToStorage",
@@ -127,7 +127,7 @@ function writeMultiple(writeRequests, op, ids, table) {
   let allIdsStr = ids.join(", ");
   let size = writeRequests.length;
   let batches = Stdlib_Math.Int.ceil(size / DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.maxBatchSize);
-  let logSplitEffect = batches > 1 ? EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `writeBatch: splitting up batch of size ` + size.toString() + ` into ` + batches.toString() + ` batches`) : Effect$1.succeed();
+  let logSplitEffect = batches > 1 ? EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `writeBatch: splitting up batch of size ` + size.toString() + ` into ` + batches.toString() + ` batches`) : Effect$1.succeed();
   let batchEffects = Stdlib_Array.fromInitializer(batches, batchNr => Effect$1.map(Util_DynamoDb_Runtime$ReventlessAws.batchWriteWithRetries(Util_DynamoDb_Runtime$ReventlessAws.toTable(sliceBatch(writeRequests, batchNr), tableName)), result => {
     let batchIds = sliceBatch(ids, batchNr);
     let batchCount = batchIds.length.toString();
@@ -142,14 +142,14 @@ function writeMultiple(writeRequests, op, ids, table) {
     concurrency: "unbounded"
   })), results => Stdlib_Array.filterMap(results, x => x)), errors => {
     if (errors.length === 0) {
-      return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `writeBatch: ` + op + ` ` + count + ` states: ` + tableName + `, ids:` + allIdsStr), () => ({
+      return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `writeBatch: ` + op + ` ` + count + ` states: ` + tableName + `, ids:` + allIdsStr), () => ({
         TAG: "Ok",
         _0: undefined
       }));
     }
     let errorsStr = errors.join("; ");
     let errorMsg = `writeBatch: Couldn't save states to ` + tableName + `: ` + errorsStr;
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, errorMsg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, errorMsg), () => ({
       TAG: "Error",
       _0: {
         TAG: "BatchNotFullyWrittenToStorage",
@@ -159,7 +159,7 @@ function writeMultiple(writeRequests, op, ids, table) {
   }), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
     let errorMsg = `writeBatch: Couldn't save states to ` + tableName + `, ` + count + ` ids:` + allIdsStr + `: ` + msg;
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, errorMsg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, errorMsg), () => ({
       TAG: "Error",
       _0: {
         TAG: "BatchNotFullyWrittenToStorage",
@@ -190,7 +190,7 @@ function saveBatch(table) {
 function count(table) {
   return (id, fieldName, inc) => {
     let tableName = table.name;
-    return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `count: ` + tableName + `, ` + id + `, ` + fieldName + `, ` + inc.toString()), () => Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "count"), () => DynamoDb_DocumentClient$AwsSdk.UpdateCommand.send(new LibDynamodb.UpdateCommand({
+    return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `count: ` + tableName + `, ` + id + `, ` + fieldName + `, ` + inc.toString()), () => Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "count"), () => DynamoDb_DocumentClient$AwsSdk.UpdateCommand.send(new LibDynamodb.UpdateCommand({
       Key: Object.fromEntries([[
           "id",
           id
@@ -214,7 +214,7 @@ function count(table) {
           _0: value
         });
       } else {
-        return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `count: Invalid updateOutput in count on ` + tableName), () => ({
+        return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `count: Invalid updateOutput in count on ` + tableName), () => ({
           TAG: "Error",
           _0: {
             TAG: "NotCountedOnStorage",
@@ -222,7 +222,7 @@ function count(table) {
           }
         }));
       }
-    }), errorMsg => Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `count: Couldn't count on ` + tableName + `: ` + errorMsg), () => ({
+    }), errorMsg => Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `count: Couldn't count on ` + tableName + `: ` + errorMsg), () => ({
       TAG: "Error",
       _0: {
         TAG: "NotCountedOnStorage",
@@ -237,13 +237,13 @@ function $$delete(table) {
     let tableName = table.name;
     return Effect$1.runPromise(Effect$1.flatMap(Util_DynamoDb_Runtime$ReventlessAws.deleteWithRetries(sort, table, id), result => {
       if (result.TAG === "Ok") {
-        return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `delete: deleted state from ` + tableName + `: id=` + id + `, sort=` + Stdlib_Option.getOr(JSON.stringify(sort), "None")), () => ({
+        return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `delete: deleted state from ` + tableName + `: id=` + id + `, sort=` + Stdlib_Option.getOr(JSON.stringify(sort), "None")), () => ({
           TAG: "Ok",
           _0: undefined
         }));
       }
       let errorMsg = result._0;
-      return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `delete: Couldn't delete state from ` + tableName + `, id=` + id + `, sort=` + Stdlib_Option.getOr(JSON.stringify(sort), "None") + `: ` + errorMsg), () => ({
+      return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `delete: Couldn't delete state from ` + tableName + `, id=` + id + `, sort=` + Stdlib_Option.getOr(JSON.stringify(sort), "None") + `: ` + errorMsg), () => ({
         TAG: "Error",
         _0: {
           TAG: "NotDeletedFromStorage",

package/src/adapter/QueryEngine/QueryEngine_DynamoDb.res.mjs

@@ -167,9 +167,9 @@ function queryByTableName(tableName, keyOpt, id, subIdConfig, filterConfigsOpt,
     Limit: params_Limit,
     ScanIndexForward: params_ScanIndexForward
   };
-  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logDebug("QueryEngine_DynamoDb-ReventlessAws", undefined, "queryByTableName params: " + LogFormat$ReventlessCore.truncate(Stdlib_Option.getOr(JSON.stringify(params), ""))), () => Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.queryStream(params)), items => items.map(js => JSON.parse(JSON.stringify(js)))), err => {
+  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logDebug("QueryEngine_DynamoDb-ReventlessAws", undefined, undefined, "queryByTableName params: " + LogFormat$ReventlessCore.truncate(Stdlib_Option.getOr(JSON.stringify(params), ""))), () => Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.queryStream(params)), items => items.map(js => JSON.parse(JSON.stringify(js)))), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
-    return Effect.map(EffectLogger$ReventlessCore.logError("QueryEngine_DynamoDb-ReventlessAws", undefined, "queryByTableName: " + msg), () => []);
+    return Effect.map(EffectLogger$ReventlessCore.logError("QueryEngine_DynamoDb-ReventlessAws", undefined, undefined, "queryByTableName: " + msg), () => []);
   })));
 }
 
@@ -197,9 +197,9 @@ function scanByTableName(tableName, filterConfigs, limit) {
     FilterExpression: params_FilterExpression,
     Limit: params_Limit
   };
-  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logDebug("QueryEngine_DynamoDb-ReventlessAws", undefined, "scanByTableName params: " + LogFormat$ReventlessCore.truncate(Stdlib_Option.getOr(JSON.stringify(params), ""))), () => Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream(params)), items => items.map(js => JSON.parse(JSON.stringify(js)))), err => {
+  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logDebug("QueryEngine_DynamoDb-ReventlessAws", undefined, undefined, "scanByTableName params: " + LogFormat$ReventlessCore.truncate(Stdlib_Option.getOr(JSON.stringify(params), ""))), () => Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream(params)), items => items.map(js => JSON.parse(JSON.stringify(js)))), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
-    return Effect.map(EffectLogger$ReventlessCore.logError("QueryEngine_DynamoDb-ReventlessAws", undefined, "scanByTableName: " + msg), () => []);
+    return Effect.map(EffectLogger$ReventlessCore.logError("QueryEngine_DynamoDb-ReventlessAws", undefined, undefined, "scanByTableName: " + msg), () => []);
   })));
 }
 

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -539,7 +539,7 @@ let makeOutboundJsonEventsHandler = (
           ->Option.getOr("")
         let (eventType, dataDict) = rawEvent->ReventlessCore.Message.splitMessage
         switch decoder.decode(~eventType, ~data=dataDict) {
-        | Some(event) => [(sourceId, event)]
+        | Some(event) => [(sourceId, event, ReventlessCore.Message.metaOfEnvelope(envelope))]
         | None => []
         }
       })
@@ -549,7 +549,11 @@ let makeOutboundJsonEventsHandler = (
     ->Effect.flatMap(events =>
       Effect.promise(async () => {
         await loadTodoItems()
-        await callback.phase1(events, ~capabilities=capabilities())
+        await callback.phase1(
+          events->Array.map(((sourceId, event, _)) => (sourceId, event)),
+          ~metas=events->Array.map(((_, _, meta)) => meta),
+          ~capabilities=capabilities(),
+        )
         await syncTodoItems()
         await callback.phase2(publishJsons, ~capabilities=capabilities())
         await syncTodoItems()

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res.mjs

@@ -187,9 +187,9 @@ function makeLoadTodoItems(queryDbTableName, todoItems, rowSchema, comp) {
       }
       todoItems[id] = row;
       return count + 1 | 0;
-    })), err => Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `restore: couldn't read pending TODO rows from ` + queryDbTableName + `: ` + DynamoDb_Error$ReventlessAws.message(err)), () => 0)));
+    })), err => Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, undefined, `restore: couldn't read pending TODO rows from ` + queryDbTableName + `: ` + DynamoDb_Error$ReventlessAws.message(err)), () => 0)));
     if (restored > 0) {
-      return Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `restore: reloaded ` + restored.toString() + ` unfinished TODO row(s) from ` + queryDbTableName));
+      return Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, undefined, `restore: reloaded ` + restored.toString() + ` unfinished TODO row(s) from ` + queryDbTableName));
     }
   };
 }
@@ -237,7 +237,7 @@ function makeScheduleStore(tableName, rows, comp) {
           return;
         }
       });
-    }), err => EffectLogger$ReventlessCore.logError(comp, undefined, `restore: couldn't read the schedules from ` + tableName + `: ` + DynamoDb_Error$ReventlessAws.message(err))));
+    }), err => EffectLogger$ReventlessCore.logError(comp, undefined, undefined, `restore: couldn't read the schedules from ` + tableName + `: ` + DynamoDb_Error$ReventlessAws.message(err))));
     stored.contents = Object.keys(rows);
   };
   let sync = async () => {
@@ -323,14 +323,18 @@ function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJso
     if (event !== undefined) {
       return [[
           sourceId,
-          Primitive_option.valFromOption(event)
+          Primitive_option.valFromOption(event),
+          Message$ReventlessCore.metaOfEnvelope(envelope)
         ]];
     } else {
       return [];
     }
   })), events => Stream$1.fromIterable(events))), events => Effect.promise(async () => {
     await loadTodoItems();
-    await callback.phase1(events, capabilities());
+    await callback.phase1(events.map(param => [
+      param[0],
+      param[1]
+    ]), events.map(param => param[2]), capabilities());
     await syncTodoItems();
     await callback.phase2(publishJsons, capabilities());
     return await syncTodoItems();
@@ -436,7 +440,7 @@ async function runSweeps(slices) {
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
-      Effect.runSync(EffectLogger$ReventlessCore.logError(slice.comp, undefined, `sweep failed: ` + msg));
+      Effect.runSync(EffectLogger$ReventlessCore.logError(slice.comp, undefined, undefined, `sweep failed: ` + msg));
     }
   }
 }
@@ -461,7 +465,7 @@ async function reconcileSchedules(slices) {
   for (let i = 0, i_finish = reconciles.length; i < i_finish; ++i) {
     await reconciles[i]();
   }
-  return Effect.runSync(EffectLogger$ReventlessCore.logInfo("AutomationSliceRuntime", undefined, `reconcile: the schedules of ` + reconciles.length.toString() + ` automation(s) are in line`));
+  return Effect.runSync(EffectLogger$ReventlessCore.logInfo("AutomationSliceRuntime", undefined, undefined, `reconcile: the schedules of ` + reconciles.length.toString() + ` automation(s) are in line`));
 }
 
 export {

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res.mjs

@@ -45,7 +45,7 @@ function deriveScope(specs) {
     let err = Primitive_exceptions.internalToException(raw_err);
     if (err.RE_EXN_ID === "JsExn") {
       let err$1 = err._1;
-      Effect.runSync(EffectLogger$ReventlessCore.logError("DcbCommandTopicRuntime", undefined, `refusing to start: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(err$1), "unknown error")));
+      Effect.runSync(EffectLogger$ReventlessCore.logError("DcbCommandTopicRuntime", undefined, undefined, `refusing to start: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(err$1), "unknown error")));
       throw err$1;
     }
     throw err;
@@ -135,12 +135,12 @@ async function persistAudit(callback, auditQueryDbOps, result) {
     if (err.TAG === "Ok") {
       return;
     } else {
-      return Effect.runSync(EffectLogger$ReventlessCore.logError("InboundTranslationSlice.audit", undefined, `failed to persist audit row ` + id + `: ` + QueryDb$ReventlessCore.storageErrorToString(err._0)));
+      return Effect.runSync(EffectLogger$ReventlessCore.logError("InboundTranslationSlice.audit", undefined, undefined, `failed to persist audit row ` + id + `: ` + QueryDb$ReventlessCore.storageErrorToString(err._0)));
     }
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     let detail = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
-    return Effect.runSync(EffectLogger$ReventlessCore.logError("InboundTranslationSlice.audit", undefined, `failed to persist audit row ` + id + `: ` + detail));
+    return Effect.runSync(EffectLogger$ReventlessCore.logError("InboundTranslationSlice.audit", undefined, undefined, `failed to persist audit row ` + id + `: ` + detail));
   }
 }
 

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res

@@ -126,6 +126,20 @@ let decodeEnvelope = (json: JSON.t): envelope<'event> => {
 
 let exnMessage = StreamRoutedEntryPoint_Ops.exnMessage
 
+// The event an envelope carries, as the source of the rows its actions change.
+// Read off the JSON, like `producerTime`: an envelope without a meta yields none.
+let sourcesOf = (json: JSON.t): array<ReventlessCore.Projection.changeSource> => {
+  let fields = json->JSON.Decode.object->Option.getOr(Dict.make())
+  let meta = fields->Dict.get("meta")->Option.flatMap(JSON.Decode.object)
+  let string = (d, k) => d->Option.flatMap(d => d->Dict.get(k))->Option.flatMap(JSON.Decode.string)
+  switch string(meta, "msgId") {
+  | Some(msgId) =>
+    let (entityId, entityType) = ReventlessCore.ViewChange.entityOfEnvelope(fields)
+    [{msgId, correlationId: ?string(meta, "correlationId"), ?entityId, ?entityType}]
+  | None => []
+  }
+}
+
 // The typed core of buildJsonEventsHandler: decode each envelope, parse the
 // event against the slice's consumed-event schema, project, and run every
 // resulting action against the view table. A decode failure logs and yields no
@@ -140,7 +154,13 @@ let makeJsonEventsHandler = (
   ~queryDbOps: ReventlessCore.QueryDb_Adapter.operations,
   ~subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
   ~stateSchema: option<S.t<unknown>>,
-): ReventlessCore.EventCollector.jsonEventsHandler =>
+): ReventlessCore.EventCollector.jsonEventsHandler => {
+  // Each row the events change is logged; the states are already JSON.
+  let onChange = ReventlessCore.ViewChange.reporter(
+    ~comp=sliceName,
+    ~view=sliceName,
+    ~stateToJson=state => state,
+  )
   stream =>
     stream
     ->Stream.mapEffect(json =>
@@ -155,11 +175,14 @@ let makeJsonEventsHandler = (
           // The deployed slice assembles JSON-level operations rather than going
           // through the typed rewrite, so the trail is appended here — with this
           // envelope's own time, which the apply below no longer has.
-          producerTime === ""
-            ? actions
-            : actions->Array.map(
-                ReventlessCore.Projection.rewriteJsonAction(_, ~at=producerTime, ~stateSchema),
-              )
+          let sources = sourcesOf(json)
+          let actions =
+            producerTime === ""
+              ? actions
+              : actions->Array.map(
+                  ReventlessCore.Projection.rewriteJsonAction(_, ~at=producerTime, ~stateSchema),
+                )
+          actions->Array.map(action => (action, sources))
         } catch {
         | exn =>
           StreamRoutedEntryPoint_Ops.logError(
@@ -171,7 +194,7 @@ let makeJsonEventsHandler = (
       )
     )
     ->Stream.flatMap(actions => Stream.fromIterable(actions))
-    ->Stream.runForEach(action =>
+    ->Stream.runForEach(((action, sources)) =>
       // Thread the slice's `subIdConfig` (generated from `@subId`) so
       // sub-id-dependent actions like `UpdateMultiState` can resolve the sort
       // key. Dropping it here made every such action hit the
@@ -181,9 +204,17 @@ let makeJsonEventsHandler = (
       // actions. `~comp` is the slice's spec name — attribution for
       // Projection.handleAction's debug-lazy action log.
       Effect.promise(() =>
-        ReventlessCore.Projection.handleAction(~comp=sliceName, action, queryDbOps, subIdConfig)
+        ReventlessCore.Projection.handleAction(
+          ~comp=sliceName,
+          ~sources,
+          ~onChange,
+          action,
+          queryDbOps,
+          subIdConfig,
+        )
       )->Effect.map(_ => ())
     )
+}
 
 // ── Handler assembly (called by the shell per HANDLER_CONFIG entry) ─────────
 // `sliceModules` types the shell's reads off the two dynamically imported

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs

@@ -8,6 +8,7 @@ import * as Stream from "effect/Stream";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Projection$ReventlessCore from "@reventlessdev/reventless-core/src/Projection.res.mjs";
+import * as ViewChange$ReventlessCore from "@reventlessdev/reventless-core/src/ViewChange.res.mjs";
 import * as ProjectionEntryPoint_Ops$ReventlessAws from "./ProjectionEntryPoint_Ops.res.mjs";
 import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
 
@@ -64,7 +65,25 @@ function decodeEnvelope(json) {
   };
 }
 
+function sourcesOf(json) {
+  let fields = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(json), {});
+  let meta = Stdlib_Option.flatMap(fields["meta"], Stdlib_JSON.Decode.object);
+  let string = (d, k) => Stdlib_Option.flatMap(Stdlib_Option.flatMap(d, d => d[k]), Stdlib_JSON.Decode.string);
+  let msgId = string(meta, "msgId");
+  if (msgId === undefined) {
+    return [];
+  }
+  let match = ViewChange$ReventlessCore.entityOfEnvelope(fields);
+  return [{
+      msgId: msgId,
+      correlationId: string(meta, "correlationId"),
+      entityId: match[0],
+      entityType: match[1]
+    }];
+}
+
 function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subIdConfig, stateSchema) {
+  let onChange = ViewChange$ReventlessCore.reporter(sliceName, sliceName, state => state);
   return stream => Stream.runForEach(Stream.flatMap(Stream.mapEffect(stream, json => Effect.sync(() => {
     try {
       let match = decodeEnvelope(json);
@@ -74,11 +93,12 @@ function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subI
         meta: match.meta,
         recordedAt: match.recordedAt
       });
-      if (producerTime === "") {
-        return actions;
-      } else {
-        return actions.map(__x => Projection$ReventlessCore.rewriteJsonAction(__x, producerTime, stateSchema));
-      }
+      let sources = sourcesOf(json);
+      let actions$1 = producerTime === "" ? actions : actions.map(__x => Projection$ReventlessCore.rewriteJsonAction(__x, producerTime, stateSchema));
+      return actions$1.map(action => [
+        action,
+        sources
+      ]);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       StreamRoutedEntryPoint_Ops$ReventlessAws.logError("failed to decode event", {
@@ -87,7 +107,11 @@ function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subI
       });
       return [];
     }
-  })), actions => Stream.fromIterable(actions)), action => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(sliceName, action, queryDbOps, subIdConfig)), param => {}));
+  })), actions => Stream.fromIterable(actions)), param => {
+    let sources = param[1];
+    let action = param[0];
+    return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(sliceName, sources, onChange, action, queryDbOps, subIdConfig)), param => {});
+  });
 }
 
 function makeRegisteredHandler(entry, modules) {
@@ -106,6 +130,7 @@ export {
   parseHandlerConfig,
   decodeEnvelope,
   exnMessage,
+  sourcesOf,
   makeJsonEventsHandler,
   makeRegisteredHandler,
 }

package/src/adapter/ScheduledPublisher/ScheduledPublisher_EventBridgeScheduler_Runtime.res.mjs

@@ -60,7 +60,7 @@ function scheduleInput(roleArn, targetArn, setAt, schedule) {
 
 function failWithoutQueue(action) {
   let err = action + ` not possible: no Queue configured !`;
-  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logError("ScheduledPublisher_EventBridgeScheduler_Runtime-ReventlessAws", undefined, err), () => Effect.sync(() => Stdlib_JsError.throwWithMessage(err))));
+  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logError("ScheduledPublisher_EventBridgeScheduler_Runtime-ReventlessAws", undefined, undefined, err), () => Effect.sync(() => Stdlib_JsError.throwWithMessage(err))));
 }
 
 async function putSchedule(roleArn, targetArn, schedule) {

package/src/plugin/runtime/Util_PluginMessage_Runtime.res.mjs

@@ -9,7 +9,7 @@ import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src
 function sendMessage(channelId, messageBody) {
   return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SQS_Error$ReventlessAws.classify, () => SQS_Helpers$AwsSdk.sendMessage(channelId, messageBody, undefined, undefined, undefined)), () => {}), SQS_Error$ReventlessAws.retrySchedule), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_PluginMessage_Runtime-ReventlessAws", undefined, "Failed to send message to channel: " + msg), () => Effect$1.fail(err));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_PluginMessage_Runtime-ReventlessAws", undefined, undefined, "Failed to send message to channel: " + msg), () => Effect$1.fail(err));
   }));
 }
 

package/src/util/Util_CognitoGroupUser_Runtime.res.mjs

@@ -21,7 +21,7 @@ function addUserToGroup(region, userName, groupName, userPoolId) {
     return client.send(addUserToGroupCommand);
   }), () => {}), Cognito_Error$ReventlessAws.retrySchedule), err => {
     let msg = Cognito_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, `addUserToGroup: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, undefined, `addUserToGroup: ` + msg), () => Effect$1.fail(msg));
   }));
 }
 
@@ -39,7 +39,7 @@ function removeUserFromGroup(region, userName, groupName, userPoolId) {
     return client.send(removeUserFromGroupCommand);
   }), () => {}), Cognito_Error$ReventlessAws.retrySchedule), err => {
     let msg = Cognito_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, `removeUserFromGroup: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, undefined, `removeUserFromGroup: ` + msg), () => Effect$1.fail(msg));
   }));
 }
 

package/src/util/Util_Cognito_Runtime.res.mjs

@@ -24,7 +24,7 @@ function signUp(region, userPoolId, userPoolClientId, userName, password) {
 }
 
 function signUpIfMissing(region, userPoolId, userPoolClientId, userName, password) {
-  return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect.tryPromise(Cognito_Error$ReventlessAws.classify, () => signUp(region, userPoolId, userPoolClientId, userName, password)), result => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, `Created User ` + userName + ` ` + Stdlib_Option.getOr(result.UserSub, ""))), err => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, Cognito_Error$ReventlessAws.message(err))));
+  return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect.tryPromise(Cognito_Error$ReventlessAws.classify, () => signUp(region, userPoolId, userPoolClientId, userName, password)), result => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, undefined, `Created User ` + userName + ` ` + Stdlib_Option.getOr(result.UserSub, ""))), err => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, undefined, Cognito_Error$ReventlessAws.message(err))));
 }
 
 export {

package/src/util/Util_DynamoDb_Runtime.res.mjs

@@ -46,7 +46,7 @@ function putWithRetries(table, id, item) {
         break;
     }
     let msg = err._0;
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `putWithRetries: id=` + id + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `putWithRetries: id=` + id + `: ` + msg), () => ({
       TAG: "Error",
       _0: `put id=` + id + ` failed: ` + msg
     }));
@@ -70,7 +70,7 @@ function putIfNotExistsWithRetries(idKey, sortKey, table, id, item) {
         break;
     }
     let msg = err._0;
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `putIfNotExistsWithRetries: id=` + id + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `putIfNotExistsWithRetries: id=` + id + `: ` + msg), () => ({
       TAG: "Error",
       _0: `putIfNotExists id=` + id + ` failed: ` + msg
     }));
@@ -87,7 +87,7 @@ function deleteWithRetries(sort, table, id) {
     _0: undefined
   })), DynamoDb_Error$ReventlessAws.retrySchedule), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `delete: id=` + id + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `delete: id=` + id + `: ` + msg), () => ({
       TAG: "Error",
       _0: `delete id=` + id + ` failed: ` + msg
     }));
@@ -199,7 +199,7 @@ function batchWriteWithRetries(batchWriteRequests) {
     }
     let unprocessedRequests = Stdlib_Option.getOrThrow(writeOutput.UnprocessedItems, undefined);
     let count = Object.keys(unprocessedRequests).length.toString();
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_DynamoDb_Runtime-ReventlessAws", undefined, `batchWriteWithRetries: retry ` + retry.toString() + `: ` + count + ` unprocessed items`), () => attempt(retry + 1 | 0, unprocessedRequests));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `batchWriteWithRetries: retry ` + retry.toString() + `: ` + count + ` unprocessed items`), () => attempt(retry + 1 | 0, unprocessedRequests));
   }), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
     return Effect$1.succeed({

package/src/util/Util_Kinesis_Runtime.res.mjs

@@ -14,7 +14,7 @@ function putRecord(stream, data) {
     PartitionKey: ""
   }))), param => {}), Kinesis_Error$ReventlessAws.retrySchedule), err => {
     let msg = Kinesis_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_Kinesis_Runtime-ReventlessAws", undefined, `putRecord: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_Kinesis_Runtime-ReventlessAws", undefined, undefined, `putRecord: ` + msg), () => Effect$1.fail(msg));
   }));
 }
 

package/src/util/Util_SNS_Runtime.res.mjs

@@ -9,14 +9,14 @@ import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src
 function publish(topic, message) {
   return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SNS_Error$ReventlessAws.classify, () => SNS_Helpers$AwsSdk.publish(topic.arn, undefined, message)), param => {}), SNS_Error$ReventlessAws.retrySchedule), err => {
     let msg = SNS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, "publish: " + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, undefined, "publish: " + msg), () => Effect$1.fail(msg));
   }));
 }
 
 function publishFifo(topic, messageGroupId, message) {
   return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SNS_Error$ReventlessAws.classify, () => SNS_Helpers$AwsSdk.publish(topic.arn, messageGroupId, message)), param => {}), SNS_Error$ReventlessAws.retrySchedule), err => {
     let msg = SNS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, "publishFifo: " + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, undefined, "publishFifo: " + msg), () => Effect$1.fail(msg));
   }));
 }
 

package/src/util/Util_SQS_Runtime.res.mjs

@@ -44,7 +44,7 @@ function send(queue, queueService, commandJson) {
     }
   }), () => {}), SQS_Error$ReventlessAws.sendRetrySchedule), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, "send: " + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, undefined, "send: " + msg), () => Effect$1.fail(msg));
   });
 }
 
@@ -69,7 +69,7 @@ function sendMessages(queue, queueService, commandJsons) {
       return failedIds.some(failedId => failedId === msgId);
     });
     if (retry < 5) {
-      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, `sendMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, commandJsonsToRetry));
+      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `sendMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, commandJsonsToRetry));
     }
     let ids = failedIds.join(", ");
     return Effect$1.fail({
@@ -79,7 +79,7 @@ function sendMessages(queue, queueService, commandJsons) {
   });
   return Effect$1.catchAll(attempt(0, commandJsons), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, `sendMessages: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `sendMessages: ` + msg), () => Effect$1.fail(msg));
   });
 }
 
@@ -104,7 +104,7 @@ function deleteMessages(entries, queue) {
       ReceiptHandle: entry.ReceiptHandle
     }));
     if (retry < 5) {
-      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, `deleteMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, entriesToRetry));
+      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `deleteMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, entriesToRetry));
     }
     let ids = failedIds.join(", ");
     return Effect$1.fail({
@@ -114,7 +114,7 @@ function deleteMessages(entries, queue) {
   });
   return Effect$1.catchAll(attempt(0, entries), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, `deleteMessages: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `deleteMessages: ` + msg), () => Effect$1.fail(msg));
   });
 }
 

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -388,7 +388,7 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
     let received = ref([])
     let callback: AutomationSliceEntryPoint_Ops.outboundCallback<outboundEvent> = {
       todoItems: Dict.make(),
-      phase1: async (events, ~capabilities as _) => {
+      phase1: async (events, ~metas as _=?, ~capabilities as _) => {
         received := events
         steps->Array.push("phase1")
       },

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -581,7 +581,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       contents: []
     };
     let callback_todoItems = {};
-    let callback_phase1 = async (events, param) => {
+    let callback_phase1 = async (events, param, param$1) => {
       received.contents = events;
       steps.push("phase1");
     };