@reventlessdev/reventless-local 3.0.0-alpha.312 → 3.0.0-alpha.314

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.314 (2026-10-30)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
+# 3.0.0-alpha.313 (2026-10-30)
+
+### Features
+
+* **automation:** a work item with personal data is stored like an event ([f9e173f](https://github.com/ReventlessDev/reventless-core/commit/f9e173fb6f1dc671900052f2c4b6590ee99b5bdf))
+
+
 # 3.0.0-alpha.312 (2026-10-30)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.312",
+  "version": "3.0.0-alpha.314",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,23 +35,23 @@
     "sury": "11.0.0",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.24",
     "@reventlessdev/rescript-node": "2.0.0-alpha.24",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.321",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.169",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.218",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.185",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.323",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.171",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.219",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.187",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.271",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.39",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.269",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.189"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.190"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.109"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.111"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/components/AutomationSlice_Builder.res

@@ -26,6 +26,7 @@ module Make = (Bus: LocalBus.T) => {
     EventCollectorRuntimeBuilder,
     Api,
     LocalAutomationSchedules,
+    LocalCapabilities,
   )
 
   module Make = (

package/src/components/AutomationSlice_Builder.res.mjs

@@ -7,6 +7,7 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as TestRunner$ReventlessLocal from "../test/TestRunner.res.mjs";
 import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+import * as LocalCapabilities$ReventlessLocal from "../adapter/LocalCapabilities.res.mjs";
 import * as LocalQueryDbStorage$ReventlessLocal from "../adapter/QueryDb/LocalQueryDbStorage.res.mjs";
 import * as LocalAutomationSweep$ReventlessLocal from "./LocalAutomationSweep.res.mjs";
 import * as AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
@@ -42,6 +43,8 @@ function Make(Bus) {
     make: QueryDbResolvers.make
   })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api)({
     platformFor: LocalAutomationSchedules$ReventlessLocal.platformFor
+  })({
+    capabilities: LocalCapabilities$ReventlessLocal.capabilities
   });
   let Make$1 = Spec => (Automation => {
     let Inner = CoreMaker.Make(Spec)(Automation);

package/tests/components/automationslice/AutomationSliceCallbackTest.res

@@ -29,7 +29,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
       "OrderPlaced JSON creates a pending TODO item",
       async () => {
         let json = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
-        Callback.phase1([json], testContext)
+        await Callback.phase1([json], testContext, ~capabilities=Reventless.Capabilities.none)
         let items = Callback.todoItems
         expect(items->Dict.toArray->Array.length)->toBe(1)
         let row = items->Dict.get("ord-1")->Option.getOrThrow
@@ -43,8 +43,8 @@ describe("AutomationSlice Callback (mixed-source)", () => {
       async () => {
         let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
         let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "456 Oak Ave"}))
-        Callback.phase1([j1], testContext)
-        Callback.phase1([j2], testContext)
+        await Callback.phase1([j1], testContext, ~capabilities=Reventless.Capabilities.none)
+        await Callback.phase1([j2], testContext, ~capabilities=Reventless.Capabilities.none)
         expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(1)
       },
     )
@@ -54,7 +54,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
       async () => {
         let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
         let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-2", address: "456 Oak Ave"}))
-        Callback.phase1([j1, j2], testContext)
+        await Callback.phase1([j1, j2], testContext, ~capabilities=Reventless.Capabilities.none)
         expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(2)
       },
     )
@@ -63,7 +63,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
       "ShipmentCreated does not create a TODO item",
       async () => {
         let json = encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))
-        Callback.phase1([json], testContext)
+        await Callback.phase1([json], testContext, ~capabilities=Reventless.Capabilities.none)
         expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
       },
     )
@@ -73,11 +73,16 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "ShipmentCreated marks pending TODO item as completed",
       async () => {
-        Callback.phase1(
+        await Callback.phase1(
           [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
           testContext,
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        await Callback.phase1(
+          [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
+          testContext,
+          ~capabilities=Reventless.Capabilities.none,
         )
-        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))], testContext)
         let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
         expect(row.status)->toBe(Completed)
       },
