@reventlessdev/reventless-aws 3.0.0-alpha.386 → 3.0.0-alpha.388

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

@@ -101,10 +101,10 @@ let dcbConfigRef = {
 
 let registeredSliceModulePaths = [];
 
-function registerStateChangeSliceSpec(specPath, behaviorPath) {
+function registerStateChangeSliceSpec(specPath, decisionPath) {
   registeredSliceModulePaths.push({
     specPath: specPath,
-    behaviorPath: behaviorPath
+    decisionPath: decisionPath
   });
 }
 
@@ -547,7 +547,7 @@ function Make(EventCollectorChannel) {
     let dcbConfig = dcbConfigRef.contents;
     let slicePaths = registeredSliceModulePaths.concat(dcbConfig.stateChangeSliceModulePaths).map(param => [
       param.specPath,
-      param.behaviorPath
+      param.decisionPath
     ]);
     let inboundSlices = Stdlib_Array.filterMap(Object.values(registeredInboundSlices), reg => {
       if (reg.specPath === "") {

package/src/plugin/stack/Plugin_Stack.res

@@ -524,7 +524,7 @@ let makeUiBundleDistribution = (
 
     // Auto-invalidate CloudFront once every object is (re)uploaded. Stable-named
     // entry files (index.html, the module-federation mf-entry-bootstrap-*.js)
-    // are served by the long-TTL default cache behaviour, so without this a
+    // are served by the long-TTL default cache behavior, so without this a
     // `pulumi up` lands the new bundle in S3 while CloudFront keeps serving the
     // prior build until its TTL expires. Chained on the upload etags so it runs
     // AFTER the new content is in S3; `/*` is a single invalidation path (well

package/src/util/Util_Bundle.res

@@ -254,7 +254,7 @@ type codeArchive = {
  *
  * `ReventlessCore.RuntimeExtension` carries `import.meta.url`s because that is
  * what an extension module can state about itself; the npm specifier a Lambda
- * resolves is derived here, the same conversion spec and behavior modules go
+ * resolves is derived here, the same conversion spec and decision modules go
  * through.
  */
 let runtimeExtensionSpecifiers = (): array<string> =>

package/src/util/Util_ShellConfig.res

@@ -81,7 +81,8 @@ let subscriptionEndpoint = (httpsEndpoint: string): string =>
 /**
 The config.json field set.
 
-`computed` arrives in wire order and keeps it. `viewModes` unset ⇒ no
+`computed` arrives in wire order and keeps it; `environment` follows it, its
+purpose key only when the purpose is known. `viewModes` unset ⇒ no
 `viewModes` key and no per-mode key, so a deployment that wants no optional mode
 gets byte-identical output to before this input existed. `bakedManifest` unset ⇒
 no `manifestUrl`, and every caller keeps the admin discovery path. `shellConfig`
@@ -91,6 +92,7 @@ somewhere unintended with nothing in the diff to say so.
 */
 let fields = (
   ~computed: array<(string, JSON.t)>,
+  ~environment: option<Reventless.ShellEnvironment.t>=?,
   ~viewModes: option<array<Platform.viewMode>>=?,
   ~bakedManifest: option<Platform.bakedManifest>=?,
   ~uiSlotsFile: option<string>=?,
@@ -98,6 +100,10 @@ let fields = (
 ): dict<JSON.t> => {
   let out = computed->Dict.fromArray
 
+  environment->Option.forEach(env =>
+    env->Reventless.ShellEnvironment.configFields->Array.forEach(((k, v)) => out->Dict.set(k, v))
+  )
+
   // Computed, like the endpoints: the group the admin API is gated on, from the
   // deploy's own role mapping.
   ReventlessCore.Platform_AdminGroup.configEntry()->Option.forEach(((k, v)) => out->Dict.set(k, v))

package/src/util/Util_ShellConfig.res.mjs

@@ -4,6 +4,7 @@ import * as Pervasives from "@rescript/runtime/lib/es6/Pervasives.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 Platform$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/Platform.res.mjs";
+import * as ShellEnvironment$Reventless from "@reventlessdev/reventless-spec/src/types/ShellEnvironment.res.mjs";
 import * as Platform_UiSlots$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_UiSlots.res.mjs";
 import * as Platform_AdminGroup$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_AdminGroup.res.mjs";
 import * as Platform_BakedManifest$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_BakedManifest.res.mjs";
@@ -58,8 +59,13 @@ function subscriptionEndpoint(httpsEndpoint) {
   return httpsEndpoint.replace("https://", "wss://").replace(".appsync-api.", ".appsync-realtime-api.");
 }
 
-function fields(computed, viewModes, bakedManifest, uiSlotsFile, shellConfig) {
+function fields(computed, environment, viewModes, bakedManifest, uiSlotsFile, shellConfig) {
   let out = Object.fromEntries(computed);
+  Stdlib_Option.forEach(environment, env => {
+    ShellEnvironment$Reventless.configFields(env).forEach(param => {
+      out[param[0]] = param[1];
+    });
+  });
   Stdlib_Option.forEach(Platform_AdminGroup$ReventlessCore.configEntry(), param => {
     out[param[0]] = param[1];
   });
@@ -107,4 +113,4 @@ export {
   subscriptionEndpoint,
   fields,
 }
-/* Platform_AdminGroup-ReventlessCore Not a pure module */
+/* ShellEnvironment-Reventless Not a pure module */

package/tests/AppSync_AdapterTest.res

@@ -330,7 +330,7 @@ describe("AppSync_Adapter.injectAwsAuth — Stage E2 permission lifting", () =>
   // and emitted the same group-less directive, which on this Cognito-primary
   // API means *any authenticated caller* — the inverse of the declaration. It
   // deployed green, passed `assertGateable`, and worked on the local platform,
-  // whose resolvers call `Authorization.isAllowed` and honour the rule. It
+  // whose resolvers call `Authorization.isAllowed` and honor the rule. It
   // failed closed, so no deployment ever reported it.
 
   let refuses = (run: unit => 'a): bool =>

package/tests/AppSync_RetirementNarrowingTest.res

@@ -192,7 +192,7 @@ describe("the by-index door's owner scoping", () => {
     )->Expect.toBe(true)
   )
 
-  // The generic argument loop turns an unrecognised arg into a `contains` filter.
+  // The generic argument loop turns an unrecognized arg into a `contains` filter.
   // `includeRetired` is a request to lift a restriction, and filtering on it
   // would match no row at all.
   testSync("never treats includeRetired as a column to match on", () =>

package/tests/AppSync_SdlDecorateTest.res

@@ -270,7 +270,7 @@ describe("AppSync_SdlDecorate.assertGateable", () => {
 
   // The original outage, exactly. A "does it have a directive?" check passes
   // this — @aws_auth was present on all 18 admin fields the whole time it was
-  // inert. Only knowing WHICH directive the service honours catches it.
+  // inert. Only knowing WHICH directive the service honors catches it.
   testSync("refuses @aws_auth, the directive AppSync ignores here", () => {
     let sdl = `type Query @aws_cognito_user_pools {\n  Admin_Thing: String @aws_auth(cognito_groups: ["Admin"])\n}`
     expect(refuses(sdl))->toBe(true)

package/tests/Auth_LoginIdentifierTest.res

@@ -1,7 +1,7 @@
 open JestGlobals
 
 // The sign-in attribute is the one pool setting no later deploy can correct, so
-// what these cover is the parse: absent must mean today's behaviour, and a
+// what these cover is the parse: absent must mean today's behavior, and a
 // spelling this build does not know must refuse rather than default.
 
 module LoginIdentifier = Auth_LoginIdentifier

package/tests/Auth_SignUpModeTest.res

@@ -2,7 +2,7 @@ open JestGlobals
 
 // Sign-up mode is correctable on a live pool, unlike the sign-in attribute, so
 // what these cover is not permanence but silence: absent must mean today's
-// behaviour, an unknown spelling must refuse rather than quietly close the pool,
+// behavior, an unknown spelling must refuse rather than quietly close the pool,
 // and the mapping onto Cognito's inverted field must not be readable backwards.
 
 module SignUpMode = Auth_SignUpMode

package/tests/BakeConvergenceTest.res

@@ -94,10 +94,10 @@ let row = (def: Reventless.Plugin.pluginDefinition, ~at: string): dict<JSON.t> =
   ->JSON.Decode.object
   ->Option.getOr(Dict.make())
 
-let apply = (state, events) => events->Array.reduce(state, ReventlessCore.PluginBehavior.evolve)
+let apply = (state, events) => events->Array.reduce(state, ReventlessCore.PluginDecision.evolve)
 
 let connect = (state, def) =>
-  switch ReventlessCore.PluginBehavior.decide(state, ReventlessCore.PluginSpec.Connect(def)) {
+  switch ReventlessCore.PluginDecision.decide(state, ReventlessCore.PluginSpec.Connect(def)) {
   | Ok(events) => events
   | Error(_) => []
   }
@@ -153,16 +153,16 @@ describe("the bake converges when a plugin's structure changes", () => {
   // unchanged one, so this is the step a broken chain silently skips.
   testSync("a redeploy with a changed structure re-emits VersionConnected", () => {
     let connected =
-      ReventlessCore.PluginBehavior.initialState->apply(
-        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      ReventlessCore.PluginDecision.initialState->apply(
+        connect(ReventlessCore.PluginDecision.initialState, shipped(defA)),
       )
     expect(connect(connected, shipped(defB))->Array.length)->toBe(1)
   })
 
   testSync("once it lands, the plugin reads as registered by this deploy", () => {
     let connected =
-      ReventlessCore.PluginBehavior.initialState->apply(
-        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      ReventlessCore.PluginDecision.initialState->apply(
+        connect(ReventlessCore.PluginDecision.initialState, shipped(defA)),
       )
     let redeployed = connected->apply(connect(connected, shipped(defB)))
     let def = switch redeployed.known->Dict.get("1.0.0") {
@@ -180,8 +180,8 @@ describe("the bake converges when a plugin's structure changes", () => {
   // counts it apart from a plugin that did register.
   testSync("an unchanged structure passes without re-registering", () => {
     let connected =
-      ReventlessCore.PluginBehavior.initialState->apply(
-        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      ReventlessCore.PluginDecision.initialState->apply(
+        connect(ReventlessCore.PluginDecision.initialState, shipped(defA)),
       )
     expect(connect(connected, shipped(defA)))->toEqual([])
     expect(
@@ -198,11 +198,11 @@ describe("the bake converges when a plugin's structure changes", () => {
   // and the changed structure never reaches the read model.
   testSync("a redeploy re-detects an already-connected version", () => {
     let connected =
-      ReventlessCore.PluginBehavior.initialState->apply(
-        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      ReventlessCore.PluginDecision.initialState->apply(
+        connect(ReventlessCore.PluginDecision.initialState, shipped(defA)),
       )
     expect(
-      ReventlessCore.PluginBehavior.decide(connected, ReventlessCore.PluginSpec.Redetect("1.0.0")),
+      ReventlessCore.PluginDecision.decide(connected, ReventlessCore.PluginSpec.Redetect("1.0.0")),
     )->toEqual(Ok([ReventlessCore.PluginSpec.VersionDetected("1.0.0")]))
   })
 })

package/tests/BakeConvergenceTest.res.mjs

@@ -6,7 +6,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
-import * as PluginBehavior$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
+import * as PluginDecision$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginDecision.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as PluginsProjection$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsProjection.res.mjs";
 import * as Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws from "../src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs";
@@ -97,11 +97,11 @@ function row(def, at) {
 }
 
 function apply(state, events) {
-  return Stdlib_Array.reduce(events, state, PluginBehavior$ReventlessCore.evolve);
+  return Stdlib_Array.reduce(events, state, PluginDecision$ReventlessCore.evolve);
 }
 
 function connect(state, def) {
-  let events = PluginBehavior$ReventlessCore.decide(state, {
+  let events = PluginDecision$ReventlessCore.decide(state, {
     TAG: "Connect",
     _0: def
   });
@@ -156,15 +156,15 @@ globalThis.describe("the bake converges when a plugin's structure changes", () =
       ]], deployedAt)).toEqual("behind");
   });
   globalThis.test("a redeploy with a changed structure re-emits VersionConnected", () => {
-    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
-    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    let events = connect(PluginDecision$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginDecision$ReventlessCore.initialState, PluginDecision$ReventlessCore.evolve);
     globalThis.expect(connect(connected, shipped(defB)).length).toBe(1);
   });
   globalThis.test("once it lands, the plugin reads as registered by this deploy", () => {
-    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
-    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    let events = connect(PluginDecision$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginDecision$ReventlessCore.initialState, PluginDecision$ReventlessCore.evolve);
     let events$1 = connect(connected, shipped(defB));
-    let redeployed = Stdlib_Array.reduce(events$1, connected, PluginBehavior$ReventlessCore.evolve);
+    let redeployed = Stdlib_Array.reduce(events$1, connected, PluginDecision$ReventlessCore.evolve);
     let match = redeployed.known["1.0.0"];
     let def = match !== undefined ? match.definition : shipped(defA);
     globalThis.expect(stateOf([row(def, afterDeploy)], [[
@@ -173,8 +173,8 @@ globalThis.describe("the bake converges when a plugin's structure changes", () =
       ]], deployedAt)).toEqual("registered");
   });
   globalThis.test("an unchanged structure passes without re-registering", () => {
-    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
-    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    let events = connect(PluginDecision$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginDecision$ReventlessCore.initialState, PluginDecision$ReventlessCore.evolve);
     globalThis.expect(connect(connected, shipped(defA))).toEqual([]);
     globalThis.expect(stateOf([row(shipped(defA), beforeDeploy)], [[
         "Ordering",
@@ -182,9 +182,9 @@ globalThis.describe("the bake converges when a plugin's structure changes", () =
       ]], deployedAt)).toEqual("unchanged");
   });
   globalThis.test("a redeploy re-detects an already-connected version", () => {
-    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
-    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
-    globalThis.expect(PluginBehavior$ReventlessCore.decide(connected, {
+    let events = connect(PluginDecision$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginDecision$ReventlessCore.initialState, PluginDecision$ReventlessCore.evolve);
+    globalThis.expect(PluginDecision$ReventlessCore.decide(connected, {
       TAG: "Redetect",
       _0: "1.0.0"
     })).toEqual({

package/tests/QueryDbResolvers_AppSyncTest.res

@@ -43,7 +43,7 @@ describe("AppSync_Resolver_Retrying.Functions.listAllItemsConnection", () => {
   )
 })
 
-// Tripwires for the Scan connection's paging. The behaviour itself is exercised
+// Tripwires for the Scan connection's paging. The behavior itself is exercised
 // against the evaluated resolver in `rescript/pulumi-aws`; these guard the wiring
 // this package is responsible for emitting.
 describe("listAllItemsConnection — paging", () => {

package/tests/Upload_ClaimTest.res

@@ -4,7 +4,7 @@
 // decided by three functions in `Upload_Claim_S3_Ops`: which table a record came
 // from, which refs a declared field holds, and whether a ref resolves to an
 // object this claimer may touch. The untag itself has no branching left in it,
-// so pinning these pins the behaviour that matters.
+// so pinning these pins the behavior that matters.
 //
 // The direction under test throughout is refusal. An untag this component
 // wrongly *skips* costs a delayed cleanup; one it wrongly *performs* removes the

package/tests/Util_AwsErrorTest.res

@@ -18,7 +18,7 @@ external throwAwsError: (string, string) => unit = "throwAwsError"
 
     🚨 **Thrown and caught, not constructed.** ReScript's `exn` for a JS error is
     the wrapper its own `catch` builds — a bare `Error` value is a different thing
-    and `JsExn.fromException` does not recognise it. A fixture that returned one
+    and `JsExn.fromException` does not recognize it. A fixture that returned one
     would make every predicate here look broken while the code was fine, which is
     exactly the wrong way round for a regression test. */
 let awsError = (~name: string, ~message: string): exn =>

package/tests/Util_ShellConfigTest.res

@@ -226,6 +226,46 @@ describe("Util_ShellConfig.fields — journeys", () => {
   })
 })
 
+// The shell badges every environment that is not production, so a purpose that
+// went missing shows as a badge rather than as nothing.
+describe("Util_ShellConfig.fields — environment", () => {
+  testSync("the name and the purpose follow the computed keys", () => {
+    let out = Util_ShellConfig.fields(~computed, ~environment={name: "test", purpose: Some("test")})
+    expect(out->Dict.keysToArray)->toEqual([
+      "apiEndpoint",
+      "region",
+      "environment",
+      "environmentPurpose",
+    ])
+    expect((out->get("environment"), out->get("environmentPurpose")))->toEqual((
+      JSON.Encode.string("test"),
+      JSON.Encode.string("test"),
+    ))
+  })
+
+  testSync("an unknown purpose leaves its key out", () => {
+    let out = Util_ShellConfig.fields(~computed, ~environment={name: "alpha", purpose: None})
+    expect(out->Dict.get("environmentPurpose")->Option.isNone)->toBe(true)
+  })
+
+  testSync("a shellConfig environment fails the deploy rather than renaming it", () => {
+    let failure = try {
+      let _ = Util_ShellConfig.fields(
+        ~computed,
+        ~environment={name: "prod", purpose: Some("production")},
+        ~shellConfig=Dict.fromArray([("environment", JSON.Encode.string("staging"))]),
+      )
+      None
+    } catch {
+    | Failure(message) => Some(message)
+    }
+    switch failure {
+    | Some(message) => expect(message->String.includes("environment"))->toBe(true)
+    | None => fail("a shellConfig key renaming the computed environment must fail the deploy")
+    }
+  })
+})
+
 describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
   testSync("shell-owned keys land verbatim, under the computed ones", () => {
     let out = Util_ShellConfig.fields(

package/tests/Util_ShellConfigTest.res.mjs

@@ -28,7 +28,7 @@ function get(out, key) {
 
 globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
   globalThis.test("unset ⇒ no viewModes key and the computed set is untouched", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, undefined);
     globalThis.expect(Object.keys(out)).toEqual([
       "apiEndpoint",
       "region"
@@ -36,7 +36,7 @@ globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
     globalThis.expect(Stdlib_Option.isNone(out["viewModes"])).toBe(true);
   });
   globalThis.test("Map with defaults ⇒ the mode, and no mapStyle key", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, [{
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, [{
         TAG: "Map",
         _0: {}
       }], undefined, undefined, undefined);
@@ -44,7 +44,7 @@ globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
     globalThis.expect(Stdlib_Option.isNone(out["mapStyle"])).toBe(true);
   });
   globalThis.test("per-mode options flatten beside the mode", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, [
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, [
       {
         TAG: "Map",
         _0: {
@@ -77,21 +77,21 @@ globalThis.describe("Util_ShellConfig.fields — bakedManifest", () => {
     key: key
   });
   globalThis.test("unset ⇒ no manifestUrl, so every caller keeps the admin path", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(out["manifestUrl"])).toBe(true);
   });
   globalThis.test("declared ⇒ the URL the deploy writes the file to", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake(undefined), undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, bake(undefined), undefined, undefined);
     globalThis.expect(get(out, "manifestUrl")).toEqual("/component-manifest.json");
   });
   globalThis.test("follows a renamed bake", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake("storefront.json"), undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, bake("storefront.json"), undefined, undefined);
     globalThis.expect(get(out, "manifestUrl")).toEqual("/storefront.json");
   });
   globalThis.test("a shellConfig manifestUrl fails the deploy rather than redirecting it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake(undefined), undefined, Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, bake(undefined), undefined, Object.fromEntries([[
           "manifestUrl",
           "/elsewhere.json"
         ]]));
@@ -115,21 +115,21 @@ globalThis.describe("Util_ShellConfig.fields — bakedManifest", () => {
 
 globalThis.describe("Util_ShellConfig.fields — uiSlotsFile", () => {
   globalThis.test("unset ⇒ no uiSlotsUrl, and the shell imports nothing", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(out["uiSlotsUrl"])).toBe(true);
   });
   globalThis.test("declared ⇒ the URL the deploy writes the module to", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, "/src/storefront-slots.js", undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, "/src/storefront-slots.js", undefined);
     globalThis.expect(get(out, "uiSlotsUrl")).toEqual("/ui-slots.js");
   });
   globalThis.test("names where the file is served, never where it was authored", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, "/home/me/prj/slots.js", undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, "/home/me/prj/slots.js", undefined);
     globalThis.expect(get(out, "uiSlotsUrl")).toEqual("/ui-slots.js");
   });
   globalThis.test("a shellConfig uiSlotsUrl fails the deploy rather than redirecting it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, "/src/storefront-slots.js", Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, "/src/storefront-slots.js", Object.fromEntries([[
           "uiSlotsUrl",
           "/elsewhere.js"
         ]]));
@@ -181,7 +181,7 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
     key: fulfilment_key
   };
   globalThis.test("a bake declaring no journeys writes no map", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, {
       components: [{
           plugin: "Catalog",
           views: ["Products"],
@@ -191,15 +191,15 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
     globalThis.expect(Stdlib_Option.isNone(out["journeyManifestUrls"])).toBe(true);
   });
   globalThis.test("an empty journeys array is the same as none", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([]), undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, withJourneys([]), undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(out["journeyManifestUrls"])).toBe(true);
   });
   globalThis.test("keeps manifestUrl as the default journey", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([shopper]), undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, withJourneys([shopper]), undefined, undefined);
     globalThis.expect(get(out, "manifestUrl")).toEqual("/component-manifest.json");
   });
   globalThis.test("maps each declared group to its own file", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, withJourneys([
       shopper,
       fulfilment
     ]), undefined, undefined);
@@ -219,14 +219,14 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
       shopper,
       fulfilment
     ]);
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, bake, undefined, undefined);
     let published = Stdlib_Option.mapOr(Stdlib_JSON.Decode.string(get(out, "manifestUrl")), [], url => [url]).concat(Stdlib_Array.filterMap(Object.values(Stdlib_Option.getOr(Stdlib_JSON.Decode.object(get(out, "journeyManifestUrls")), {})), Stdlib_JSON.Decode.string));
     globalThis.expect(published).toEqual(Platform_BakedManifest$ReventlessCore.files(bake).map(param => "/" + param[0]));
   });
   globalThis.test("a shellConfig journey map fails the deploy rather than redirecting it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([shopper]), undefined, Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, withJourneys([shopper]), undefined, Object.fromEntries([[
           "journeyManifestUrls",
           {}
         ]]));
@@ -248,9 +248,64 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
   });
 });
 
+globalThis.describe("Util_ShellConfig.fields — environment", () => {
+  globalThis.test("the name and the purpose follow the computed keys", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, {
+      name: "test",
+      purpose: "test"
+    }, undefined, undefined, undefined, undefined);
+    globalThis.expect(Object.keys(out)).toEqual([
+      "apiEndpoint",
+      "region",
+      "environment",
+      "environmentPurpose"
+    ]);
+    globalThis.expect([
+      get(out, "environment"),
+      get(out, "environmentPurpose")
+    ]).toEqual([
+      "test",
+      "test"
+    ]);
+  });
+  globalThis.test("an unknown purpose leaves its key out", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, {
+      name: "alpha",
+      purpose: undefined
+    }, undefined, undefined, undefined, undefined);
+    globalThis.expect(Stdlib_Option.isNone(out["environmentPurpose"])).toBe(true);
+  });
+  globalThis.test("a shellConfig environment fails the deploy rather than renaming it", () => {
+    let failure;
+    try {
+      Util_ShellConfig$ReventlessAws.fields(computed, {
+        name: "prod",
+        purpose: "production"
+      }, undefined, undefined, undefined, Object.fromEntries([[
+          "environment",
+          "staging"
+        ]]));
+      failure = undefined;
+    } catch (raw_message) {
+      let message = Primitive_exceptions.internalToException(raw_message);
+      if (message.RE_EXN_ID === "Failure") {
+        failure = message._1;
+      } else {
+        throw message;
+      }
+    }
+    if (failure !== undefined) {
+      globalThis.expect(failure.includes("environment")).toBe(true);
+      return;
+    } else {
+      return JestGlobals.fail("a shellConfig key renaming the computed environment must fail the deploy");
+    }
+  });
+});
+
 globalThis.describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
   globalThis.test("shell-owned keys land verbatim, under the computed ones", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, Object.fromEntries([
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, Object.fromEntries([
       [
         "platformName",
         "Online Shop"
@@ -271,7 +326,7 @@ globalThis.describe("Util_ShellConfig.fields — shellConfig passthrough", () =>
   globalThis.test("a key the deploy computes fails the deploy, naming it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, Object.fromEntries([[
           "apiEndpoint",
           "https://wrong.example/graphql"
         ]]));
@@ -345,7 +400,7 @@ globalThis.describe("the subscription endpoint", () => {
 globalThis.describe("Util_ShellConfig.fields — adminGroup", () => {
   globalThis.test("is absent while the administrator role keeps its own name", () => {
     Role$Reventless.clearGroups();
-    globalThis.expect(Stdlib_Option.isNone(Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined)["adminGroup"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, undefined)["adminGroup"])).toBe(true);
   });
   globalThis.test("carries the group a renamed administrator role maps to", () => {
     Role$Reventless.clearGroups();
@@ -353,7 +408,7 @@ globalThis.describe("Util_ShellConfig.fields — adminGroup", () => {
         Role$Reventless.admin,
         "shop-admins"
       ]]);
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined, undefined);
     Role$Reventless.clearGroups();
     globalThis.expect(get(out, "adminGroup")).toEqual("shop-admins");
   });

package/tests/Util_StoreLayoutTest.res

@@ -28,7 +28,7 @@ describe("Util_StoreLayout.layoutFor", () => {
   )
 
   // The accepted fail-open: a production stack whose name is not on the list
-  // gets the weaker layout silently. Asserted so the behaviour is a decision on
+  // gets the weaker layout silently. Asserted so the behavior is a decision on
   // record rather than a surprise, and so the config override is the documented
   // fix rather than a code change.
   testSync("an unlisted production name falls open to the shared layout", () =>

package/tests/dcbColdStartPartition.mjs

@@ -23,7 +23,7 @@ export async function invokeAfterFailedStartup() {
   process.on("unhandledRejection", onUnhandled);
   process.env.HANDLER_CONFIG = JSON.stringify({
     ...baseConfig,
-    stateChangeSliceModules: [{ spec: "cold-start-test/missing-spec.mjs", behavior: "cold-start-test/missing-behavior.mjs" }],
+    stateChangeSliceModules: [{ spec: "cold-start-test/missing-spec.mjs", decision: "cold-start-test/missing-decision.mjs" }],
   });
   try {
     const { handler } = await import(ENTRY);
@@ -51,12 +51,12 @@ export async function startWithUnresolvedSlice() {
   const { buildHandlersForConfig } = await import(ENTRY);
   const loadModule = async (specifier) => {
     if (specifier === "cold-start-test://spec") return await import("./DcbUnresolvedPartitionSlice.res.mjs");
-    if (specifier === "cold-start-test://behavior") return {};
+    if (specifier === "cold-start-test://decision") return {};
     throw new Error("unknown test specifier: " + specifier);
   };
   try {
     await buildHandlersForConfig(
-      { ...baseConfig, stateChangeSliceModules: [{ spec: "cold-start-test://spec", behavior: "cold-start-test://behavior" }] },
+      { ...baseConfig, stateChangeSliceModules: [{ spec: "cold-start-test://spec", decision: "cold-start-test://decision" }] },
       { loadModule },
     );
     return "started";

package/tests/integration/{AggTestAggregateBehavior.res → AggTestAggregateDecision.res}

@@ -1,4 +1,4 @@
-// Behavior pair for `AggTestAggregate`. Create-once / reject-on-seen.
+// Decision pair for `AggTestAggregate`. Create-once / reject-on-seen.
 
 type state = NotCreated | Active
 
@@ -15,4 +15,4 @@ let decide = (state, command: AggTestAggregate.command): result<
   | (NotCreated, Add({name})) => Ok([Added({name: name})])
   }
 
-let moduleUrl = "agg-test://AggTestAggregateBehavior"
+let moduleUrl = "agg-test://AggTestAggregateDecision"

package/tests/integration/{AggTestAggregateBehavior.res.mjs → AggTestAggregateDecision.res.mjs}

@@ -24,7 +24,7 @@ function decide(state, command) {
 
 let initialState = "NotCreated";
 
-let moduleUrl = "agg-test://AggTestAggregateBehavior";
+let moduleUrl = "agg-test://AggTestAggregateDecision";
 
 export {
   initialState,