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

package/CHANGELOG.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.311",
+  "version": "3.0.0-alpha.312",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,19 +34,19 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.24",
     "@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/reventless-core": "3.0.0-alpha.320",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.24",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.321",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.268",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.184",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.217",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.168",
+    "@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-seed": "1.0.0-alpha.39",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.188"
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.269",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.189"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res

@@ -45,9 +45,10 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "OrderShipped event creates a pending outbound item",
       async () => {
-        FireForgetCallback.phase1([
-          ("evt", OrderShipped({orderId: "ord-1", email: "test@example.com"})),
-        ])
+        await FireForgetCallback.phase1(
+          [("evt", OrderShipped({orderId: "ord-1", email: "test@example.com"}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let items = FireForgetCallback.todoItems
         expect(items->Dict.toArray->Array.length)->toBe(1)
         let row = items->Dict.get("ord-1")
@@ -61,12 +62,14 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "duplicate event does not create a second item (idempotent)",
       async () => {
-        FireForgetCallback.phase1([
-          ("evt", OrderShipped({orderId: "ord-1", email: "test@example.com"})),
-        ])
-        FireForgetCallback.phase1([
-          ("evt", OrderShipped({orderId: "ord-1", email: "other@example.com"})),
-        ])
+        await FireForgetCallback.phase1(
+          [("evt", OrderShipped({orderId: "ord-1", email: "test@example.com"}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
+        await FireForgetCallback.phase1(
+          [("evt", OrderShipped({orderId: "ord-1", email: "other@example.com"}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let items = FireForgetCallback.todoItems
         expect(items->Dict.toArray->Array.length)->toBe(1)
       },
@@ -75,10 +78,13 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "multiple different events create multiple items",
       async () => {
-        FireForgetCallback.phase1([
-          ("evt", OrderShipped({orderId: "ord-1", email: "a@example.com"})),
-          ("evt", OrderShipped({orderId: "ord-2", email: "b@example.com"})),
-        ])
+        await FireForgetCallback.phase1(
+          [
+            ("evt", OrderShipped({orderId: "ord-1", email: "a@example.com"})),
+            ("evt", OrderShipped({orderId: "ord-2", email: "b@example.com"})),
+          ],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let items = FireForgetCallback.todoItems
         expect(items->Dict.toArray->Array.length)->toBe(2)
       },
@@ -89,9 +95,10 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "Ok(None) marks item as Completed, no command published",
       async () => {
-        FireForgetCallback.phase1([
-          ("evt", OrderShipped({orderId: "ord-1", email: "test@example.com"})),
-        ])
+        await FireForgetCallback.phase1(
+          [("evt", OrderShipped({orderId: "ord-1", email: "test@example.com"}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
           publishedCommands := cmds
@@ -120,7 +127,10 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "Ok(Some(...)) marks item as Completed and publishes command",
       async () => {
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
           publishedCommands := Array.concat(publishedCommands.contents, cmds)
@@ -142,7 +152,10 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "published command is tagged with the target's name",
       async () => {
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
           publishedCommands := Array.concat(publishedCommands.contents, cmds)
@@ -158,7 +171,10 @@ describe("OutboundTranslationSlice Callback", () => {
       async () => {
         ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway timeout"))
 
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
         await CommandBackCallback.phase2(mockPublish, ~capabilities=Reventless.Capabilities.none)
 
@@ -173,7 +189,10 @@ describe("OutboundTranslationSlice Callback", () => {
       async () => {
         // First attempt fails
         ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
         await CommandBackCallback.phase2(mockPublish, ~capabilities=Reventless.Capabilities.none)
         let row1 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
@@ -198,7 +217,10 @@ describe("OutboundTranslationSlice Callback", () => {
       async () => {
         // ProcessPaymentSpec.maxRetries = 2, so after 2 failures it should stop
         ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
 
         // Fail once — still retriable, and the status says so.
@@ -234,7 +256,10 @@ describe("OutboundTranslationSlice Callback", () => {
       "a row left stranded at the ceiling is normalised on the next pass",
       async () => {
         ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
         CommandBackCallback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 2})
 
@@ -252,7 +277,10 @@ describe("OutboundTranslationSlice Callback", () => {
       "the last error survives the transition to Abandoned",
       async () => {
         ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let publish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
         await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
         await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
@@ -265,7 +293,10 @@ describe("OutboundTranslationSlice Callback", () => {
     testPromise(
       "the row carries the ceiling its count is racing",
       async () => {
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         expect(
           (CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries,
         )->toEqual(Some(ProcessPaymentSpec.maxRetries))
@@ -281,7 +312,10 @@ describe("OutboundTranslationSlice Callback", () => {
         ProcessPaymentSpec.onExhaustedFn :=
           ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
 
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let published = ref([])
         let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
           published := Array.concat(published.contents, cmds)
@@ -313,7 +347,10 @@ describe("OutboundTranslationSlice Callback", () => {
             }
           )
 
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let publish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
         await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
         await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
@@ -326,7 +363,10 @@ describe("OutboundTranslationSlice Callback", () => {
       async () => {
         ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
         // onExhaustedFn stays at its default None (reset in beforeEach).
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let published = ref([])
         let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
           published := Array.concat(published.contents, cmds)
@@ -348,7 +388,10 @@ describe("OutboundTranslationSlice Callback", () => {
         ProcessPaymentSpec.onExhaustedFn :=
           ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
 
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let failOnAbandonment: ReventlessInfra.CommandTopic.publishJsons = async _cmds =>
           JsError.throwWithMessage("topic unavailable")
         await CommandBackCallback.phase2(
@@ -372,7 +415,10 @@ describe("OutboundTranslationSlice Callback", () => {
       async () => {
         ProcessPaymentSpec.onExhaustedFn :=
           ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
-        CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+        await CommandBackCallback.phase1(
+          [("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
         CommandBackCallback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 2})
 
@@ -404,10 +450,13 @@ describe("OutboundTranslationSlice Callback", () => {
             }
           )
 
-        CommandBackCallback.phase1([
-          ("evt", PaymentReceived({orderId: "ord-1", amount: 50.0})),
-          ("evt", PaymentReceived({orderId: "ord-2", amount: 75.0})),
-        ])
+        await CommandBackCallback.phase1(
+          [
+            ("evt", PaymentReceived({orderId: "ord-1", amount: 50.0})),
+            ("evt", PaymentReceived({orderId: "ord-2", amount: 75.0})),
+          ],
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let publishedCommands = ref([])
         let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
           publishedCommands := Array.concat(publishedCommands.contents, cmds)

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res.mjs

@@ -83,14 +83,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
   });
   globalThis.describe("Phase 1 — collect", () => {
     globalThis.test("OrderShipped event creates a pending outbound item", async () => {
-      FireForgetCallback.phase1([[
+      await FireForgetCallback.phase1([[
           "evt",
           {
             TAG: "OrderShipped",
             orderId: "ord-1",
             email: "test@example.com"
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let items = FireForgetCallback.todoItems;
       globalThis.expect(Object.entries(items).length).toBe(1);
       let row = items["ord-1"];
@@ -100,26 +100,26 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       globalThis.expect(r.retryCount).toBe(0);
     });
     globalThis.test("duplicate event does not create a second item (idempotent)", async () => {
-      FireForgetCallback.phase1([[
+      await FireForgetCallback.phase1([[
           "evt",
           {
             TAG: "OrderShipped",
             orderId: "ord-1",
             email: "test@example.com"
           }
-        ]]);
-      FireForgetCallback.phase1([[
+        ]], Capabilities$Reventless.none);
+      await FireForgetCallback.phase1([[
           "evt",
           {
             TAG: "OrderShipped",
             orderId: "ord-1",
             email: "other@example.com"
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       globalThis.expect(Object.entries(FireForgetCallback.todoItems).length).toBe(1);
     });
     globalThis.test("multiple different events create multiple items", async () => {
-      FireForgetCallback.phase1([
+      await FireForgetCallback.phase1([
         [
           "evt",
           {
@@ -136,20 +136,20 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             email: "b@example.com"
           }
         ]
-      ]);
+      ], Capabilities$Reventless.none);
       globalThis.expect(Object.entries(FireForgetCallback.todoItems).length).toBe(2);
     });
   });
   globalThis.describe("Phase 2 — translate (fire-and-forget)", () => {
     globalThis.test("Ok(None) marks item as Completed, no command published", async () => {
-      FireForgetCallback.phase1([[
+      await FireForgetCallback.phase1([[
           "evt",
           {
             TAG: "OrderShipped",
             orderId: "ord-1",
             email: "test@example.com"
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -174,14 +174,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
   });
   globalThis.describe("Phase 2 — translate (command-back)", () => {
     globalThis.test("Ok(Some(...)) marks item as Completed and publishes command", async () => {
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -196,14 +196,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       globalThis.expect(row.status).toBe("Completed");
     });
     globalThis.test("published command is tagged with the target's name", async () => {
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };
@@ -219,14 +219,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         TAG: "Error",
         _0: "gateway timeout"
       });
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
@@ -238,14 +238,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         TAG: "Error",
         _0: "timeout"
       });
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       let row1 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
@@ -276,14 +276,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         TAG: "Error",
         _0: "timeout"
       });
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Failed");
@@ -308,14 +308,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         TAG: "Error",
         _0: "timeout"
       });
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       let newrecord = {...row};
       newrecord.retryCount = 2;
@@ -329,14 +329,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         TAG: "Error",
         _0: "gateway down"
       });
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let publish = async _cmds => {};
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
@@ -345,14 +345,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       globalThis.expect(row.lastError).toEqual("gateway down");
     });
     globalThis.test("the row carries the ceiling its count is racing", async () => {
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).maxRetries).toEqual(OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.maxRetries);
     });
     globalThis.test("a slice that answers onExhausted has its command published", async () => {
@@ -367,14 +367,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
           orderId: id
         }
       ];
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let published = {
         contents: []
       };
@@ -400,14 +400,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (_id, _item, lastError) => {
         seen.contents = lastError;
       };
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let publish = async _cmds => {};
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
       await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
@@ -418,14 +418,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         TAG: "Error",
         _0: "gateway down"
       });
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let published = {
         contents: []
       };
@@ -449,14 +449,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
           orderId: id
         }
       ];
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let failOnAbandonment = async _cmds => Stdlib_JsError.throwWithMessage("topic unavailable");
       await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
       await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
@@ -472,14 +472,14 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
           orderId: id
         }
       ];
-      CommandBackCallback.phase1([[
+      await CommandBackCallback.phase1([[
           "evt",
           {
             TAG: "PaymentReceived",
             orderId: "ord-1",
             amount: 50.0
           }
-        ]]);
+        ]], Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       let newrecord = {...row};
       newrecord.retryCount = 2;
@@ -518,7 +518,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
           };
         }
       };
-      CommandBackCallback.phase1([
+      await CommandBackCallback.phase1([
         [
           "evt",
           {
@@ -535,7 +535,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
             amount: 75.0
           }
         ]
-      ]);
+      ], Capabilities$Reventless.none);
       let publishedCommands = {
         contents: []
       };

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePiiTest.res

@@ -0,0 +1,160 @@
+// An outbound 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 `collect`
+// chose, opened before it is translated, and completed without a call once its
+// subject is erased.
+
+open JestGlobals
+
+let sent: ref<array<string>> = ref([])
+
+module VerifySpec = {
+  let name = "VerifyAddress"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type consumedEvent = AddressGiven({customerId: string, email: string})
+
+  @schema
+  type outboundItem = {
+    customerId: string,
+    email: @s.matches(Reventless.Pii.mark(~subject="customerId", S.string)) string,
+  }
+
+  @schema
+  type inboundCommand = unit
+
+  // Keyed by the address, as the shop's translations are: a change is new work.
+  let collect = (event, ~sourceId as _) =>
+    switch event {
+    | AddressGiven({customerId, email}) => [(`${customerId}:${email}`, {customerId, email})]
+    }
+
+  let translate = async (_id, item: outboundItem, ~capabilities as _) => {
+    sent := sent.contents->Array.concat([item.email])
+    Ok(None)
+  }
+  let onExhausted = (_id, _item, ~lastError as _) => None
+
+  let maxRetries = 3
+  let targetName = None
+  let sourceNames: array<string> = []
+  let externalSystem = None
+  let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
+  let traits: array<Reventless.Trait.t> = []
+}
+module VerifyTranslation = {
+  let collect = VerifySpec.collect
+  let translate = VerifySpec.translate
+  let onExhausted = VerifySpec.onExhausted
+  let moduleUrl = VerifySpec.moduleUrl
+}
+module Callback = ReventlessCore.OutboundTranslationSlice_Callback.Make(
+  VerifySpec,
+  VerifyTranslation,
+)
+
+let toBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "utf8")->NodeCrypto.bufferToString("base64")
+let fromBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "base64")->NodeCrypto.bufferToString("utf8")
+
+/** "Encrypts" by base64; `erased` makes every key gone, as an erasure does. */
+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 given = VerifySpec.AddressGiven({customerId: "c-1", email: "ada@example.org"})
+let rows = () => Callback.todoItems->Dict.toArray
+let publish: ReventlessInfra.CommandTopic.publishJsons = async _ => ()
+
+@val external env: dict<string> = "process.env"
+
+describe("an outbound work item with personal data", () => {
+  beforeEach(() => {
+    Callback.todoItems->Dict.keysToArray->Array.forEach(k => Callback.todoItems->Dict.delete(k))
+    sent := []
+    erased := false
+    Reventless.Pii.Provider.install(provider)
+  })
+  afterEach(() => {
+    Reventless.Pii.Provider.install(Reventless.Pii.plain)
+    env->Dict.delete("REVENTLESS_PII_REQUIRE_ENCRYPTION")
+  })
+
+  testPromise("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    let stored = rows()->JSON.stringifyAny->Option.getOr("")
+    expect(stored->String.includes("ada@example.org"))->toBe(false)
+    switch rows() {
+    | [(id, row)] =>
+      expect(id->String.startsWith("fp(outboundWorkItem:VerifyAddress)"))->toBe(true)
+      // A sealed string stays a string, so the work list still serves it as one.
+      let email = row.item->JSON.Decode.object->Option.flatMap(d => d->Dict.get("email"))
+      expect(
+        email
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.mapOr(false, s => s->String.startsWith("enc:v1:c-1:")),
+      )->toBe(true)
+    | _ => fail("expected one row")
+    }
+  })
+
+  testPromise("is collected once, however often its event arrives", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    expect(rows()->Array.length)->toBe(1)
+  })
+
+  testPromise("is opened before it is translated", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    await Callback.phase2(publish, ~capabilities=keyed)
+    expect(sent.contents)->toEqual(["ada@example.org"])
+  })
+
+  testPromise("is completed without a call once its subject is erased", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    erased := true
+    await Callback.phase2(publish, ~capabilities=keyed)
+    expect(sent.contents)->toEqual([])
+    expect(rows()->Array.map(((_, row)) => row.status))->toEqual([
+      ReventlessCore.OutboundTranslationSlice_Callback.Completed,
+    ])
+  })
+
+  testPromise("keeps the key it was given where nothing can fingerprint it", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=Reventless.Capabilities.none)
+    expect(rows()->Array.map(Pair.first))->toEqual(["c-1:ada@example.org"])
+  })
+
+  testPromise(
+    "is not stored at all where encryption is required and nothing can fingerprint it",
+    async () => {
+      env->Dict.set("REVENTLESS_PII_REQUIRE_ENCRYPTION", "true")
+      await Callback.phase1([("c-1", given)], ~capabilities=Reventless.Capabilities.none)
+      expect(rows())->toEqual([])
+    },
+  )
+})

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePiiTest.res.mjs

@@ -0,0 +1,300 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Nodebuffer from "node:buffer";
+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 Secrets$Reventless from "@reventlessdev/reventless-spec/src/semantic/Secrets.res.mjs";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+
+let sent = {
+  contents: []
+};
+
+let name = "VerifyAddress";
+
+let moduleUrl = import.meta.url;
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "AddressGiven",
+  customerId: s.m(Sury.string),
+  email: s.m(Sury.string)
+}));
+
+let outboundItemSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  email: s.m(Pii$Reventless.mark("customerId", undefined, Sury.string))
+}));
+
+let inboundCommandSchema = Sury.$unit;
+
+function collect(event, param) {
+  let email = event.email;
+  let customerId = event.customerId;
+  return [[
+      customerId + `:` + email,
+      {
+        customerId: customerId,
+        email: email
+      }
+    ]];
+}
+
+async function translate(_id, item, param) {
+  sent.contents = sent.contents.concat([item.email]);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+function onExhausted(_id, _item, param) {
+  
+}
+
+let sourceNames = [];
+
+let capabilityNeeds = [];
+
+let traits = [];
+
+let VerifySpec = {
+  name: name,
+  moduleUrl: moduleUrl,
+  consumedEventSchema: consumedEventSchema,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: inboundCommandSchema,
+  collect: collect,
+  translate: translate,
+  onExhausted: onExhausted,
+  maxRetries: 3,
+  targetName: undefined,
+  sourceNames: sourceNames,
+  externalSystem: undefined,
+  capabilityNeeds: capabilityNeeds,
+  traits: traits
+};
+
+let VerifyTranslation = {
+  collect: collect,
+  translate: translate,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl
+};
+
+let Callback = OutboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  consumedEventSchema: consumedEventSchema,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: inboundCommandSchema,
+  maxRetries: 3,
+  targetName: undefined,
+  sourceNames: sourceNames,
+  externalSystem: undefined,
+  capabilityNeeds: capabilityNeeds,
+  traits: traits
+})(VerifyTranslation);
+
+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 given = {
+  TAG: "AddressGiven",
+  customerId: "c-1",
+  email: "ada@example.org"
+};
+
+function rows() {
+  return Object.entries(Callback.todoItems);
+}
+
+async function publish(param) {
+  
+}
+
+globalThis.describe("an outbound work item with personal data", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(Callback.todoItems).forEach(k => Stdlib_Dict.$$delete(Callback.todoItems, k));
+    sent.contents = [];
+    erased.contents = false;
+    Pii$Reventless.Provider.install(provider);
+  });
+  globalThis.afterEach(() => {
+    Pii$Reventless.Provider.install(Pii$Reventless.plain);
+    Stdlib_Dict.$$delete(process.env, "REVENTLESS_PII_REQUIRE_ENCRYPTION");
+  });
+  globalThis.test("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    let stored = Stdlib_Option.getOr(JSON.stringify(Object.entries(Callback.todoItems)), "");
+    globalThis.expect(stored.includes("ada@example.org")).toBe(false);
+    let match = Object.entries(Callback.todoItems);
+    if (match.length !== 1) {
+      return JestGlobals.fail("expected one row");
+    }
+    let match$1 = match[0];
+    globalThis.expect(match$1[0].startsWith("fp(outboundWorkItem:VerifyAddress)")).toBe(true);
+    let email = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(match$1[1].item), d => d["email"]);
+    globalThis.expect(Stdlib_Option.mapOr(Stdlib_Option.flatMap(email, Stdlib_JSON.Decode.string), false, s => s.startsWith("enc:v1:c-1:"))).toBe(true);
+  });
+  globalThis.test("is collected once, however often its event arrives", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    globalThis.expect(Object.entries(Callback.todoItems).length).toBe(1);
+  });
+  globalThis.test("is opened before it is translated", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    await Callback.phase2(publish, keyed);
+    globalThis.expect(sent.contents).toEqual(["ada@example.org"]);
+  });
+  globalThis.test("is completed without a call once its subject is erased", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    erased.contents = true;
+    await Callback.phase2(publish, keyed);
+    globalThis.expect(sent.contents).toEqual([]);
+    globalThis.expect(Object.entries(Callback.todoItems).map(param => param[1].status)).toEqual(["Completed"]);
+  });
+  globalThis.test("keeps the key it was given where nothing can fingerprint it", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], Capabilities$Reventless.none);
+    globalThis.expect(Object.entries(Callback.todoItems).map(prim => prim[0])).toEqual(["c-1:ada@example.org"]);
+  });
+  globalThis.test("is not stored at all where encryption is required and nothing can fingerprint it", async () => {
+    process.env["REVENTLESS_PII_REQUIRE_ENCRYPTION"] = "true";
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], Capabilities$Reventless.none);
+    globalThis.expect(Object.entries(Callback.todoItems)).toEqual([]);
+  });
+});
+
+export {
+  sent,
+  VerifySpec,
+  VerifyTranslation,
+  Callback,
+  toBase64,
+  fromBase64,
+  erased,
+  provider,
+  keyed,
+  given,
+  rows,
+  publish,
+}
+/* moduleUrl Not a pure module */