@@ -86,7 +91,11 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "ShipmentCreated for unknown id is a no-op",
       async () => {
-        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "unknown"}))], testContext)
+        await Callback.phase1(
+          [encodeShipOrderEvent(ShipmentCreated({orderId: "unknown"}))],
+          testContext,
+          ~capabilities=Reventless.Capabilities.none,
+        )
         expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
       },
     )
@@ -96,9 +105,10 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "pending items produce commands via publishJsons",
       async () => {
-        Callback.phase1(
+        await Callback.phase1(
           [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
           testContext,
+          ~capabilities=Reventless.Capabilities.none,
         )
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
@@ -118,11 +128,16 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "completed items are not processed",
       async () => {
-        Callback.phase1(
+        await Callback.phase1(
           [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
           testContext,
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        await Callback.phase1(
+          [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
+          testContext,
+          ~capabilities=Reventless.Capabilities.none,
         )
-        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))], testContext)
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
           publishedCommands := cmds
@@ -136,7 +151,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
       "items where process returns None are skipped",
       async () => {
         let json = encodeSkipProcessEvent(OrderPlaced({orderId: "ord-1"}))
-        SkipCallback.phase1([json], testContext)
+        await SkipCallback.phase1([json], testContext, ~capabilities=Reventless.Capabilities.none)
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
           publishedCommands := cmds
@@ -163,9 +178,10 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "publishJsons failure marks items as Failed",
       async () => {
-        Callback.phase1(
+        await Callback.phase1(
           [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
           testContext,
+          ~capabilities=Reventless.Capabilities.none,
         )
         let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
           JsError.throwWithMessage("publish failed")
@@ -180,9 +196,10 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "failed items with retryCount < maxRetries are retried",
       async () => {
-        Callback.phase1(
+        await Callback.phase1(
           [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
           testContext,
+          ~capabilities=Reventless.Capabilities.none,
         )
         let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
           JsError.throwWithMessage("publish failed")
@@ -210,10 +227,11 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds =>
       JsError.throwWithMessage("publish failed")
 
-    let collectOne = () =>
-      Callback.phase1(
+    let collectOne = async () =>
+      await Callback.phase1(
         [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
         testContext,
+        ~capabilities=Reventless.Capabilities.none,
       )
 
     let statusOf = id => (Callback.todoItems->Dict.get(id)->Option.getOrThrow).status
@@ -221,7 +239,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "the attempt that spends the budget writes Abandoned, not Failed",
       async () => {
-        collectOne()
+        await collectOne()
         // ShipOrderSpec.maxRetries is 3: attempts at retryCount 0, 1 and 2 leave the
         // row retriable, and the third failure is the one that ends it.
         await Callback.phase2(failingPublish)
@@ -237,7 +255,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "an abandoned row is not picked up again",
       async () => {
-        collectOne()
+        await collectOne()
         await Callback.phase2(failingPublish)
         await Callback.phase2(failingPublish)
         await Callback.phase2(failingPublish)
@@ -256,7 +274,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "a row left stranded at the ceiling is normalised on the next pass",
       async () => {
-        collectOne()
+        await collectOne()
         // What an older build wrote, and what a Spec that lowered maxRetries leaves
         // behind: Failed at the ceiling, which no pass would ever pick up or mark.
         let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
@@ -272,7 +290,7 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "the row carries the ceiling its count is racing",
       async () => {
-        collectOne()
+        await collectOne()
         expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)->toEqual(
           Some(ShipOrderSpec.maxRetries),
         )
@@ -284,9 +302,10 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     testPromise(
       "collect → process → resolve completes the TODO item",
       async () => {
-        Callback.phase1(
+        await Callback.phase1(
           [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
           testContext,
+          ~capabilities=Reventless.Capabilities.none,
         )
         expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Pending)
 
@@ -298,7 +317,11 @@ describe("AutomationSlice Callback (mixed-source)", () => {
         expect(publishedCommands.contents->Array.length)->toBe(1)
         expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Processing)
 
-        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))], testContext)
+        await Callback.phase1(
+          [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
+          testContext,
+          ~capabilities=Reventless.Capabilities.none,
+        )
         expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Completed)
 
         let publishedCommands2 = ref([])

package/tests/components/automationslice/AutomationSliceCallbackTest.res.mjs

@@ -3,6 +3,7 @@
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as AutomationSliceFixtures$ReventlessLocal from "./AutomationSliceFixtures.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
 
@@ -22,7 +23,7 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
         orderId: "ord-1",
         address: "123 Main St"
       });
-      Callback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext);
+      await Callback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let items = Callback.todoItems;
       globalThis.expect(Object.entries(items).length).toBe(1);
       let row = Stdlib_Option.getOrThrow(items["ord-1"], undefined);
@@ -40,8 +41,8 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
         orderId: "ord-1",
         address: "456 Oak Ave"
       });
-      Callback.phase1([j1], AutomationSliceFixtures$ReventlessLocal.testContext);
-      Callback.phase1([j2], AutomationSliceFixtures$ReventlessLocal.testContext);
+      await Callback.phase1([j1], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
+      await Callback.phase1([j2], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       globalThis.expect(Object.entries(Callback.todoItems).length).toBe(1);
     });
     globalThis.test("multiple OrderPlaced events create multiple TODO items", async () => {
@@ -55,10 +56,10 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
         orderId: "ord-2",
         address: "456 Oak Ave"
       });
-      Callback.phase1([
+      await Callback.phase1([
         j1,
         j2
-      ], AutomationSliceFixtures$ReventlessLocal.testContext);
+      ], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       globalThis.expect(Object.entries(Callback.todoItems).length).toBe(2);
     });
     globalThis.test("ShipmentCreated does not create a TODO item", async () => {
@@ -66,39 +67,39 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
         TAG: "ShipmentCreated",
         orderId: "ord-1"
       });
-      Callback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext);
+      await Callback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       globalThis.expect(Object.entries(Callback.todoItems).length).toBe(0);
     });
   });
   globalThis.describe("Phase 1 — resolve", () => {
     globalThis.test("ShipmentCreated marks pending TODO item as completed", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "OrderPlaced",
           orderId: "ord-1",
           address: "123 Main St"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "ShipmentCreated",
           orderId: "ord-1"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined);
       globalThis.expect(row.status).toBe("Completed");
     });
     globalThis.test("ShipmentCreated for unknown id is a no-op", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "ShipmentCreated",
           orderId: "unknown"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       globalThis.expect(Object.entries(Callback.todoItems).length).toBe(0);
     });
   });
   globalThis.describe("Phase 2 — process", () => {
     globalThis.test("pending items produce commands via publishJsons", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "OrderPlaced",
           orderId: "ord-1",
           address: "123 Main St"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -113,15 +114,15 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(row.status).toBe("Processing");
     });
     globalThis.test("completed items are not processed", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "OrderPlaced",
           orderId: "ord-1",
           address: "123 Main St"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "ShipmentCreated",
           orderId: "ord-1"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -136,7 +137,7 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
         TAG: "OrderPlaced",
         orderId: "ord-1"
       });
-      SkipCallback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext);
+      await SkipCallback.phase1([json], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -159,11 +160,11 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(publishedCommands.contents.length).toBe(0);
     });
     globalThis.test("publishJsons failure marks items as Failed", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "OrderPlaced",
           orderId: "ord-1",
           address: "123 Main St"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let failingPublish = async _cmds => Stdlib_JsError.throwWithMessage("publish failed");
       await Callback.phase2(failingPublish);
       let row = Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined);
