@reventlessdev/reventless-gwt 1.0.0-alpha.254 → 1.0.0-alpha.256

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.256 (2026-10-25)
+
+* refactor(spec)!: the plugin structure's optional parts are optional fields ([130bad5](https://github.com/ReventlessDev/reventless-core/commit/130bad581caf725a9d61b5a3df3d012e4f8ba402))
+* feat!: an inbound translation is async and handed the platform's capabilities, and its audit row withholds sensitive fields ([dae6049](https://github.com/ReventlessDev/reventless-core/commit/dae6049e084f81408a494a2cd2011ec564dda65c))
+### Features
+
+* a stash capability holds a value for minutes outside the log and hands it over once ([627f285](https://github.com/ReventlessDev/reventless-core/commit/627f28529ead2d2d31bdd091c9f42e7faca40f6f))
+
+### BREAKING CHANGES
+
+* code that builds these records drops `name: None`, writes
+`name: x` for `name: Some(x)`, and `name: ?x` for a value already of type
+option.
+* an inbound translation's translate takes ~capabilities and
+returns a promise, and its spec must declare capabilityNeeds ([] for one that
+only maps input). FromSlice steps return promises.
+
+
+
+# 1.0.0-alpha.255 (2026-10-23)
+
+### Bug Fixes
+
+* **gwt:** a recorded sidecar is written only when it says something new ([a8f3cb9](https://github.com/ReventlessDev/reventless-core/commit/a8f3cb926d779f6a0c763196f73da5df102ca31e))
+
+
 # 1.0.0-alpha.254 (2026-10-22)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.254",
+  "version": "1.0.0-alpha.256",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "sury": "11.0.0",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
     "@reventlessdev/rescript-node": "2.0.0-alpha.23",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.306",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.203",
-    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.175"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.308",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.205",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.176"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/Capabilities_Fake.res

@@ -7,6 +7,7 @@ module Geocoding = Reventless.Geocoding
 module Messaging = Reventless.Messaging
 module IdentityProvider = Reventless.IdentityProvider
 module Secrets = Reventless.Secrets
+module Stash = Reventless.Stash
 
 /** One call a slice made through its capabilities. */
 type call =
@@ -22,6 +23,10 @@ type call =
   | PrincipalDeleted({principal: IdentityProvider.principal})
   | TokenDrawn({length: int, alphabet: Secrets.alphabet})
   | Hashed({input: string})
+  /** A value put in the stash. The value itself is recorded, so a test can
+      assert which secret was handed over — a fake has no log to keep it out of. */
+  | Stashed({key: string, value: string, ttl: Reventless.Duration.t})
+  | Taken({key: string})
 
 type t = {
   capabilities: Capabilities.t,
@@ -34,7 +39,9 @@ Fakes whose answers are given per capability. An answer left out is a plain
 success: a geocoder with no candidates, a send with a numbered receipt, a
 principal with a numbered id, `token` (or `t` repeated to length), and a hash
 that prefixes `"hash:"`. `~secrets` replaces the secret source whole, e.g. with
-`Secrets.unavailable`; its calls are still recorded.
+`Secrets.unavailable`; its calls are still recorded. The stash holds what is put
+in it and hands each value over once, starting from `~stashed`; `~stash`
+replaces it whole, e.g. with `Stash.unavailable`.
 */
 let make = (
   ~geocode: option<Geocoding.search>=?,
@@ -51,6 +58,8 @@ let make = (
   ~token: option<string>=?,
   ~hash: option<string => string>=?,
   ~secrets: option<Secrets.t>=?,
+  ~stashed: array<(string, string)>=[],
+  ~stash: option<Stash.t>=?,
   (),
 ): t => {
   let log: array<call> = []
@@ -76,6 +85,7 @@ let make = (
     | None => Ok({IdentityProvider.providerId: `principal-${Int.toString(log->Array.length)}`})
     }
   }
+  let held = Dict.fromArray(stashed)
   let capabilities: Capabilities.t = {
     geocode,
     messaging: Messaging.makeProvider(~emailAndSms=channels, ~pushServices, ~send),
@@ -111,6 +121,27 @@ let make = (
         }
       },
     },
+    stash: {
+      put: async (~key, ~value, ~ttl) => {
+        record(Stashed({key, value, ttl}))
+        switch stash {
+        | Some(s) => await s.put(~key, ~value, ~ttl)
+        | None =>
+          held->Dict.set(key, value)
+          Ok()
+        }
+      },
+      take: async (~key) => {
+        record(Taken({key: key}))
+        switch stash {
+        | Some(s) => await s.take(~key)
+        | None =>
+          let found = held->Dict.get(key)
+          held->Dict.delete(key)
+          Ok(found)
+        }
+      },
+    },
   }
   {capabilities, calls: () => log->Array.copy}
 }
@@ -153,5 +184,7 @@ let toJson = (c: call): JSON.t => {
     obj("PrincipalDeleted", [("principal", str(principal.providerId))])
   | TokenDrawn({length, _}) => obj("TokenDrawn", [("length", JSON.Encode.int(length))])
   | Hashed({input}) => obj("Hashed", [("input", str(input))])
+  | Stashed({key, ttl, _}) => obj("Stashed", [("key", str(key)), ("ttl", JSON.Encode.int(ttl))])
+  | Taken({key}) => obj("Taken", [("key", str(key))])
   }
 }

package/src/Capabilities_Fake.res.mjs

@@ -1,16 +1,18 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+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 Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
 import * as IdentityProvider$Reventless from "@reventlessdev/reventless-spec/src/semantic/IdentityProvider.res.mjs";
 
-function make(geocode, send, channelsOpt, pushServicesOpt, createPrincipal, token, hash, secrets, param) {
+function make(geocode, send, channelsOpt, pushServicesOpt, createPrincipal, token, hash, secrets, stashedOpt, stash, param) {
   let channels = channelsOpt !== undefined ? channelsOpt : [
       "Email",
       "Sms"
     ];
   let pushServices = pushServicesOpt !== undefined ? pushServicesOpt : [];
+  let stashed = stashedOpt !== undefined ? stashedOpt : [];
   let log = [];
   let geocode$1 = async text => {
     log.push({
@@ -61,6 +63,7 @@ function make(geocode, send, channelsOpt, pushServicesOpt, createPrincipal, toke
       };
     }
   };
+  let held = Object.fromEntries(stashed);
   let capabilities_messaging = Messaging$Reventless.makeProvider(channels, pushServices, send$1);
   let capabilities_identityProvider = IdentityProvider$Reventless.make(createPrincipal$1, async (principal, group) => {
     log.push({
@@ -128,11 +131,46 @@ function make(geocode, send, channelsOpt, pushServicesOpt, createPrincipal, toke
       }
     }
   };
+  let capabilities_stash = {
+    put: async (key, value, ttl) => {
+      log.push({
+        TAG: "Stashed",
+        key: key,
+        value: value,
+        ttl: ttl
+      });
+      if (stash !== undefined) {
+        return await stash.put(key, value, ttl);
+      } else {
+        held[key] = value;
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+    },
+    take: async key => {
+      log.push({
+        TAG: "Taken",
+        key: key
+      });
+      if (stash !== undefined) {
+        return await stash.take(key);
+      }
+      let found = held[key];
+      Stdlib_Dict.$$delete(held, key);
+      return {
+        TAG: "Ok",
+        _0: found
+      };
+    }
+  };
   let capabilities = {
     geocode: geocode$1,
     messaging: capabilities_messaging,
     identityProvider: capabilities_identityProvider,
-    secrets: capabilities_secrets
+    secrets: capabilities_secrets,
+    stash: capabilities_stash
   };
   return {
     capabilities: capabilities,
@@ -229,6 +267,22 @@ function toJson(c) {
           "input",
           c.input
         ]]);
+    case "Stashed" :
+      return obj("Stashed", [
+        [
+          "key",
+          c.key
+        ],
+        [
+          "ttl",
+          c.ttl
+        ]
+      ]);
+    case "Taken" :
+      return obj("Taken", [[
+          "key",
+          c.key
+        ]]);
   }
 }
 
@@ -242,12 +296,15 @@ let IdentityProvider;
 
 let Secrets;
 
+let Stash;
+
 export {
   Capabilities,
   Geocoding,
   Messaging,
   IdentityProvider,
   Secrets,
+  Stash,
   make,
   toJson,
 }

package/src/Flow_GWT.res

@@ -680,9 +680,9 @@ module InboundSlice = (
   module I = InboundTranslation_GWT.FromSlice(Spec, Translation)
 
   // Received input becomes the flow's next commands, as an automation's do.
-  let whenReceived = async (flowP: flow, json: JSON.t) => {
+  let whenReceived = async (flowP: flow, json: JSON.t, ~fakes=?) => {
     let s = await flowP
-    switch I.whenReceived(json) {
+    switch (await I.whenReceived(json, ~fakes?)).outcome {
     | Translated(pairs) => {
         ...s,
         lastCommands: pairs->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema)),

package/src/Flow_GWT.res.mjs

@@ -582,9 +582,9 @@ function OutboundSlice(Spec) {
 function InboundSlice(Spec) {
   return Translation => {
     let I = InboundTranslation_GWT$ReventlessGwt.FromSlice(Spec)(Translation);
-    let whenReceived = async (flowP, json) => {
+    let whenReceived = async (flowP, json, fakes) => {
       let s = await flowP;
-      let pairs = I.whenReceived(json);
+      let pairs = (await I.whenReceived(json, fakes, undefined)).outcome;
       switch (pairs.TAG) {
         case "Translated" :
           return {

package/src/InboundTranslation_GWT.res

@@ -77,21 +77,29 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     }
 }
 
-// The slice as written: its `Spec` and its `_Translation` body.
+// The slice as written: its `Spec` and its `_Translation` body, run against
+// recording capability fakes as the outbound DSL's `FromSlice` is.
 module FromSlice = (
   Spec: Reventless.InboundTranslationSlice.Spec,
   Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
 ) => {
   let describe = JestBind.describe
-  let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=Spec.name, name, ~timeout?, body)
 
   /** What became of one input. `InputRefused` is input that did not decode, so
       `translate` never saw it; `NotUnderstood` is input it declined. */
-  type received =
+  type outcome =
     | Translated(array<(string, Spec.command)>)
     | NotUnderstood(string)
     | InputRefused(string)
 
+  /** An outcome, and the capability calls `translate` made reaching it. */
+  type received = {outcome: outcome, sent: array<Capabilities_Fake.call>}
+
+  /** Scripted capabilities for `whenInput(~fakes)`; see `Capabilities_Fake.make`. */
+  let fakes = Capabilities_Fake.make
+
   let encPairs = (pairs: array<(string, Spec.command)>) =>
     pairs->Array.map(((id, cmd)) => {
       let d = Dict.make()
@@ -100,23 +108,49 @@ module FromSlice = (
       JSON.Encode.object(d)
     })
 
-  let whenInput = (input: Spec.externalInput) =>
-    switch Translation.translate(input) {
+  let errorOf = exn =>
+    switch exn {
+    | S.Exn(e) => e.message
+    | JsExn(e) => JsExn.message(e)->Option.getOr("unknown error")
+    | _ => "unknown error"
+    }
+
+  /** One input through the slice's own `translate`. A throw is input the slice
+      declined, as the runtime records it. `~caller` is who called the door, as
+      the transport would hand it on; left out, the platform is acting for
+      itself. */
+  let whenInput = async (
+    input: Spec.externalInput,
+    ~fakes=Capabilities_Fake.make(),
+    ~caller: option<Reventless.Identity.t>=?,
+  ) => {
+    let outcome = switch await Translation.translate(
+      input,
+      ~capabilities=fakes.capabilities,
+      ~caller,
+    ) {
     | Ok(pairs) => Translated(pairs)
     | Error(msg) => NotUnderstood(msg)
+    | exception exn => NotUnderstood(errorOf(exn))
     }
+    {outcome, sent: fakes.calls()}
+  }
 
   /** Input as it arrives: decoded through `externalInputSchema` first. */
-  let whenReceived = (json: JSON.t) =>
+  let whenReceived = async (
+    json: JSON.t,
+    ~fakes=Capabilities_Fake.make(),
+    ~caller: option<Reventless.Identity.t>=?,
+  ) =>
     switch json->Reventless.Util_Sury.fromJson(Spec.externalInputSchema) {
-    | input => whenInput(input)
+    | input => await whenInput(input, ~fakes, ~caller?)
     // Sury's message names the field that failed.
-    | exception S.Exn(e) => InputRefused(e.message)
-    | exception _ => InputRefused("invalid input")
+    | exception S.Exn(e) => {outcome: InputRefused(e.message), sent: fakes.calls()}
+    | exception _ => {outcome: InputRefused("invalid input"), sent: fakes.calls()}
     }
 
-  let describeOther = received =>
-    switch received {
+  let describeOther = outcome =>
+    switch outcome {
     | Translated(_) => None
     | NotUnderstood(msg) => Some(`not understood: ${msg}`)
     | InputRefused(msg) => Some(`input refused: ${msg}`)
@@ -131,8 +165,8 @@ module FromSlice = (
     | exception _ => false
     }
 
-  let thenCommands = (received, expected) =>
-    switch received {
+  let thenCommands = async (pending: promise<received>, expected) =>
+    switch (await pending).outcome {
     | Translated(actual) if actual == expected =>
       switch actual->Array.find(((_, cmd)) => !roundTrips(cmd)) {
       | None => Outcome.pass
@@ -149,19 +183,19 @@ module FromSlice = (
     | other => Outcome.fail(TranslateError({expected: "(commands)", actual: describeOther(other)}))
     }
 
-  let thenCommand = (received, expectedId, expectedCmd) =>
-    thenCommands(received, [(expectedId, expectedCmd)])
+  let thenCommand = (pending, expectedId, expectedCmd) =>
+    thenCommands(pending, [(expectedId, expectedCmd)])
 
-  let thenNoCommand = received =>
-    switch received {
+  let thenNoCommand = async (pending: promise<received>) =>
+    switch (await pending).outcome {
     | Translated([]) => Outcome.pass
     | Translated(actual) => Outcome.fail(NoEventExpected({actual: encPairs(actual)}))
     | other =>
       Outcome.fail(TranslateError({expected: "(no commands)", actual: describeOther(other)}))
     }
 
-  let thenNotUnderstood = (received, expectedMsg) =>
-    switch received {
+  let thenNotUnderstood = async (pending: promise<received>, expectedMsg) =>
+    switch (await pending).outcome {
     | NotUnderstood(actual) if actual == expectedMsg => Outcome.pass
     | NotUnderstood(actual) =>
       Outcome.fail(TranslateError({expected: expectedMsg, actual: Some(actual)}))
@@ -171,8 +205,8 @@ module FromSlice = (
 
   /** Passes when the input was refused and the reason contains `reason`: the
       decoder words its own messages, so a test pins the part that matters. */
-  let thenRefusedInput = (received, reason) =>
-    switch received {
+  let thenRefusedInput = async (pending: promise<received>, reason) =>
+    switch (await pending).outcome {
     | InputRefused(actual) if actual->String.includes(reason) => Outcome.pass
     | other =>
       Outcome.fail(
@@ -185,4 +219,18 @@ module FromSlice = (
         }),
       )
     }
+
+  /** The capability calls `translate` made, in order. */
+  let thenSent = async (pending: promise<received>, expected: array<Capabilities_Fake.call>) => {
+    let {sent, _} = await pending
+    sent == expected
+      ? Outcome.pass
+      : Outcome.fail(
+          EventsMismatch({
+            expected: expected->Array.map(Capabilities_Fake.toJson),
+            actual: sent->Array.map(Capabilities_Fake.toJson),
+          }),
+        )
+  }
+  let thenNothingSent = pending => thenSent(pending, [])
 }

package/src/InboundTranslation_GWT.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -8,6 +9,7 @@ import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/U
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Capabilities_Fake$ReventlessGwt from "./Capabilities_Fake.res.mjs";
 
 function Make(Spec) {
   let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
@@ -92,28 +94,53 @@ function Make(Spec) {
 
 function FromSlice(Spec) {
   return Translation => {
-    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(Spec.name, name, timeout, body);
     let encPairs = pairs => pairs.map(param => {
       let d = {};
       d["id"] = param[0];
       d["command"] = Message$ReventlessCore.encode(param[1], Spec.commandSchema);
       return d;
     });
-    let whenInput = input => {
-      let pairs = Translation.translate(input);
-      if (pairs.TAG === "Ok") {
-        return {
-          TAG: "Translated",
-          _0: pairs._0
-        };
+    let errorOf = exn => {
+      if (exn.RE_EXN_ID === S.Exn) {
+        return exn._1.message;
+      } else if (exn.RE_EXN_ID === "JsExn") {
+        return Stdlib_Option.getOr(Stdlib_JsExn.message(exn._1), "unknown error");
       } else {
-        return {
+        return "unknown error";
+      }
+    };
+    let whenInput = async (input, fakesOpt, caller) => {
+      let fakes = fakesOpt !== undefined ? fakesOpt : Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+      let outcome;
+      let exit = 0;
+      let pairs;
+      try {
+        pairs = await Translation.translate(input, fakes.capabilities, caller);
+        exit = 1;
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        outcome = {
           TAG: "NotUnderstood",
-          _0: pairs._0
+          _0: errorOf(exn)
         };
       }
+      if (exit === 1) {
+        outcome = pairs.TAG === "Ok" ? ({
+            TAG: "Translated",
+            _0: pairs._0
+          }) : ({
+            TAG: "NotUnderstood",
+            _0: pairs._0
+          });
+      }
+      return {
+        outcome: outcome,
+        sent: fakes.calls()
+      };
     };
-    let whenReceived = json => {
+    let whenReceived = async (json, fakesOpt, caller) => {
+      let fakes = fakesOpt !== undefined ? fakesOpt : Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
       let input;
       try {
         input = Util_Sury$Reventless.fromJson(json, Spec.externalInputSchema);
@@ -121,26 +148,32 @@ function FromSlice(Spec) {
         let e = Primitive_exceptions.internalToException(raw_e);
         if (e.RE_EXN_ID === S.Exn) {
           return {
-            TAG: "InputRefused",
-            _0: e._1.message
+            outcome: {
+              TAG: "InputRefused",
+              _0: e._1.message
+            },
+            sent: fakes.calls()
           };
         } else {
           return {
-            TAG: "InputRefused",
-            _0: "invalid input"
+            outcome: {
+              TAG: "InputRefused",
+              _0: "invalid input"
+            },
+            sent: fakes.calls()
           };
         }
       }
-      return whenInput(input);
+      return await whenInput(input, fakes, caller);
     };
-    let describeOther = received => {
-      switch (received.TAG) {
+    let describeOther = outcome => {
+      switch (outcome.TAG) {
         case "Translated" :
           return;
         case "NotUnderstood" :
-          return `not understood: ` + received._0;
+          return `not understood: ` + outcome._0;
         case "InputRefused" :
-          return `input refused: ` + received._0;
+          return `input refused: ` + outcome._0;
       }
     };
     let roundTrips = cmd => {
@@ -152,18 +185,19 @@ function FromSlice(Spec) {
       }
       return Primitive_object.equal(back, cmd);
     };
-    let thenCommands = (received, expected) => {
-      switch (received.TAG) {
+    let thenCommands = async (pending, expected) => {
+      let actual = (await pending).outcome;
+      switch (actual.TAG) {
         case "Translated" :
-          let actual = received._0;
-          if (!Primitive_object.equal(actual, expected)) {
+          let actual$1 = actual._0;
+          if (!Primitive_object.equal(actual$1, expected)) {
             return Outcome$ReventlessGwt.fail({
               TAG: "EventsMismatch",
               expected: encPairs(expected),
-              actual: encPairs(actual)
+              actual: encPairs(actual$1)
             });
           }
-          let pair = actual.find(param => !roundTrips(param[1]));
+          let pair = actual$1.find(param => !roundTrips(param[1]));
           if (pair !== undefined) {
             return Outcome$ReventlessGwt.fail({
               TAG: "TranslateError",
@@ -178,22 +212,23 @@ function FromSlice(Spec) {
           return Outcome$ReventlessGwt.fail({
             TAG: "TranslateError",
             expected: "(commands)",
-            actual: describeOther(received)
+            actual: describeOther(actual)
           });
       }
     };
-    let thenCommand = (received, expectedId, expectedCmd) => thenCommands(received, [[
+    let thenCommand = (pending, expectedId, expectedCmd) => thenCommands(pending, [[
         expectedId,
         expectedCmd
       ]]);
-    let thenNoCommand = received => {
-      switch (received.TAG) {
+    let thenNoCommand = async pending => {
+      let actual = (await pending).outcome;
+      switch (actual.TAG) {
         case "Translated" :
-          let actual = received._0;
-          if (actual.length !== 0) {
+          let actual$1 = actual._0;
+          if (actual$1.length !== 0) {
             return Outcome$ReventlessGwt.fail({
               TAG: "NoEventExpected",
-              actual: encPairs(actual)
+              actual: encPairs(actual$1)
             });
           } else {
             return Outcome$ReventlessGwt.pass;
@@ -203,21 +238,22 @@ function FromSlice(Spec) {
           return Outcome$ReventlessGwt.fail({
             TAG: "TranslateError",
             expected: "(no commands)",
-            actual: describeOther(received)
+            actual: describeOther(actual)
           });
       }
     };
-    let thenNotUnderstood = (received, expectedMsg) => {
-      switch (received.TAG) {
+    let thenNotUnderstood = async (pending, expectedMsg) => {
+      let actual = (await pending).outcome;
+      switch (actual.TAG) {
         case "NotUnderstood" :
-          let actual = received._0;
-          if (actual === expectedMsg) {
+          let actual$1 = actual._0;
+          if (actual$1 === expectedMsg) {
             return Outcome$ReventlessGwt.pass;
           } else {
             return Outcome$ReventlessGwt.fail({
               TAG: "TranslateError",
               expected: expectedMsg,
-              actual: actual
+              actual: actual$1
             });
           }
         case "Translated" :
@@ -225,29 +261,30 @@ function FromSlice(Spec) {
           return Outcome$ReventlessGwt.fail({
             TAG: "TranslateError",
             expected: expectedMsg,
-            actual: describeOther(received)
+            actual: describeOther(actual)
           });
       }
     };
-    let thenRefusedInput = (received, reason) => {
-      switch (received.TAG) {
+    let thenRefusedInput = async (pending, reason) => {
+      let actual = (await pending).outcome;
+      switch (actual.TAG) {
         case "Translated" :
         case "NotUnderstood" :
           break;
         case "InputRefused" :
-          if (received._0.includes(reason)) {
+          if (actual._0.includes(reason)) {
             return Outcome$ReventlessGwt.pass;
           }
           break;
       }
       let tmp;
-      switch (received.TAG) {
+      switch (actual.TAG) {
         case "Translated" :
           tmp = "translated";
           break;
         case "NotUnderstood" :
         case "InputRefused" :
-          tmp = describeOther(received);
+          tmp = describeOther(actual);
           break;
       }
       return Outcome$ReventlessGwt.fail({
@@ -256,10 +293,26 @@ function FromSlice(Spec) {
         actual: tmp
       });
     };
+    let thenSent = async (pending, expected) => {
+      let match = await pending;
+      let sent = match.sent;
+      if (Primitive_object.equal(sent, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expected.map(Capabilities_Fake$ReventlessGwt.toJson),
+          actual: sent.map(Capabilities_Fake$ReventlessGwt.toJson)
+        });
+      }
+    };
+    let thenNothingSent = pending => thenSent(pending, []);
     return {
       describe: JestBind$ReventlessGwt.describe,
       test: test,
+      fakes: Capabilities_Fake$ReventlessGwt.make,
       encPairs: encPairs,
+      errorOf: errorOf,
       whenInput: whenInput,
       whenReceived: whenReceived,
       describeOther: describeOther,
@@ -269,7 +322,9 @@ function FromSlice(Spec) {
       thenNoCommand: thenNoCommand,
       thenNotUnderstood: thenNotUnderstood,
       thenTranslateError: thenNotUnderstood,
-      thenRefusedInput: thenRefusedInput
+      thenRefusedInput: thenRefusedInput,
+      thenSent: thenSent,
+      thenNothingSent: thenNothingSent
     };
   };
 }

package/src/OutboundTranslation_GWT.res.mjs

@@ -229,7 +229,7 @@ function FromSlice(Spec) {
     let givenTodo = (id, item) => ({
       id: id,
       item: item,
-      fakes: Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+      fakes: Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
     });
     let givenCapabilities = (todo, fakes) => ({
       id: todo.id,

package/src/ScenarioRecorder.res

@@ -120,7 +120,16 @@ let write = (~path: string, ~file: string, ~spec: string, scenarios: array<scena
       ),
     ]),
   )
-  NodeFs.writeFileSync(path, JSON.stringifyAny(json, ~space=2)->Option.getOr("{}") ++ "\n")
+  let text = JSON.stringifyAny(json, ~space=2)->Option.getOr("{}") ++ "\n"
+  // Written only when it says something new: a watch reacts to the write, and the same run
+  // records the same scenarios each time.
+  let same = switch NodeFs.readFileSync(path) {
+  | old => old == text
+  | exception _ => false
+  }
+  if !same {
+    NodeFs.writeFileSync(path, text)
+  }
 }
 
 /** Runs one test's `body`, recording its steps when recording is on, and adds the scenario to

package/src/ScenarioRecorder.res.mjs

@@ -161,7 +161,23 @@ function write(path, file, spec, scenarios) {
       ])))
     ]
   ]);
-  Nodefs.writeFileSync(path, Stdlib_Option.getOr(JSON.stringify(json, undefined, 2), "{}") + "\n", "utf8");
+  let text = Stdlib_Option.getOr(JSON.stringify(json, undefined, 2), "{}") + "\n";
+  let same;
+  let exit = 0;
+  let old;
+  try {
+    old = Nodefs.readFileSync(path, "utf8");
+    exit = 1;
+  } catch (exn) {
+    same = false;
+  }
+  if (exit === 1) {
+    same = old === text;
+  }
+  if (!same) {
+    Nodefs.writeFileSync(path, text, "utf8");
+    return;
+  }
 }
 
 function around(spec, title, body) {

package/src/StubRuntime.res

@@ -46,8 +46,6 @@ let pluginDefinition: Reventless.Plugin.pluginDefinition = {
   eventCollector: "NOT-SET",
   extensionProtocols: [],
   apiSchemaFragment: None,
-  apiTarget: None,
   structure: None,
-  dcbEventLog: None,
   kind: Domain,
 }

package/src/StubRuntime.res.mjs

@@ -31,9 +31,7 @@ let pluginDefinition = {
   eventCollector: "NOT-SET",
   extensionProtocols: [],
   apiSchemaFragment: undefined,
-  apiTarget: undefined,
   structure: undefined,
-  dcbEventLog: undefined,
   kind: "Domain"
 };
 

package/tests/InboundFromSliceGwtTest.res

@@ -16,14 +16,37 @@ module PaymentHook = {
   let endpoint = None
   type role = Reventless.Role.name
   let authorizationOf = _ => Reventless.Authorization.AllowAuthenticated
+  let capabilityNeeds = [Reventless.CapabilityNeed.Messaging]
 }
 
+// Confirms a paid order and, through the capability `translate` is handed, tells
+// the buyer — which is what makes the fakes worth asserting on. A payment marked
+// paid by hand is confirmed only for a caller in Finance, which is what makes the
+// caller worth handing in.
 module PaymentHook_Translation = {
   let moduleUrl = ""
-  let translate = (input: PaymentHook.externalInput) =>
+  let translate = async (
+    input: PaymentHook.externalInput,
+    ~capabilities: Reventless.Capabilities.t,
+    ~caller: option<Reventless.Identity.t>,
+  ) =>
     switch input.status {
-    | "paid" => Ok([(input.orderId, PaymentHook.ConfirmPayment({orderId: input.orderId}))])
+    | "paidByHand" =>
+      switch caller {
+      | Some(identity) if identity->Reventless.Identity.hasGroup("Finance") =>
+        Ok([(input.orderId, PaymentHook.ConfirmPayment({orderId: input.orderId}))])
+      | _ => Error("only Finance marks a payment paid by hand")
+      }
+    | "paid" =>
+      switch await capabilities.messaging.send(
+        ~recipient=ToEmail(Reventless.Email.unsafe("buyer@example.com")),
+        ~message={subject: "Paid", body: input.orderId},
+      ) {
+      | Ok(_) => Ok([(input.orderId, PaymentHook.ConfirmPayment({orderId: input.orderId}))])
+      | Error(failure) => Error(Reventless.Messaging.failureReason(failure))
+      }
     | "pending" => Ok([])
+    | "broken" => JsError.throwWithMessage("the translation threw")
     | other => Error(`Unknown status: ${other}`)
     }
 }
@@ -34,7 +57,41 @@ include InboundTranslation_GWT.FromSlice(PaymentHook, PaymentHook_Translation)
 let json = (pairs: array<(string, string)>) =>
   pairs->Array.map(((k, v)) => (k, JSON.Encode.string(v)))->Dict.fromArray->JSON.Encode.object
 
+let financeClerk: Reventless.Identity.t = {
+  ...Reventless.Identity.anonymous,
+  userId: "u_clerk",
+  groups: ["Finance"],
+}
+let visitor = Reventless.Identity.anonymous
+
 describe("InboundTranslation_GWT.FromSlice", () => {
+  test("a door that reads its caller translates for the caller it admits", () =>
+    whenInput({orderId: "o1", status: "paidByHand"}, ~caller=financeClerk)->thenCommand(
+      "o1",
+      ConfirmPayment({orderId: "o1"}),
+    )
+  )
+
+  test("…and declines a caller it does not", () =>
+    whenInput({orderId: "o1", status: "paidByHand"}, ~caller=visitor)->thenNotUnderstood(
+      "only Finance marks a payment paid by hand",
+    )
+  )
+
+  // No caller is the platform acting for itself, which this door does not admit.
+  test("…and an input with no caller at all", () =>
+    whenInput({orderId: "o1", status: "paidByHand"})->thenNotUnderstood(
+      "only Finance marks a payment paid by hand",
+    )
+  )
+
+  test("received JSON carries its caller through the decode", () =>
+    whenReceived(
+      json([("orderId", "o1"), ("status", "paidByHand")]),
+      ~caller=financeClerk,
+    )->thenCommand("o1", ConfirmPayment({orderId: "o1"}))
+  )
+
   test("input translates to a command", () =>
     whenInput({orderId: "o1", status: "paid"})->thenCommand("o1", ConfirmPayment({orderId: "o1"}))
   )
@@ -61,4 +118,28 @@ describe("InboundTranslation_GWT.FromSlice", () => {
   test("no commands is an answer", () =>
     whenInput({orderId: "o1", status: "pending"})->thenNoCommand
   )
+
+  test("translate reaches the capabilities it is handed", () =>
+    whenInput({orderId: "o1", status: "paid"})->thenSent([
+      Sent({
+        recipient: ToEmail(Reventless.Email.unsafe("buyer@example.com")),
+        message: {subject: "Paid", body: "o1"},
+      }),
+    ])
+  )
+
+  test("a capability failure is the translation declining the input", () =>
+    whenInput(
+      {orderId: "o1", status: "paid"},
+      ~fakes=fakes(~send=async (~recipient as _, ~message as _) => Error(Unavailable("down")), ()),
+    )->thenNotUnderstood("down")
+  )
+
+  test("a translation that throws declined the input", () =>
+    whenInput({orderId: "o1", status: "broken"})->thenNotUnderstood("the translation threw")
+  )
+
+  test("input that never translated sent nothing", () =>
+    whenReceived(json([("status", "paid")]))->thenNothingSent
+  )
 })

package/tests/InboundFromSliceGwtTest.res.mjs

@@ -1,6 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
 import * as InboundTranslation_GWT$ReventlessGwt from "../src/InboundTranslation_GWT.res.mjs";
 
 let name = "PaymentHook";
@@ -25,6 +28,8 @@ function authorizationOf(param) {
   return "AllowAuthenticated";
 }
 
+let capabilityNeeds = ["Messaging"];
+
 let traits = [];
 
 let PaymentHook = {
@@ -36,25 +41,60 @@ let PaymentHook = {
   externalSystem: externalSystem,
   endpoint: undefined,
   authorizationOf: authorizationOf,
+  capabilityNeeds: capabilityNeeds,
   traits: traits
 };
 
 let moduleUrl$1 = "";
 
-function translate(input) {
+async function translate(input, capabilities, caller) {
   let other = input.status;
   switch (other) {
+    case "broken" :
+      return Stdlib_JsError.throwWithMessage("the translation threw");
     case "paid" :
-      return {
-        TAG: "Ok",
-        _0: [[
-            input.orderId,
-            {
-              TAG: "ConfirmPayment",
-              orderId: input.orderId
-            }
-          ]]
-      };
+      let failure = await capabilities.messaging.send({
+        TAG: "ToEmail",
+        _0: "buyer@example.com"
+      }, {
+        subject: "Paid",
+        body: input.orderId
+      });
+      if (failure.TAG === "Ok") {
+        return {
+          TAG: "Ok",
+          _0: [[
+              input.orderId,
+              {
+                TAG: "ConfirmPayment",
+                orderId: input.orderId
+              }
+            ]]
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: Messaging$Reventless.failureReason(failure._0)
+        };
+      }
+    case "paidByHand" :
+      if (caller !== undefined && Identity$Reventless.hasGroup(caller, "Finance")) {
+        return {
+          TAG: "Ok",
+          _0: [[
+              input.orderId,
+              {
+                TAG: "ConfirmPayment",
+                orderId: input.orderId
+              }
+            ]]
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: "only Finance marks a payment paid by hand"
+        };
+      }
     case "pending" :
       return {
         TAG: "Ok",
@@ -81,7 +121,8 @@ let include = InboundTranslation_GWT$ReventlessGwt.FromSlice({
   targetName: targetName,
   externalSystem: externalSystem,
   authorizationOf: authorizationOf,
-  endpoint: undefined
+  endpoint: undefined,
+  capabilityNeeds: capabilityNeeds
 })({
   translate: translate,
   moduleUrl: moduleUrl$1
@@ -91,6 +132,8 @@ let describe = include.describe;
 
 let test = include.test;
 
+let fakes = include.fakes;
+
 let whenInput = include.whenInput;
 
 let whenReceived = include.whenReceived;
@@ -105,6 +148,10 @@ let thenTranslateError = include.thenTranslateError;
 
 let thenRefusedInput = include.thenRefusedInput;
 
+let thenSent = include.thenSent;
+
+let thenNothingSent = include.thenNothingSent;
+
 function json(pairs) {
   return Object.fromEntries(pairs.map(param => [
     param[0],
@@ -112,15 +159,49 @@ function json(pairs) {
   ]));
 }
 
+let newrecord = {...Identity$Reventless.anonymous};
+
+newrecord.groups = ["Finance"];
+
+newrecord.userId = "u_clerk";
+
 describe("InboundTranslation_GWT.FromSlice", () => {
-  test("input translates to a command", () => thenCommand(whenInput({
+  test("a door that reads its caller translates for the caller it admits", undefined, () => thenCommand(whenInput({
+    orderId: "o1",
+    status: "paidByHand"
+  }, undefined, newrecord), "o1", {
+    TAG: "ConfirmPayment",
+    orderId: "o1"
+  }));
+  test("…and declines a caller it does not", undefined, () => thenNotUnderstood(whenInput({
+    orderId: "o1",
+    status: "paidByHand"
+  }, undefined, Identity$Reventless.anonymous), "only Finance marks a payment paid by hand"));
+  test("…and an input with no caller at all", undefined, () => thenNotUnderstood(whenInput({
+    orderId: "o1",
+    status: "paidByHand"
+  }, undefined, undefined), "only Finance marks a payment paid by hand"));
+  test("received JSON carries its caller through the decode", undefined, () => thenCommand(whenReceived(json([
+    [
+      "orderId",
+      "o1"
+    ],
+    [
+      "status",
+      "paidByHand"
+    ]
+  ]), undefined, newrecord), "o1", {
+    TAG: "ConfirmPayment",
+    orderId: "o1"
+  }));
+  test("input translates to a command", undefined, () => thenCommand(whenInput({
     orderId: "o1",
     status: "paid"
-  }), "o1", {
+  }, undefined, undefined), "o1", {
     TAG: "ConfirmPayment",
     orderId: "o1"
   }));
-  test("received JSON decodes before it translates", () => thenCommand(whenReceived(json([
+  test("received JSON decodes before it translates", undefined, () => thenCommand(whenReceived(json([
     [
       "orderId",
       "o1"
@@ -129,42 +210,82 @@ describe("InboundTranslation_GWT.FromSlice", () => {
       "status",
       "paid"
     ]
-  ])), "o1", {
+  ]), undefined, undefined), "o1", {
     TAG: "ConfirmPayment",
     orderId: "o1"
   }));
-  test("input that does not decode is refused before translate", () => thenRefusedInput(whenReceived(json([[
+  test("input that does not decode is refused before translate", undefined, () => thenRefusedInput(whenReceived(json([[
       "status",
       "paid"
-    ]])), "orderId"));
-  test("input translate declines is not understood", () => thenNotUnderstood(whenInput({
+    ]]), undefined, undefined), "orderId"));
+  test("input translate declines is not understood", undefined, () => thenNotUnderstood(whenInput({
     orderId: "o1",
     status: "lost"
-  }), "Unknown status: lost"));
-  test("thenTranslateError is the older name", () => thenTranslateError(whenInput({
+  }, undefined, undefined), "Unknown status: lost"));
+  test("thenTranslateError is the older name", undefined, () => thenTranslateError(whenInput({
     orderId: "o1",
     status: "lost"
-  }), "Unknown status: lost"));
-  test("no commands is an answer", () => thenNoCommand(whenInput({
+  }, undefined, undefined), "Unknown status: lost"));
+  test("no commands is an answer", undefined, () => thenNoCommand(whenInput({
     orderId: "o1",
     status: "pending"
-  })));
+  }, undefined, undefined)));
+  test("translate reaches the capabilities it is handed", undefined, () => thenSent(whenInput({
+    orderId: "o1",
+    status: "paid"
+  }, undefined, undefined), [{
+      TAG: "Sent",
+      recipient: {
+        TAG: "ToEmail",
+        _0: "buyer@example.com"
+      },
+      message: {
+        subject: "Paid",
+        body: "o1"
+      }
+    }]));
+  test("a capability failure is the translation declining the input", undefined, () => thenNotUnderstood(whenInput({
+    orderId: "o1",
+    status: "paid"
+  }, fakes(undefined, async (param, param$1) => ({
+    TAG: "Error",
+    _0: {
+      TAG: "Unavailable",
+      _0: "down"
+    }
+  }), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined), undefined), "down"));
+  test("a translation that throws declined the input", undefined, () => thenNotUnderstood(whenInput({
+    orderId: "o1",
+    status: "broken"
+  }, undefined, undefined), "the translation threw"));
+  test("input that never translated sent nothing", undefined, () => thenNothingSent(whenReceived(json([[
+      "status",
+      "paid"
+    ]]), undefined, undefined)));
 });
 
 let encPairs = include.encPairs;
 
+let errorOf = include.errorOf;
+
 let describeOther = include.describeOther;
 
 let roundTrips = include.roundTrips;
 
 let thenCommands = include.thenCommands;
 
+let financeClerk = newrecord;
+
+let visitor = Identity$Reventless.anonymous;
+
 export {
   PaymentHook,
   PaymentHook_Translation,
   describe,
   test,
+  fakes,
   encPairs,
+  errorOf,
   whenInput,
   whenReceived,
   describeOther,
@@ -175,6 +296,10 @@ export {
   thenNotUnderstood,
   thenTranslateError,
   thenRefusedInput,
+  thenSent,
+  thenNothingSent,
   json,
+  financeClerk,
+  visitor,
 }
 /* externalInputSchema Not a pure module */

package/tests/OutboundFromSliceGwtTest.res.mjs

@@ -151,7 +151,7 @@ let down = Capabilities_Fake$ReventlessGwt.make(undefined, async (param, param$1
     TAG: "Unavailable",
     _0: "smtp down"
   }
-}), undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+}), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
 
 let welcome = {
   TAG: "Sent",