@reventlessdev/reventless-gwt 1.0.0-alpha.247 → 1.0.0-alpha.249

package/tests/HintTest.res

@@ -1,5 +1,5 @@
 // A state mismatch's hint names the fold that produced the state: `project` for
-// a view's scenario, `evolve` for a behavior's.
+// a view's scenario, `evolve` for a decision's.
 
 open JestGlobals
 
@@ -46,7 +46,7 @@ describe("Hint for a StateMismatch", () => {
     }
   })
 
-  testSync("a behavior's differing state still points at evolve", () => {
+  testSync("a decision's differing state still points at evolve", () => {
     let hint = Hint.forMismatch(
       ~slice="AddCategory",
       Outcome.StateMismatch({key: "c1", expected: None, actual: None}),

package/tests/HintTest.res.mjs

@@ -80,7 +80,7 @@ globalThis.describe("Hint for a StateMismatch", () => {
     globalThis.expect(hint.locus).toBe("CategoriesView.project");
     globalThis.expect(hint.message).toBe("project() filed a different row than expected. Check the arm for the event and the key it sets.");
   });
-  globalThis.test("a behavior's differing state still points at evolve", () => {
+  globalThis.test("a decision's differing state still points at evolve", () => {
     let hint = Hint$ReventlessGwt.forMismatch("AddCategory", {
       TAG: "StateMismatch",
       key: "c1",

package/tests/MappingGwtTest.res

@@ -7,7 +7,7 @@
 // module types.
 
 // ---------------------------------------------------------------------------
-// Shared Aggregate specs + behaviours used by the Aggr→* cases below.
+// Shared Aggregate specs + decisions used by the Aggr→* cases below.
 // ---------------------------------------------------------------------------
 
 module CategorySpec = {
@@ -26,7 +26,7 @@ module CategorySpec = {
   let moduleUrl = ""
 }
 
-module CategoryBehavior = {
+module CategoryDecision = {
   module Spec = CategorySpec
   type state = NotCreated | Created
   let initialState = NotCreated
@@ -64,7 +64,7 @@ module ProductSpec = {
   let moduleUrl = ""
 }
 
-module ProductBehavior = {
+module ProductDecision = {
   module Spec = ProductSpec
   type state = Pristine | Mirrored
   let initialState = Pristine
@@ -164,8 +164,8 @@ module InventorySlice = {
 // Adapter aliases — built once, shared across mappings.
 // ---------------------------------------------------------------------------
 
-module CategorySource = Mapping_GWT.FromBehavior(CategorySpec, CategoryBehavior)
-module ProductTarget = Mapping_GWT.FromBehavior(ProductSpec, ProductBehavior)
+module CategorySource = Mapping_GWT.FromDecision(CategorySpec, CategoryDecision)
+module ProductTarget = Mapping_GWT.FromDecision(ProductSpec, ProductDecision)
 module NotificationSource = Mapping_GWT.FromStateChangeSlice(NotificationSlice)
 module NotificationTarget = Mapping_GWT.FromStateChangeSlice(NotificationSlice)
 module InventoryTarget = Mapping_GWT.FromStateChangeSlice(InventorySlice)

package/tests/MappingGwtTest.res.mjs

@@ -69,7 +69,7 @@ function decide(state, cmd) {
 
 let moduleUrl$1 = "";
 
-let CategoryBehavior = {
+let CategoryDecision = {
   Spec: undefined,
   initialState: "NotCreated",
   snapshot: undefined,
@@ -145,7 +145,7 @@ function decide$1(state, cmd) {
 
 let moduleUrl$3 = "";
 
-let ProductBehavior = {
+let ProductDecision = {
   Spec: undefined,
   initialState: "Pristine",
   snapshot: undefined,
@@ -298,7 +298,7 @@ let InventorySlice = {
   readConsistency: "EscalateOnRetry"
 };
 
-let CategorySource = Mapping_GWT$ReventlessGwt.FromBehavior({
+let CategorySource = Mapping_GWT$ReventlessGwt.FromDecision({
   Id: {
     schema: Id$Reventless.StringPure.schema,
     make: prim => prim,
@@ -339,7 +339,7 @@ let CategorySource = Mapping_GWT$ReventlessGwt.FromBehavior({
   moduleUrl: moduleUrl$1
 });
 
-let ProductTarget = Mapping_GWT$ReventlessGwt.FromBehavior({
+let ProductTarget = Mapping_GWT$ReventlessGwt.FromDecision({
   Id: {
     schema: Id$Reventless.StringPure.schema,
     make: prim => prim,
@@ -611,9 +611,9 @@ DcbToDcbGwt.describe("Inventory → Notification (DCB → DCB)", () => {
 
 export {
   CategorySpec,
-  CategoryBehavior,
+  CategoryDecision,
   ProductSpec,
-  ProductBehavior,
+  ProductDecision,
   NotificationSlice,
   InventorySlice,
   CategorySource,

package/tests/ScenarioRecorderTest.res

@@ -0,0 +1,101 @@
+open JestGlobals
+
+// `ScenarioRecorder` writes what a decision test runs as a sidecar `check-lifecycle` reads, for
+// a suite whose source names nothing (one written against a binding). Each case records into a
+// file of its own under the OS temp folder, named by `setFile` as an external runner would.
+
+let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "scenario-recorder-"]))
+let testFile = name => NodePath.join([dir, `${name}_GWT.res.mjs`])
+let sidecarOf = name => NodePath.join([dir, `${name}_GWT.gwt.json`])
+
+let read = path => NodeFs.readFileSync(path)->JSON.parseOrThrow
+
+let field = (json: JSON.t, key) =>
+  switch json {
+  | Object(d) => d->Dict.get(key)
+  | _ => None
+  }
+
+// One recorded test: the history, the command, and the event it expects.
+let run = (~spec, ~title, ~expects) =>
+  ScenarioRecorder.around(~spec, title, () => {
+    ScenarioRecorder.given(["CustomerRegistered"])
+    ScenarioRecorder.whenCommand("RequestNotification")
+    ScenarioRecorder.thenEvents([expects])
+  })
+
+let switched = (on, f) => {
+  NodeProcess.env->Dict.set("REVENTLESS_EMIT_SIDECAR", on ? "1" : "0")
+  let out = f()
+  NodeProcess.env->Dict.delete("REVENTLESS_EMIT_SIDECAR")
+  out
+}
+
+describe("ScenarioRecorder", () => {
+  testSync("with the switch off it writes nothing", () => {
+    ScenarioRecorder.setFile(testFile("Off"))
+    switched(false, () => run(~spec="Prefs", ~title="t", ~expects="NotificationRequested"))
+    expect(NodeFs.existsSync(sidecarOf("Off")))->toBe(false)
+  })
+
+  testSync("a test run with the switch on is a sidecar naming its spec as the component", () => {
+    ScenarioRecorder.setFile(testFile("Conformance"))
+    switched(
+      true,
+      () => {
+        run(~spec="Prefs", ~title="undeliverable", ~expects="NotificationUndeliverable")
+        run(~spec="Prefs", ~title="deferred", ~expects="NotificationDeferred")
+      },
+    )
+    let json = read(sidecarOf("Conformance"))
+    let scenarios = switch json->field("scenarios") {
+    | Some(Array(xs)) => xs
+    | _ => []
+    }
+    expect((
+      json->field("stem"),
+      json->field("recorded"),
+      scenarios->Array.map(
+        s =>
+          switch (s->field("when"), s->field("then")) {
+          | (Some(Array([w])), Some(Array([t]))) => (w->field("element"), t->field("element"))
+          | _ => (None, None)
+          },
+      ),
+    ))->toEqual((
+      Some(JSON.String("Prefs")),
+      Some(JSON.Boolean(true)),
+      [
+        (Some(JSON.String("RequestNotification")), Some(JSON.String("NotificationUndeliverable"))),
+        (Some(JSON.String("RequestNotification")), Some(JSON.String("NotificationDeferred"))),
+      ],
+    ))
+  })
+
+  testSync("a sidecar the PPX wrote is left as it is", () => {
+    let ppx = `{"stem":"Mine_GWT","scenarios":[]}`
+    NodeFs.writeFileSync(sidecarOf("Mine"), ppx)
+    ScenarioRecorder.setFile(testFile("Mine"))
+    switched(true, () => run(~spec="Prefs", ~title="t", ~expects="NotificationRequested"))
+    expect(NodeFs.readFileSync(sidecarOf("Mine")))->toBe(ppx)
+  })
+
+  testSync("a second spec in one file gets a sidecar of its own", () => {
+    ScenarioRecorder.setFile(testFile("Two"))
+    switched(
+      true,
+      () => {
+        run(~spec="Prefs", ~title="a", ~expects="NotificationRequested")
+        run(~spec="Claims", ~title="b", ~expects="NotificationSourceClaimed")
+      },
+    )
+    expect((
+      read(sidecarOf("Two"))->field("stem"),
+      read(NodePath.join([dir, "Two_GWT.Claims.gwt.json"]))->field("stem"),
+    ))->toEqual((Some(JSON.String("Prefs")), Some(JSON.String("Claims"))))
+  })
+
+  testSync("steps outside a recorded test record nothing", () =>
+    expect(ScenarioRecorder.recording())->toBe(false)
+  )
+})

package/tests/ScenarioRecorderTest.res.mjs

@@ -0,0 +1,163 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as ScenarioRecorder$ReventlessGwt from "../src/ScenarioRecorder.res.mjs";
+
+let dir = Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "scenario-recorder-"));
+
+function testFile(name) {
+  return Nodepath.join(dir, name + `_GWT.res.mjs`);
+}
+
+function sidecarOf(name) {
+  return Nodepath.join(dir, name + `_GWT.gwt.json`);
+}
+
+function read(path) {
+  return JSON.parse(Nodefs.readFileSync(path, "utf8"));
+}
+
+function field(json, key) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return json[key];
+  }
+}
+
+function run(spec, title, expects) {
+  ScenarioRecorder$ReventlessGwt.around(spec, title, () => {
+    ScenarioRecorder$ReventlessGwt.given(["CustomerRegistered"]);
+    ScenarioRecorder$ReventlessGwt.whenCommand("RequestNotification");
+    ScenarioRecorder$ReventlessGwt.thenEvents([expects]);
+  });
+}
+
+function switched(on, f) {
+  process.env["REVENTLESS_EMIT_SIDECAR"] = on ? "1" : "0";
+  let out = f();
+  Stdlib_Dict.$$delete(process.env, "REVENTLESS_EMIT_SIDECAR");
+  return out;
+}
+
+globalThis.describe("ScenarioRecorder", () => {
+  globalThis.test("with the switch off it writes nothing", () => {
+    ScenarioRecorder$ReventlessGwt.setFile(testFile("Off"));
+    switched(false, () => run("Prefs", "t", "NotificationRequested"));
+    globalThis.expect(Nodefs.existsSync(sidecarOf("Off"))).toBe(false);
+  });
+  globalThis.test("a test run with the switch on is a sidecar naming its spec as the component", () => {
+    ScenarioRecorder$ReventlessGwt.setFile(testFile("Conformance"));
+    switched(true, () => {
+      run("Prefs", "undeliverable", "NotificationUndeliverable");
+      run("Prefs", "deferred", "NotificationDeferred");
+    });
+    let path = sidecarOf("Conformance");
+    let json = JSON.parse(Nodefs.readFileSync(path, "utf8"));
+    let match = field(json, "scenarios");
+    let scenarios = match !== undefined ? (
+        Array.isArray(match) ? match : []
+      ) : [];
+    globalThis.expect([
+      field(json, "stem"),
+      field(json, "recorded"),
+      scenarios.map(s => {
+        let match = field(s, "when");
+        let match$1 = field(s, "then");
+        if (match === undefined) {
+          return [
+            undefined,
+            undefined
+          ];
+        }
+        if (!Array.isArray(match)) {
+          return [
+            undefined,
+            undefined
+          ];
+        }
+        if (match.length !== 1) {
+          return [
+            undefined,
+            undefined
+          ];
+        }
+        let w = match[0];
+        if (match$1 === undefined) {
+          return [
+            undefined,
+            undefined
+          ];
+        }
+        if (!Array.isArray(match$1)) {
+          return [
+            undefined,
+            undefined
+          ];
+        }
+        if (match$1.length !== 1) {
+          return [
+            undefined,
+            undefined
+          ];
+        }
+        let t = match$1[0];
+        return [
+          field(w, "element"),
+          field(t, "element")
+        ];
+      })
+    ]).toEqual([
+      "Prefs",
+      true,
+      [
+        [
+          "RequestNotification",
+          "NotificationUndeliverable"
+        ],
+        [
+          "RequestNotification",
+          "NotificationDeferred"
+        ]
+      ]
+    ]);
+  });
+  globalThis.test("a sidecar the PPX wrote is left as it is", () => {
+    let ppx = `{"stem":"Mine_GWT","scenarios":[]}`;
+    Nodefs.writeFileSync(sidecarOf("Mine"), ppx, "utf8");
+    ScenarioRecorder$ReventlessGwt.setFile(testFile("Mine"));
+    switched(true, () => run("Prefs", "t", "NotificationRequested"));
+    globalThis.expect(Nodefs.readFileSync(sidecarOf("Mine"), "utf8")).toBe(ppx);
+  });
+  globalThis.test("a second spec in one file gets a sidecar of its own", () => {
+    ScenarioRecorder$ReventlessGwt.setFile(testFile("Two"));
+    switched(true, () => {
+      run("Prefs", "a", "NotificationRequested");
+      run("Claims", "b", "NotificationSourceClaimed");
+    });
+    let path = sidecarOf("Two");
+    let path$1 = Nodepath.join(dir, "Two_GWT.Claims.gwt.json");
+    globalThis.expect([
+      field(JSON.parse(Nodefs.readFileSync(path, "utf8")), "stem"),
+      field(JSON.parse(Nodefs.readFileSync(path$1, "utf8")), "stem")
+    ]).toEqual([
+      "Prefs",
+      "Claims"
+    ]);
+  });
+  globalThis.test("steps outside a recorded test record nothing", () => {
+    globalThis.expect(ScenarioRecorder$ReventlessGwt.recording()).toBe(false);
+  });
+});
+
+export {
+  dir,
+  testFile,
+  sidecarOf,
+  read,
+  field,
+  run,
+  switched,
+}
+/* dir Not a pure module */

package/tests/StateChange/ExternalAddCategorySlice_GWT.res

@@ -1,11 +1,11 @@
 // External-Spec verification test for @@reventless.gwt.
 //
 // Zero payload, no local module, no alias. The PPX resolves:
-//   - Kind from the folder segment "StateChange" -> Behavior
+//   - Kind from the folder segment "StateChange" -> Decision
 //   - Spec from the filename stem (strip "_GWT") -> ExternalAddCategorySlice
-//   - Impl derived as ExternalAddCategorySlice_Behavior
+//   - Impl derived as ExternalAddCategorySlice_Decision
 //   - open ExternalAddCategorySlice +
-//     include Behavior_GWT.Make(ExternalAddCategorySlice, ExternalAddCategorySlice_Behavior)
+//     include Decision_GWT.Make(ExternalAddCategorySlice, ExternalAddCategorySlice_Decision)
 //
 // Mirrors the canonical consumer pattern documented in
 // docs/guides/given-when-then.md § 4.10.

package/tests/StateChange/ExternalAddCategorySlice_GWT.res.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Behavior_GWT$ReventlessGwt from "../../src/Behavior_GWT.res.mjs";
+import * as Decision_GWT$ReventlessGwt from "../../src/Decision_GWT.res.mjs";
 import * as ExternalAddCategorySlice$ReventlessGwt from "../../src/StateChange/ExternalAddCategorySlice.res.mjs";
-import * as ExternalAddCategorySlice_Behavior$ReventlessGwt from "../../src/StateChange/ExternalAddCategorySlice_Behavior.res.mjs";
+import * as ExternalAddCategorySlice_Decision$ReventlessGwt from "../../src/StateChange/ExternalAddCategorySlice_Decision.res.mjs";
 
-let include = Behavior_GWT$ReventlessGwt.Make(ExternalAddCategorySlice$ReventlessGwt)(ExternalAddCategorySlice_Behavior$ReventlessGwt);
+let include = Decision_GWT$ReventlessGwt.Make(ExternalAddCategorySlice$ReventlessGwt)(ExternalAddCategorySlice_Decision$ReventlessGwt);
 
 let describe = include.describe;
 
@@ -51,7 +51,7 @@ let thenEventWithError = include.thenEventWithError;
 
 let thenEventsWithError = include.thenEventsWithError;
 
-let thenRefused = include.thenRefused;
+let thenForbidden = include.thenForbidden;
 
 let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
 
@@ -72,7 +72,7 @@ export {
   thenEventWithError,
   thenEventsWithError,
   thenError,
-  thenRefused,
+  thenForbidden,
   thenAppendsConditionedOn,
   thenAppendsConditionedOnExactly,
 }

package/tests/StateChange/WithFixtures_GWT.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Behavior_GWT$ReventlessGwt from "../../src/Behavior_GWT.res.mjs";
+import * as Decision_GWT$ReventlessGwt from "../../src/Decision_GWT.res.mjs";
 import * as WithFixtures$ReventlessGwt from "../../src/StateChange/WithFixtures.res.mjs";
-import * as WithFixtures_Behavior$ReventlessGwt from "../../src/StateChange/WithFixtures_Behavior.res.mjs";
+import * as WithFixtures_Decision$ReventlessGwt from "../../src/StateChange/WithFixtures_Decision.res.mjs";
 import * as WithFixtures_Fixtures$ReventlessGwt from "./WithFixtures_Fixtures.res.mjs";
 
-let include = Behavior_GWT$ReventlessGwt.Make(WithFixtures$ReventlessGwt)(WithFixtures_Behavior$ReventlessGwt);
+let include = Decision_GWT$ReventlessGwt.Make(WithFixtures$ReventlessGwt)(WithFixtures_Decision$ReventlessGwt);
 
 let describe = include.describe;
 
@@ -37,7 +37,7 @@ let thenEventsWithError = include.thenEventsWithError;
 
 let thenError = include.thenError;
 
-let thenRefused = include.thenRefused;
+let thenForbidden = include.thenForbidden;
 
 let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
 
@@ -58,7 +58,7 @@ export {
   thenEventWithError,
   thenEventsWithError,
   thenError,
-  thenRefused,
+  thenForbidden,
   thenAppendsConditionedOn,
   thenAppendsConditionedOnExactly,
 }

package/tests/StateChange/WithManualOpen_GWT.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Behavior_GWT$ReventlessGwt from "../../src/Behavior_GWT.res.mjs";
+import * as Decision_GWT$ReventlessGwt from "../../src/Decision_GWT.res.mjs";
 import * as WithManualOpen$ReventlessGwt from "../../src/StateChange/WithManualOpen.res.mjs";
-import * as WithManualOpen_Behavior$ReventlessGwt from "../../src/StateChange/WithManualOpen_Behavior.res.mjs";
+import * as WithManualOpen_Decision$ReventlessGwt from "../../src/StateChange/WithManualOpen_Decision.res.mjs";
 import * as WithManualOpen_Fixtures$ReventlessGwt from "./WithManualOpen_Fixtures.res.mjs";
 
-let include = Behavior_GWT$ReventlessGwt.Make(WithManualOpen$ReventlessGwt)(WithManualOpen_Behavior$ReventlessGwt);
+let include = Decision_GWT$ReventlessGwt.Make(WithManualOpen$ReventlessGwt)(WithManualOpen_Decision$ReventlessGwt);
 
 let describe = include.describe;
 
@@ -37,7 +37,7 @@ let thenEventsWithError = include.thenEventsWithError;
 
 let thenError = include.thenError;
 
-let thenRefused = include.thenRefused;
+let thenForbidden = include.thenForbidden;
 
 let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
 
@@ -58,7 +58,7 @@ export {
   thenEventWithError,
   thenEventsWithError,
   thenError,
-  thenRefused,
+  thenForbidden,
   thenAppendsConditionedOn,
   thenAppendsConditionedOnExactly,
 }

package/tests/StateChangeSliceAuthorizeGwtTest.res

@@ -8,7 +8,7 @@ module ShelveSlice = {
   let name = "Shelve"
 
   // Inside the spec, so the zero-argument form still finds the spec and its
-  // behaviour first; the rule's `Roles` resolves by ordinary scoping either way.
+  // decision first; the rule's `Roles` resolves by ordinary scoping either way.
   module Roles = {
     type t =
       | Admin
@@ -35,7 +35,7 @@ module ShelveSlice = {
   type event = Done({shelfId: @s.matches(Reventless.DcbTag.string) string})
 }
 
-module ShelveSliceBehavior = {
+module ShelveSliceDecision = {
   module Spec = ShelveSlice
   open ShelveSlice
 
@@ -67,23 +67,23 @@ describe("a command's rule, checked against the caller's roles", () => {
   )
 
   test("refused for a signed-in caller holding none of them", () =>
-    givenEvents([])->asCaller(Caller.owner("c1"))->whenCmd(Shelve({shelfId: s1}))->thenRefused
+    givenEvents([])->asCaller(Caller.owner("c1"))->whenCmd(Shelve({shelfId: s1}))->thenForbidden
   )
 
   test("refused for an anonymous caller", () =>
-    givenEvents([])->asCaller(Caller.anonymous)->whenCmd(Shelve({shelfId: s1}))->thenRefused
+    givenEvents([])->asCaller(Caller.anonymous)->whenCmd(Shelve({shelfId: s1}))->thenForbidden
   )
 
   // Elevation lifts ownership rules, not rules about who may issue a command.
   test("refused for an operator, who holds no role", () =>
-    givenEvents([])->asCaller(Caller.operator)->whenCmd(Shelve({shelfId: s1}))->thenRefused
+    givenEvents([])->asCaller(Caller.operator)->whenCmd(Shelve({shelfId: s1}))->thenForbidden
   )
 
   test("DenyAll refuses every caller, Admin included", () =>
     givenEvents([])
     ->asCaller(Caller.inRoles([Admin]))
     ->whenCmd(Purge({shelfId: s1}))
-    ->thenRefused
+    ->thenForbidden
   )
 
   test("AllowAnonymous accepts an anonymous caller", () =>
@@ -94,7 +94,7 @@ describe("a command's rule, checked against the caller's roles", () => {
   )
 
   test("the default rule refuses an anonymous caller", () =>
-    givenEvents([])->asCaller(Caller.anonymous)->whenCmd(Browse({shelfId: s1}))->thenRefused
+    givenEvents([])->asCaller(Caller.anonymous)->whenCmd(Browse({shelfId: s1}))->thenForbidden
   )
 
   test("a scenario without asCaller is checked against no rule", () =>
@@ -132,7 +132,7 @@ module ClaimSlice = {
   type event = Done({shelfId: @s.matches(Reventless.DcbTag.string) string})
 }
 
-module Claim = Behavior_GWT.Make(
+module Claim = Decision_GWT.Make(
   ClaimSlice,
   {
     type state = unit
@@ -162,13 +162,13 @@ describe("the rule, then ownership", () => {
     Claim.givenEvents(claimedByC1)
     ->Claim.asCaller(Claim.Caller.owner("c2", ~roles=[Merchandiser]))
     ->Claim.whenCmd(Shelve({shelfId: s1}))
-    ->Claim.thenRefused
+    ->Claim.thenForbidden
   )
 
   Claim.test("owning a thing does not pass a rule the owner fails", () =>
     Claim.givenEvents(claimedByC1)
     ->Claim.asCaller(Claim.Caller.owner("c1"))
     ->Claim.whenCmd(Shelve({shelfId: s1}))
-    ->Claim.thenRefused
+    ->Claim.thenForbidden
   )
 })

package/tests/StateChangeSliceAuthorizeGwtTest.res.mjs

@@ -3,7 +3,7 @@
 import * as Sury from "sury";
 import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
-import * as Behavior_GWT$ReventlessGwt from "../src/Behavior_GWT.res.mjs";
+import * as Decision_GWT$ReventlessGwt from "../src/Decision_GWT.res.mjs";
 
 let name = "Shelve";
 
@@ -92,14 +92,14 @@ function decide(_state, command) {
   };
 }
 
-let ShelveSliceBehavior = {
+let ShelveSliceDecision = {
   Spec: undefined,
   initialState: undefined,
   evolve: evolve,
   decide: decide
 };
 
-let include = Behavior_GWT$ReventlessGwt.Make({
+let include = Decision_GWT$ReventlessGwt.Make({
   name: name,
   consumedEventSchema: consumedEventSchema,
   commandSchema: commandSchema,
@@ -126,7 +126,7 @@ let whenCmd = include.whenCmd;
 
 let thenEvent = include.thenEvent;
 
-let thenRefused = include.thenRefused;
+let thenForbidden = include.thenForbidden;
 
 let s1 = "s1";
 
@@ -145,19 +145,19 @@ describe("a command's rule, checked against the caller's roles", () => {
     TAG: "Done",
     shelfId: s1
   }));
-  test("refused for a signed-in caller holding none of them", () => thenRefused(whenCmd(asCaller(givenEvents([]), Caller.owner("c1", undefined)), {
+  test("refused for a signed-in caller holding none of them", () => thenForbidden(whenCmd(asCaller(givenEvents([]), Caller.owner("c1", undefined)), {
     TAG: "Shelve",
     shelfId: s1
   })));
-  test("refused for an anonymous caller", () => thenRefused(whenCmd(asCaller(givenEvents([]), Caller.anonymous), {
+  test("refused for an anonymous caller", () => thenForbidden(whenCmd(asCaller(givenEvents([]), Caller.anonymous), {
     TAG: "Shelve",
     shelfId: s1
   })));
-  test("refused for an operator, who holds no role", () => thenRefused(whenCmd(asCaller(givenEvents([]), Caller.operator), {
+  test("refused for an operator, who holds no role", () => thenForbidden(whenCmd(asCaller(givenEvents([]), Caller.operator), {
     TAG: "Shelve",
     shelfId: s1
   })));
-  test("DenyAll refuses every caller, Admin included", () => thenRefused(whenCmd(asCaller(givenEvents([]), Caller.inRoles(["Admin"])), {
+  test("DenyAll refuses every caller, Admin included", () => thenForbidden(whenCmd(asCaller(givenEvents([]), Caller.inRoles(["Admin"])), {
     TAG: "Purge",
     shelfId: s1
   })));
@@ -168,7 +168,7 @@ describe("a command's rule, checked against the caller's roles", () => {
     TAG: "Done",
     shelfId: s1
   }));
-  test("the default rule refuses an anonymous caller", () => thenRefused(whenCmd(asCaller(givenEvents([]), Caller.anonymous), {
+  test("the default rule refuses an anonymous caller", () => thenForbidden(whenCmd(asCaller(givenEvents([]), Caller.anonymous), {
     TAG: "Browse",
     shelfId: s1
   })));
@@ -247,7 +247,7 @@ function decide$1(_state, command) {
   };
 }
 
-let Claim = Behavior_GWT$ReventlessGwt.Make({
+let Claim = Decision_GWT$ReventlessGwt.Make({
   name: name$1,
   consumedEventSchema: consumedEventSchema$1,
   commandSchema: commandSchema$1,
@@ -274,11 +274,11 @@ describe("the rule, then ownership", () => {
     TAG: "Done",
     shelfId: s1
   }));
-  Claim.test("passing the rule does not let a caller act on someone else's thing", () => Claim.thenRefused(Claim.whenCmd(Claim.asCaller(Claim.givenEvents(claimedByC1), Claim.Caller.owner("c2", ["Merchandiser"])), {
+  Claim.test("passing the rule does not let a caller act on someone else's thing", () => Claim.thenForbidden(Claim.whenCmd(Claim.asCaller(Claim.givenEvents(claimedByC1), Claim.Caller.owner("c2", ["Merchandiser"])), {
     TAG: "Shelve",
     shelfId: s1
   })));
-  Claim.test("owning a thing does not pass a rule the owner fails", () => Claim.thenRefused(Claim.whenCmd(Claim.asCaller(Claim.givenEvents(claimedByC1), Claim.Caller.owner("c1", undefined)), {
+  Claim.test("owning a thing does not pass a rule the owner fails", () => Claim.thenForbidden(Claim.whenCmd(Claim.asCaller(Claim.givenEvents(claimedByC1), Claim.Caller.owner("c1", undefined)), {
     TAG: "Shelve",
     shelfId: s1
   })));
@@ -304,7 +304,7 @@ let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
 
 export {
   ShelveSlice,
-  ShelveSliceBehavior,
+  ShelveSliceDecision,
   Spec,
   describe,
   todo,
@@ -319,7 +319,7 @@ export {
   thenEventWithError,
   thenEventsWithError,
   thenError,
-  thenRefused,
+  thenForbidden,
   thenAppendsConditionedOn,
   thenAppendsConditionedOnExactly,
   s1,