@@ -171,11 +172,11 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(row.retryCount).toBe(1);
     });
     globalThis.test("failed items with retryCount < maxRetries are retried", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "OrderPlaced",
           orderId: "ord-1",
           address: "123 Main St"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       let failingPublish = async _cmds => Stdlib_JsError.throwWithMessage("publish failed");
       await Callback.phase2(failingPublish);
       let row1 = Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined);
@@ -194,14 +195,14 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
   });
   globalThis.describe("retry exhaustion", () => {
     let failingPublish = async _cmds => Stdlib_JsError.throwWithMessage("publish failed");
-    let collectOne = () => Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+    let collectOne = async () => await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
         TAG: "OrderPlaced",
         orderId: "ord-1",
         address: "123 Main St"
-      })], AutomationSliceFixtures$ReventlessLocal.testContext);
+      })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
     let statusOf = id => Stdlib_Option.getOrThrow(Callback.todoItems[id], undefined).status;
     globalThis.test("the attempt that spends the budget writes Abandoned, not Failed", async () => {
-      collectOne();
+      await collectOne();
       await Callback.phase2(failingPublish);
       globalThis.expect(statusOf("ord-1")).toBe("Failed");
       await Callback.phase2(failingPublish);
@@ -211,7 +212,7 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).retryCount).toBe(3);
     });
     globalThis.test("an abandoned row is not picked up again", async () => {
-      collectOne();
+      await collectOne();
       await Callback.phase2(failingPublish);
       await Callback.phase2(failingPublish);
       await Callback.phase2(failingPublish);
@@ -227,7 +228,7 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).retryCount).toBe(3);
     });
     globalThis.test("a row left stranded at the ceiling is normalised on the next pass", async () => {
-      collectOne();
+      await collectOne();
       let row = Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined);
       let newrecord = {...row};
       newrecord.retryCount = 3;
@@ -243,17 +244,17 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
     });
     globalThis.test("the row carries the ceiling its count is racing", async () => {
-      collectOne();
+      await collectOne();
       globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).maxRetries).toEqual(AutomationSliceFixtures$ReventlessLocal.ShipOrderSpec.maxRetries);
     });
   });
   globalThis.describe("full lifecycle", () => {
     globalThis.test("collect → process → resolve completes the TODO item", async () => {
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "OrderPlaced",
           orderId: "ord-1",
           address: "123 Main St"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).status).toBe("Pending");
       let publishedCommands = {
         contents: []
@@ -264,10 +265,10 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       await Callback.phase2(mockPublish);
       globalThis.expect(publishedCommands.contents.length).toBe(1);
       globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).status).toBe("Processing");
-      Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+      await Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
           TAG: "ShipmentCreated",
           orderId: "ord-1"
-        })], AutomationSliceFixtures$ReventlessLocal.testContext);
+        })], AutomationSliceFixtures$ReventlessLocal.testContext, Capabilities$Reventless.none);
       globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).status).toBe("Completed");
       let publishedCommands2 = {
         contents: []

package/tests/components/automationslice/AutomationSlicePiiTest.res

@@ -0,0 +1,178 @@
+// An automation's work item that carries personal data is stored as an event is:
+// its marked fields sealed, its row keyed by a fingerprint of the key the mapping
+// chose, that key sealed inside the item for `process` and `resolve`, and an item
+// whose subject was erased completed without processing.
+
+open JestGlobals
+
+module Source = {
+  module Id = Reventless.Id.String
+  let name = "GreetDcbEventLog"
+  @schema
+  type event =
+    | MemberJoined({memberId: @s.matches(Reventless.DcbTag.string) string, email: string})
+    | MemberGreeted({memberId: @s.matches(Reventless.DcbTag.string) string, email: string})
+}
+
+module Spec = {
+  let name = "GreetMember"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type todoItem = {
+    memberId: string,
+    email: @s.matches(Reventless.Pii.mark(~subject="memberId", S.string)) string,
+  }
+
+  @schema
+  type command = SendGreeting({memberId: @s.matches(Reventless.DcbTag.string) string, key: string})
+
+  let maxRetries = 3
+  let targetName = "SendGreeting"
+  let schedule = None
+}
+
+// Keyed by the address, as a translation keyed by contact would be.
+module Mapping = Reventless.AutomationSlice.Mapping.Make(
+  Source,
+  Spec,
+  {
+    let collect = (event: Source.event, ~sourceId as _, _ctx) =>
+      switch event {
+      | MemberJoined({memberId, email}) => [
+          (`${memberId}:${email}`, ({memberId, email}: Spec.todoItem)),
+        ]
+      | MemberGreeted(_) => []
+      }
+    let resolve = (event: Source.event) =>
+      switch event {
+      | MemberGreeted({memberId, email}) => Some(`${memberId}:${email}`)
+      | MemberJoined(_) => None
+      }
+    let reschedule = _ => []
+  },
+)
+
+let processed: ref<array<(string, string)>> = ref([])
+
+module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec = {
+  let process = (key, item: Spec.todoItem, ~now as _) => {
+    processed := processed.contents->Array.concat([(key, item.email)])
+    Some((item.memberId, Spec.SendGreeting({memberId: item.memberId, key})))
+  }
+  let onExhausted = (_id, _item: Spec.todoItem) => None
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = Reventless.AutomationSlice.Mappings.Make(Spec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(Mapping)]
+}
+
+module Callback = ReventlessCore.AutomationSlice_Callback.Make(Spec, Automation)
+
+let context: Reventless.AutomationSlice.context = {
+  environment: "test",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: "GreetMember",
+}
+
+let envelope = (event: Source.event) =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("id", JSON.Encode.string("m-1")),
+      (
+        "meta",
+        ReventlessCore.Message.generateMeta(~service=Source.name)->Reventless.Util_Sury.toJson(
+          Reventless.Message.metaSchema,
+        ),
+      ),
+      ("event", event->Reventless.Util_Sury.toJson(Source.eventSchema)),
+    ]),
+  )
+
+let toBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "utf8")->NodeCrypto.bufferToString("base64")
+let fromBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "base64")->NodeCrypto.bufferToString("utf8")
+
+let erased = ref(false)
+let provider: Reventless.Pii.provider = {
+  name: "fake",
+  encrypts: true,
+  seal: async (~subject, ~field as _, ~forgettable as _, json) => Ok(
+    Reventless.Pii.wrap(`enc:v1:${subject}:fake:${json->JSON.stringify->toBase64}`),
+  ),
+  prefetch: async _ => Ok(),
+  openNow: (~field, json) =>
+    switch json->Reventless.Pii.unwrap->Option.flatMap(Reventless.Pii.parseStored) {
+    | Some(Cipher(_)) if erased.contents => Ok(Reventless.Pii.wrap(Reventless.Pii.erasedMarker))
+    | Some(Cipher({bytes})) => Ok(bytes->fromBase64->JSON.parseOrThrow)
+    | _ => Error(Reventless.Pii.UnknownForm({field: field}))
+    },
+  release: async (~subject as _, ~ref as _) => Ok(),
+}
+
+let keyed: Reventless.Capabilities.t = {
+  ...Reventless.Capabilities.none,
+  secrets: Reventless.Secrets.fixed(
+    ~token="t",
+    ~hash=s => s,
+    ~fingerprint=(~purpose, input) =>
+      `fp(${purpose})#${input->toBase64->String.length->Int.toString}`,
+  ),
+}
+
+let joined = Source.MemberJoined({memberId: "m-1", email: "ada@example.org"})
+let greeted = Source.MemberGreeted({memberId: "m-1", email: "ada@example.org"})
+let rows = () => Callback.todoItems->Dict.toArray
+let published: ref<array<Reventless.Message.commandJson>> = ref([])
+let publish: ReventlessInfra.CommandTopic.publishJsons = async msgs => {
+  published := published.contents->Array.concat(msgs)
+}
+
+describe("an automation's work item with personal data", () => {
+  beforeEach(() => {
+    Callback.todoItems->Dict.keysToArray->Array.forEach(k => Callback.todoItems->Dict.delete(k))
+    processed := []
+    published := []
+    erased := false
+    Reventless.Pii.Provider.install(provider)
+  })
+  afterEach(() => Reventless.Pii.Provider.install(Reventless.Pii.plain))
+
+  testPromise("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    expect(rows()->JSON.stringifyAny->Option.getOr("")->String.includes("ada@example.org"))->toBe(
+      false,
+    )
+    expect(
+      rows()->Array.every(((id, _)) => id->String.startsWith("fp(automationWorkItem:GreetMember)")),
+    )->toBe(true)
+    expect(rows()->Array.length)->toBe(1)
+  })
+
+  testPromise("is processed with the key and the value it was collected with", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    await Callback.phase2(publish)
+    expect(processed.contents)->toEqual([("m-1:ada@example.org", "ada@example.org")])
+    expect(published.contents->Array.length)->toBe(1)
+  })
+
+  testPromise("is resolved by the key the mapping chose", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    await Callback.phase1([envelope(greeted)], context, ~capabilities=keyed)
+    expect(rows()->Array.map(((_, row)) => row.status))->toEqual([
+      ReventlessCore.AutomationSlice_Callback.Completed,
+    ])
+  })
+
+  testPromise("is completed without processing once its subject is erased", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    erased := true
+    await Callback.phase2(publish)
+    expect(processed.contents)->toEqual([])
+    expect(rows()->Array.map(((_, row)) => row.status))->toEqual([
+      ReventlessCore.AutomationSlice_Callback.Completed,
+    ])
+  })
+})

package/tests/components/automationslice/AutomationSlicePiiTest.res.mjs

@@ -0,0 +1,352 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Nodebuffer from "node:buffer";
+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";
+import * as Pii$Reventless from "@reventlessdev/reventless-spec/src/components/Pii.res.mjs";
+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 Secrets$Reventless from "@reventlessdev/reventless-spec/src/semantic/Secrets.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+
+let name = "GreetDcbEventLog";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "MemberJoined",
+    memberId: s.m(DcbTag$Reventless.string),
+    email: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "MemberGreeted",
+    memberId: s.m(DcbTag$Reventless.string),
+    email: s.m(Sury.string)
+  }))
+]);
+
+let Source = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  memberId: s.m(Sury.string),
+  email: s.m(Pii$Reventless.mark("memberId", undefined, Sury.string))
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "SendGreeting",
+  memberId: s.m(DcbTag$Reventless.string),
+  key: s.m(Sury.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let Spec = {
+  name: "GreetMember",
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  targetName: "SendGreeting",
+  schedule: undefined,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(event, param, _ctx) {
+  if (event.TAG !== "MemberJoined") {
+    return [];
+  }
+  let email = event.email;
+  let memberId = event.memberId;
+  return [[
+      memberId + `:` + email,
+      {
+        memberId: memberId,
+        email: email
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "MemberJoined") {
+    return;
+  } else {
+    return event.memberId + `:` + event.email;
+  }
+}
+
+function reschedule(param) {
+  return [];
+}
+
+let Mapping = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(Spec)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+let processed = {
+  contents: []
+};
+
+function process(key, item, param) {
+  processed.contents = processed.contents.concat([[
+      key,
+      item.email
+    ]]);
+  return [
+    item.memberId,
+    {
+      TAG: "SendGreeting",
+      memberId: item.memberId,
+      key: key
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(Spec);
+
+let mappings = [Mapping];
+
+let Automation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let Callback = AutomationSlice_Callback$ReventlessCore.Make(Spec)(Automation);
+
+let context = {
+  environment: "test",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: "GreetMember"
+};
+
+function envelope(event) {
+  return Object.fromEntries([
+    [
+      "id",
+      "m-1"
+    ],
+    [
+      "meta",
+      Util_Sury$Reventless.toJson(Message$ReventlessCore.generateMeta(name, undefined, undefined, undefined, undefined, undefined, undefined), Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      Util_Sury$Reventless.toJson(event, eventSchema)
+    ]
+  ]);
+}
+
+function toBase64(s) {
+  return Nodebuffer.Buffer.from(s, "utf8").toString("base64");
+}
+
+function fromBase64(s) {
+  return Nodebuffer.Buffer.from(s, "base64").toString("utf8");
+}
+
+let erased = {
+  contents: false
+};
+
+async function provider_seal(subject, param, param$1, json) {
+  return {
+    TAG: "Ok",
+    _0: Pii$Reventless.wrap(`enc:v1:` + subject + `:fake:` + toBase64(JSON.stringify(json)))
+  };
+}
+
+async function provider_prefetch(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+function provider_openNow(field, json) {
+  let match = Stdlib_Option.flatMap(Pii$Reventless.unwrap(json), Pii$Reventless.parseStored);
+  if (match === undefined) {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "UnknownForm",
+        field: field
+      }
+    };
+  }
+  switch (match.TAG) {
+    case "Cipher" :
+      if (erased.contents) {
+        return {
+          TAG: "Ok",
+          _0: Pii$Reventless.wrap(Pii$Reventless.erasedMarker)
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: JSON.parse(fromBase64(match.bytes))
+        };
+      }
+    case "ErasedForm" :
+    case "ForgottenForm" :
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownForm",
+          field: field
+        }
+      };
+  }
+}
+
+async function provider_release(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let provider = {
+  name: "fake",
+  encrypts: true,
+  seal: provider_seal,
+  prefetch: provider_prefetch,
+  openNow: provider_openNow,
+  release: provider_release
+};
+
+let keyed_geocode = Capabilities$Reventless.none.geocode;
+
+let keyed_messaging = Capabilities$Reventless.none.messaging;
+
+let keyed_identityProvider = Capabilities$Reventless.none.identityProvider;
+
+let keyed_secrets = Secrets$Reventless.fixed("t", s => s, (purpose, input) => `fp(` + purpose + `)#` + toBase64(input).length.toString());
+
+let keyed_stash = Capabilities$Reventless.none.stash;
+
+let keyed = {
+  geocode: keyed_geocode,
+  messaging: keyed_messaging,
+  identityProvider: keyed_identityProvider,
+  secrets: keyed_secrets,
+  stash: keyed_stash
+};
+
+let joined = {
+  TAG: "MemberJoined",
+  memberId: "m-1",
+  email: "ada@example.org"
+};
+
+let greeted = {
+  TAG: "MemberGreeted",
+  memberId: "m-1",
+  email: "ada@example.org"
+};
+
+function rows() {
+  return Object.entries(Callback.todoItems);
+}
+
+let published = {
+  contents: []
+};
+
+async function publish(msgs) {
+  published.contents = published.contents.concat(msgs);
+}
+
+globalThis.describe("an automation's work item with personal data", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(Callback.todoItems).forEach(k => Stdlib_Dict.$$delete(Callback.todoItems, k));
+    processed.contents = [];
+    published.contents = [];
+    erased.contents = false;
+    Pii$Reventless.Provider.install(provider);
+  });
+  globalThis.afterEach(() => Pii$Reventless.Provider.install(Pii$Reventless.plain));
+  globalThis.test("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    globalThis.expect(Stdlib_Option.getOr(JSON.stringify(Object.entries(Callback.todoItems)), "").includes("ada@example.org")).toBe(false);
+    globalThis.expect(Object.entries(Callback.todoItems).every(param => param[0].startsWith("fp(automationWorkItem:GreetMember)"))).toBe(true);
+    globalThis.expect(Object.entries(Callback.todoItems).length).toBe(1);
+  });
+  globalThis.test("is processed with the key and the value it was collected with", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    await Callback.phase2(publish);
+    globalThis.expect(processed.contents).toEqual([[
+        "m-1:ada@example.org",
+        "ada@example.org"
+      ]]);
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+  globalThis.test("is resolved by the key the mapping chose", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    await Callback.phase1([envelope(greeted)], context, keyed);
+    globalThis.expect(Object.entries(Callback.todoItems).map(param => param[1].status)).toEqual(["Completed"]);
+  });
+  globalThis.test("is completed without processing once its subject is erased", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    erased.contents = true;
+    await Callback.phase2(publish);
+    globalThis.expect(processed.contents).toEqual([]);
+    globalThis.expect(Object.entries(Callback.todoItems).map(param => param[1].status)).toEqual(["Completed"]);
+  });
+});
+
+export {
+  Source,
+  Spec,
+  Mapping,
+  processed,
+  Automation,
+  Callback,
+  context,
+  envelope,
+  toBase64,
+  fromBase64,
+  erased,
+  provider,
+  keyed,
+  joined,
+  greeted,
+  rows,
+  published,
+  publish,
+}
+/* eventSchema Not a pure module */