@reventlessdev/reventless-local 3.0.0-alpha.290 → 3.0.0-alpha.292

package/src/ShellConfig.res

@@ -17,8 +17,9 @@
 // `pnpm install` that replaces the package directory costs one restart, because
 // the baseline is re-seeded from whatever the new package ships.
 //
-// One key is computed (`manifestUrl`, from the bake declaration — local knows
-// where it put the file); the rest are the deployment's own `shellConfig`,
+// The computed keys are the environment (always `local`), `manifestUrl` and the
+// journey map (from the bake declaration — local knows where it put the file),
+// `uiSlotsUrl` and `adminGroup`; the rest are the deployment's own `shellConfig`,
 // passed through verbatim. A `shellConfig` that names a computed key fails the
 // same way it does on AWS: a passthrough cannot redirect a key the platform
 // decides, and silently resolving it either way points the shell somewhere
@@ -41,7 +42,10 @@ let manifestUrlOf = (config: ReventlessInfra.Platform.bakedManifest): string =>
 // caller matching no declared group gets and what every existing deployment has.
 let journeyManifestsKey = "journeyManifestUrls"
 
+let environmentKeys = [Reventless.ShellEnvironment.nameKey, Reventless.ShellEnvironment.purposeKey]
+
 let computedKeys = [
+  ...environmentKeys,
   "manifestUrl",
   journeyManifestsKey,
   ReventlessCore.Platform_UiSlots.configKey,
@@ -60,7 +64,10 @@ let overlay = (
   ~uiSlotsFile: option<string>=?,
   ~shellConfig: option<dict<JSON.t>>,
 ): dict<JSON.t> => {
-  let out = Dict.make()
+  let out =
+    Reventless.ShellEnvironment.local
+    ->Reventless.ShellEnvironment.configFields
+    ->Dict.fromArray
 
   // `UiSlots` serves the module; this is what tells the shell to import it. The
   // two are separate writes to separate files, which is exactly why the name
@@ -120,23 +127,22 @@ let readObject = (~path: string, ~label: string): dict<JSON.t> =>
 /**
  Merge the overlay onto the shipped `config.json` in the host shell's `dist/`.
 
- A no-op when there is nothing to say and nothing was said before — a platform
- that declares neither a bake nor any `shellConfig` never touches the file, so
- its dev shell is byte-identical to one built before this module existed. Once
- either is declared the write happens or fails loudly, for the reason
- `BakedManifest.emit` gives: both failure modes it can hit are the deployment's
- own mistake, and both produce the same silent symptom if swallowed.
+ The environment keys are always written, so the shell can say it is local;
+ without the package they are dropped silently, since a platform nobody points a
+ browser at has nothing to badge. Anything declared beyond them is written or
+ fails loudly, for the reason `BakedManifest.emit` gives: both failure modes it
+ can hit are the deployment's own mistake, and both produce the same silent
+ symptom if swallowed.
  */
 let emit = (
   ~bakedManifest: option<ReventlessInfra.Platform.bakedManifest>,
   ~uiSlotsFile: option<string>=?,
   ~shellConfig: option<dict<JSON.t>>,
-  // Test seam. The baseline dance is the part of this module with state behind
-  // it — "boot twice and the second write still starts from the shipped file" is
-  // not a property a pure function can carry.
+  // The platform's chosen `assetsDir`; unset, the host-shell package's `dist/`.
   ~dir: option<string>=?,
 ) => {
   let overlay = overlay(~bakedManifest, ~uiSlotsFile?, ~shellConfig)
+  let declared = overlay->Dict.keysToArray->Array.filter(k => !(environmentKeys->Array.includes(k)))
 
   switch switch dir {
   | Some(_) as given => given
@@ -146,7 +152,7 @@ let emit = (
     // Nothing declared and no shell installed is the ordinary case for a
     // platform nobody points a browser at; only a declaration makes the missing
     // package an error, and then it is the same error the bake gives.
-    if overlay->Dict.keysToArray->Array.length > 0 {
+    if declared->Array.length > 0 {
       JsError.throwWithMessage(
         `host UI config.json: cannot resolve ${HostShellDist.package} from ${NodeProcess.cwd()} — ` ++
         `the local shell reads its config from that package's dist/, so declaring shell ` ++
@@ -157,29 +163,26 @@ let emit = (
     let path = NodePath.join([dir, fileName])
     let baselinePath = NodePath.join([dir, baselineFileName])
 
-    // Seeded only when there is an overlay to apply. A platform that declares
-    // nothing must not leave a `config.base.json` behind for the next one to
-    // read as authoritative.
-    if !NodeFs.existsSync(baselinePath) && overlay->Dict.keysToArray->Array.length > 0 {
-      if !NodeFs.existsSync(path) {
+    // The baseline is whatever `config.json` the directory held first: the
+    // shell's shipped file, or the app's own in a chosen `assetsDir`.
+    if !NodeFs.existsSync(baselinePath) {
+      if NodeFs.existsSync(path) {
+        NodeFs.writeFileSync(baselinePath, NodeFs.readFileSync(path))
+      } else if declared->Array.length > 0 {
         JsError.throwWithMessage(
-          `host UI config.json: ${HostShellDist.package} ships no ${fileName} at ${dir} — ` ++
+          `host UI config.json: there is no ${fileName} at ${dir} — ` ++
           `there is no baseline to overlay, so the shell would boot with only the keys ` ++ `declared here and none of the ones it expects.`,
         )
       }
-      NodeFs.writeFileSync(baselinePath, NodeFs.readFileSync(path))
     }
 
     if NodeFs.existsSync(baselinePath) {
       let merged = readObject(~path=baselinePath, ~label="config baseline")
       overlay->Dict.forEachWithKey((v, k) => merged->Dict.set(k, v))
       NodeFs.writeFileSync(path, JSON.stringify(merged->JSON.Encode.object, ~space=2))
-      let keys = overlay->Dict.keysToArray
       log.info(
         ~comp="ShellConfig",
-        keys->Array.length == 0
-          ? `restored ${fileName} from ${baselineFileName}: ${path}`
-          : `wrote ${fileName} with ${keys->Array.join(", ")}: ${path}`,
+        `wrote ${fileName} with ${overlay->Dict.keysToArray->Array.join(", ")}: ${path}`,
       )
     }
   }

package/src/ShellConfig.res.mjs

@@ -2,11 +2,13 @@
 
 import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
+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_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as ShellEnvironment$Reventless from "@reventlessdev/reventless-spec/src/types/ShellEnvironment.res.mjs";
 import * as HostShellDist$ReventlessLocal from "./HostShellDist.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";
@@ -24,15 +26,23 @@ function manifestUrlOf(config) {
 
 let journeyManifestsKey = "journeyManifestUrls";
 
-let computedKeys = [
-  "manifestUrl",
-  journeyManifestsKey,
-  Platform_UiSlots$ReventlessCore.configKey,
-  Platform_AdminGroup$ReventlessCore.configKey
+let environmentKeys = [
+  ShellEnvironment$Reventless.nameKey,
+  ShellEnvironment$Reventless.purposeKey
 ];
 
+let computedKeys = Belt_Array.concatMany([
+  environmentKeys,
+  [
+    "manifestUrl",
+    journeyManifestsKey,
+    Platform_UiSlots$ReventlessCore.configKey,
+    Platform_AdminGroup$ReventlessCore.configKey
+  ]
+]);
+
 function overlay(bakedManifest, uiSlotsFile, shellConfig) {
-  let out = {};
+  let out = Object.fromEntries(ShellEnvironment$Reventless.configFields(ShellEnvironment$Reventless.local));
   Stdlib_Option.forEach(uiSlotsFile, param => {
     out[Platform_UiSlots$ReventlessCore.configKey] = Platform_UiSlots$ReventlessCore.url;
   });
@@ -78,9 +88,10 @@ function readObject(path, label) {
 
 function emit(bakedManifest, uiSlotsFile, shellConfig, dir) {
   let overlay$1 = overlay(bakedManifest, uiSlotsFile, shellConfig);
+  let declared = Object.keys(overlay$1).filter(k => !environmentKeys.includes(k));
   let dir$1 = dir !== undefined ? dir : HostShellDist$ReventlessLocal.dir();
   if (dir$1 === undefined) {
-    if (Object.keys(overlay$1).length !== 0) {
+    if (declared.length !== 0) {
       return Stdlib_JsError.throwWithMessage(`host UI config.json: cannot resolve ` + HostShellDist$ReventlessLocal.$$package + ` from ` + process.cwd() + ` — the local shell reads its config from that package's dist/, so declaring shell config without the package installed would write nothing and leave the shell configured as it shipped.`);
     } else {
       return;
@@ -88,11 +99,12 @@ function emit(bakedManifest, uiSlotsFile, shellConfig, dir) {
   }
   let path = Nodepath.join(dir$1, fileName);
   let baselinePath = Nodepath.join(dir$1, baselineFileName);
-  if (!Nodefs.existsSync(baselinePath) && Object.keys(overlay$1).length !== 0) {
-    if (!Nodefs.existsSync(path)) {
-      Stdlib_JsError.throwWithMessage(`host UI config.json: ` + HostShellDist$ReventlessLocal.$$package + ` ships no ` + fileName + ` at ` + dir$1 + ` — there is no baseline to overlay, so the shell would boot with only the keys declared here and none of the ones it expects.`);
+  if (!Nodefs.existsSync(baselinePath)) {
+    if (Nodefs.existsSync(path)) {
+      Nodefs.writeFileSync(baselinePath, Nodefs.readFileSync(path, "utf8"), "utf8");
+    } else if (declared.length !== 0) {
+      Stdlib_JsError.throwWithMessage(`host UI config.json: there is no ` + fileName + ` at ` + dir$1 + ` — there is no baseline to overlay, so the shell would boot with only the keys declared here and none of the ones it expects.`);
     }
-    Nodefs.writeFileSync(baselinePath, Nodefs.readFileSync(path, "utf8"), "utf8");
   }
   if (!Nodefs.existsSync(baselinePath)) {
     return;
@@ -102,8 +114,7 @@ function emit(bakedManifest, uiSlotsFile, shellConfig, dir) {
     merged[k] = v;
   });
   Nodefs.writeFileSync(path, JSON.stringify(merged, undefined, 2), "utf8");
-  let keys = Object.keys(overlay$1);
-  log.info("ShellConfig", undefined, keys.length === 0 ? `restored ` + fileName + ` from ` + baselineFileName + `: ` + path : `wrote ` + fileName + ` with ` + keys.join(", ") + `: ` + path);
+  log.info("ShellConfig", undefined, `wrote ` + fileName + ` with ` + Object.keys(overlay$1).join(", ") + `: ` + path);
 }
 
 export {
@@ -112,6 +123,7 @@ export {
   baselineFileName,
   manifestUrlOf,
   journeyManifestsKey,
+  environmentKeys,
   computedKeys,
   overlay,
   readObject,

package/src/UiHints.res

@@ -12,7 +12,7 @@
 // withdrawn declaration leaves yesterday's hints in place with nothing in the
 // diff to explain them. Unlike `ShellConfig` there is no merge — AWS writes the
 // declared file verbatim, and layering a deployment's hints over the shell
-// package's demonstration hints would invent a third behaviour neither platform
+// package's demonstration hints would invent a third behavior neither platform
 // has.
 
 let log = ReventlessCore.Logger.fromEnv()
@@ -37,9 +37,8 @@ let baselineFileName = "ui-hints.base.json"
  */
 let emit = (
   ~uiHintsFile: option<string>,
-  // Test seam, as in `ShellConfig.emit`: the baseline dance is the part with
-  // state behind it, and "boot twice and the second write still starts from the
-  // shipped file" is not a property a pure function can carry.
+  // Where the file is served from: the platform's chosen `assetsDir`; unset, the
+  // host-shell package's `dist/`.
   ~dir: option<string>=?,
 ) => {
   // Read before anything is touched, so a bad declaration cannot leave the
@@ -125,8 +124,7 @@ let emit = (
  */
 let watch = (
   ~uiHintsFile: option<string>,
-  // The same seam `emit` takes, and threaded to it: a test has to be able to
-  // watch a file it wrote into a temp dir without a host-shell package on disk.
+  // The directory `emit` takes, threaded to it.
   ~dir: option<string>=?,
   ~onReload: unit => unit,
 ): option<NodeFs.watcher> =>

package/src/UiSlots.res

@@ -53,9 +53,8 @@ let fileName = ReventlessCore.Platform_UiSlots.fileName
  */
 let emit = (
   ~uiSlotsFile: option<string>,
-  // Test seam, as in `UiHints.emit`: the removal on withdrawal is the part with
-  // state behind it, and "declare, then withdraw, and the file is gone" is not a
-  // property a pure function can carry.
+  // Where the module is served from: the platform's chosen `assetsDir`; unset,
+  // the host-shell package's `dist/`.
   ~dir: option<string>=?,
 ) => {
   // Read before anything is touched, so a bad declaration cannot leave the

package/src/adapter/Auth/LocalAuth.res

@@ -113,7 +113,7 @@ module Login = {
   //      every ReScript rebuild, so a per-process secret logs the developer out
   //      several times an hour, mid-task, with a "reconnecting" spinner as the
   //      only explanation.
-  //   3. A random 32 bytes, per process — today's behaviour, kept for the run
+  //   3. A random 32 bytes, per process — today's behavior, kept for the run
   //      that has no `.reventless/` to write to.
   //
   // The directory is used but never created. Its presence is what distinguishes
@@ -389,7 +389,7 @@ let authenticate = async (ctx: ReventlessCore.Auth_Adapter.requestContext): Iden
       | None =>
         // No headers: in-memory mode defaults to defaultUser so local dev
         // against an AllowAuthenticated-defaulted backend "just works" without
-        // setting headers. Anonymous behaviour is reachable only by building
+        // setting headers. Anonymous behavior is reachable only by building
         // an Identity.anonymous explicitly in code.
         Authenticated(defaultUser)
       | Some(g) =>

package/src/adapter/Backend.res

@@ -1,6 +1,6 @@
 // Selects which storage backend the in-memory Platform uses.
 //
-// Memory   — pure in-memory dicts/refs, current default behaviour, wiped on restart.
+// Memory   — pure in-memory dicts/refs, current default behavior, wiped on restart.
 // Sqlite   — opt-in on-disk SQLite file via SqliteDriver. Survives process restart.
 //             resetOnStart=true wipes the file when the Platform is constructed.
 
@@ -41,7 +41,7 @@ let removeFileIfExists = (path: string) =>
   | _ => ()
   }
 
-// Parses REVENTLESS_LOCAL_BACKEND. Recognised forms:
+// Parses REVENTLESS_LOCAL_BACKEND. Recognized forms:
 //   sqlite:./local.db        — Sqlite backend, no reset on start
 //   sqlite:./local.db?reset  — Sqlite backend, wipes file at Platform.Make time
 //   memory                   — explicit Memory selector

package/src/adapter/LocalBus.res

@@ -117,7 +117,7 @@ module type T = {
   let registerQueryDbScan: (string, unit => array<JSON.t>) => unit
   let getQueryDbScan: string => option<unit => array<JSON.t>>
   // Stream variant: lazily creates a Stream from current storage contents.
-  // Used by LocalQueryEngine to honour ~limit via Stream.take without loading all items.
+  // Used by LocalQueryEngine to honor ~limit via Stream.take without loading all items.
   let registerQueryDbStream: (string, unit => Stream.t<JSON.t, string, unit>) => unit
   let getQueryDbStream: string => option<unit => Stream.t<JSON.t, string, unit>>
   // Indexed equality lookup: (field, value) → matching items. The SQLite backend

package/src/adapter/LocalUploadResolvers.res

@@ -1,6 +1,6 @@
 // Local upload resolver logic (route B), backed by `LocalObjectStore`. Shared by the
 // dev platform (`Platform.res` registers these on the domain server) and
-// `ServedBucketHttpTest`, so the mint/release behaviour has one definition.
+// `ServedBucketHttpTest`, so the mint/release behavior has one definition.
 //
 // The dev store has no identities and no clock, so release enforces only the *shape*
 // of the rule (key under a served prefix), not the identity/age conditions AWS applies

package/src/components/Aggregate_Builder.res

@@ -28,12 +28,12 @@ module MakeWithHooks = (
 
   module Make = (
     Spec: Reventless.Aggregate.Spec,
-    Behavior: Reventless.Behavior.T with module Spec := Spec,
+    Decision: Reventless.Decision.T with module Spec := Spec,
     EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
   ) => {
     include ReventlessCore.Aggregate_Builder.Make(
       Spec,
-      Behavior,
+      Decision,
       EventMappings,
       RuntimeEnvironment,
       CommandGeneratorResolvers_GraphQL,

package/src/components/Aggregate_Builder.res.mjs

@@ -56,8 +56,8 @@ function MakeWithHooks(Bus) {
     let AggregateRuntimeBuilder = LocalAggregateRuntime_Builder$ReventlessLocal.Make(Bus)({
       make: CommandTopicChannel.make
     })(EventCollectorChannel);
-    let Make = Spec => (Behavior => (EventMappings => {
-      let include = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+    let Make = Spec => (Decision => (EventMappings => {
+      let include = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
         mappings: EventMappings.mappings,
         counter: EventMappings.counter
       })({
@@ -105,8 +105,8 @@ function Make(Bus) {
   let AggregateRuntimeBuilder = LocalAggregateRuntime_Builder$ReventlessLocal.Make(Bus)({
     make: CommandTopicChannel.make
   })(EventCollectorChannel);
-  let Make$1 = Spec => (Behavior => (EventMappings => {
-    let include = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+  let Make$1 = Spec => (Decision => (EventMappings => {
+    let include = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
       mappings: EventMappings.mappings,
       counter: EventMappings.counter
     })({

package/src/components/DcbEventLog_Builder.res

@@ -4,7 +4,7 @@ module Make = (Bus: LocalBus.T) => {
   module EventTopicPublisher = LocalEventTopicPublisher.Make(Bus)
 
   // Use the backend-aware storage functor (as Platform does), not the plain
-  // module: the functor consults BackendState so a standalone DCB log honours
+  // module: the functor consults BackendState so a standalone DCB log honors
   // REVENTLESS_LOCAL_BACKEND=sqlite, and it registers the read with the Bus so
   // `Bus.getDcbEventLogRead` can see it. The plain module did neither — the log
   // silently stayed in memory under SQLite and was invisible to bus readers.

package/src/components/StateChangeSlice_Builder.res

@@ -2,11 +2,11 @@
 
 module Make = (
   Spec: Reventless.StateChangeSlice.Spec,
-  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+  Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec,
 ) => {
-  module Inner = ReventlessCore.StateChangeSlice_Builder.Make(Spec, Behavior)
+  module Inner = ReventlessCore.StateChangeSlice_Builder.Make(Spec, Decision)
   module Spec = Spec
-  module Behavior = Behavior
+  module Decision = Decision
   let isAsync = Inner.isAsync
   type component = Inner.component
   let make: (

package/src/components/StateChangeSlice_Builder.res.mjs

@@ -3,12 +3,12 @@
 import * as StateChangeSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Builder.res.mjs";
 
 function Make(Spec) {
-  return Behavior => {
-    let Inner = StateChangeSlice_Builder$ReventlessCore.Make(Spec)(Behavior);
+  return Decision => {
+    let Inner = StateChangeSlice_Builder$ReventlessCore.Make(Spec)(Decision);
     return {
       Inner: Inner,
       Spec: Spec,
-      Behavior: Behavior,
+      Decision: Decision,
       isAsync: Inner.isAsync,
       make: Inner.make
     };

package/src/reset/LocalSeedReset.res

@@ -552,7 +552,7 @@ let run = (~dbPath: option<string>=?): unit => {
           Console.log("Nothing to do.")
         } else {
           // Set at all ⇒ it is the answer, affirmative or not. Falling through to
-          // the prompt on an unrecognised value would ask for a TTY the runs this
+          // the prompt on an unrecognized value would ask for a TTY the runs this
           // variable exists for do not have, so `SEED_RESET_CONFIRM=no` would
           // throw where it plainly means "don't". Both arms read the reply
           // through one predicate, which is what keeps the typed `y` and the

package/tests/HostShellDistTest.res

@@ -0,0 +1,70 @@
+open JestGlobals
+
+// The one directory every local host-UI writer writes into. An app that composes
+// its own UI bundle names it as `assetsDir`, as on AWS; a writer that took a
+// second opinion would put its file where nothing serves it.
+
+let _ = TestRunner.setup()
+
+let tmpdir = prefix => NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), prefix]))
+
+// What the package's dist/ holds, so a test can say it was not touched. Empty
+// when the package is not installed where the test runs.
+let snapshot = () =>
+  HostShellDist.dir()
+  ->Option.filter(NodeFs.existsSync)
+  ->Option.mapOr([], dir =>
+    NodeFs.readdirSyncNames(dir, {})
+    ->Array.toSorted(String.compare)
+    ->Array.map(name => {
+      let path = NodePath.join([dir, name])
+      (name, NodeFs.statSync(path)->NodeFs.mtimeMs)
+    })
+  )
+
+describe("HostShellDist.resolve", () => {
+  testSync("is the package's dist/ when no directory is chosen", () =>
+    expect(HostShellDist.resolve(~assetsDir=None))->toEqual(HostShellDist.dir())
+  )
+
+  testSync("is the chosen directory, created when missing", () => {
+    let chosen = NodePath.join([tmpdir("reventless-assetsdir-"), "app", "dist"])
+    expect(HostShellDist.resolve(~assetsDir=Some(chosen)))->toEqual(Some(chosen))
+    expect(NodeFs.existsSync(chosen))->toBe(true)
+  })
+})
+
+describe("the local writers in a chosen assetsDir", () => {
+  testSync("all four write there and leave the package's dist/ alone", () => {
+    let before = snapshot()
+    let dir =
+      HostShellDist.resolve(
+        ~assetsDir=Some(NodePath.join([tmpdir("reventless-assetsdir-"), "ui"])),
+      )->Option.getOrThrow
+    // The app's own config.json is the baseline the overlay goes on.
+    NodeFs.writeFileSync(NodePath.join([dir, "config.json"]), `{"appName": "App"}`)
+    let source = name => {
+      let path = NodePath.join([tmpdir("reventless-assetsdir-src-"), name])
+      NodeFs.writeFileSync(
+        path,
+        name->String.endsWith(".json") ? "{}" : "export function register() {}",
+      )
+      path
+    }
+    let bake: ReventlessInfra.Platform.bakedManifest = {components: []}
+
+    ShellConfig.emit(~bakedManifest=Some(bake), ~shellConfig=None, ~dir)
+    UiHints.emit(~uiHintsFile=Some(source("ui-hints.json")), ~dir)
+    UiSlots.emit(~uiSlotsFile=Some(source("slots.js")), ~dir)
+    BakedManifest.emit(~structures=[], ~config=bake, ~dir)
+
+    expect(NodeFs.readdirSyncNames(dir, {})->Array.toSorted(String.compare))->toEqual([
+      "component-manifest.json",
+      "config.base.json",
+      "config.json",
+      "ui-hints.json",
+      "ui-slots.js",
+    ])
+    expect(snapshot())->toEqual(before)
+  })
+})

package/tests/HostShellDistTest.res.mjs

@@ -0,0 +1,75 @@
+// 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_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as UiHints$ReventlessLocal from "../src/UiHints.res.mjs";
+import * as UiSlots$ReventlessLocal from "../src/UiSlots.res.mjs";
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+import * as ShellConfig$ReventlessLocal from "../src/ShellConfig.res.mjs";
+import * as BakedManifest$ReventlessLocal from "../src/BakedManifest.res.mjs";
+import * as HostShellDist$ReventlessLocal from "../src/HostShellDist.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+function tmpdir(prefix) {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), prefix));
+}
+
+function snapshot() {
+  return Stdlib_Option.mapOr(Stdlib_Option.filter(HostShellDist$ReventlessLocal.dir(), prim => Nodefs.existsSync(prim)), [], dir => Nodefs.readdirSync(dir, {}).toSorted(Primitive_string.compare).map(name => {
+    let path = Nodepath.join(dir, name);
+    return [
+      name,
+      Nodefs.statSync(path).mtimeMs
+    ];
+  }));
+}
+
+globalThis.describe("HostShellDist.resolve", () => {
+  globalThis.test("is the package's dist/ when no directory is chosen", () => {
+    globalThis.expect(HostShellDist$ReventlessLocal.resolve(undefined)).toEqual(HostShellDist$ReventlessLocal.dir());
+  });
+  globalThis.test("is the chosen directory, created when missing", () => {
+    let chosen = Nodepath.join(tmpdir("reventless-assetsdir-"), "app", "dist");
+    globalThis.expect(HostShellDist$ReventlessLocal.resolve(chosen)).toEqual(chosen);
+    globalThis.expect(Nodefs.existsSync(chosen)).toBe(true);
+  });
+});
+
+globalThis.describe("the local writers in a chosen assetsDir", () => {
+  globalThis.test("all four write there and leave the package's dist/ alone", () => {
+    let before = snapshot();
+    let dir = Stdlib_Option.getOrThrow(HostShellDist$ReventlessLocal.resolve(Nodepath.join(tmpdir("reventless-assetsdir-"), "ui")), undefined);
+    Nodefs.writeFileSync(Nodepath.join(dir, "config.json"), `{"appName": "App"}`, "utf8");
+    let source = name => {
+      let path = Nodepath.join(tmpdir("reventless-assetsdir-src-"), name);
+      Nodefs.writeFileSync(path, name.endsWith(".json") ? "{}" : "export function register() {}", "utf8");
+      return path;
+    };
+    let bake_components = [];
+    let bake = {
+      components: bake_components
+    };
+    ShellConfig$ReventlessLocal.emit(bake, undefined, undefined, dir);
+    UiHints$ReventlessLocal.emit(source("ui-hints.json"), dir);
+    UiSlots$ReventlessLocal.emit(source("slots.js"), dir);
+    BakedManifest$ReventlessLocal.emit([], bake, dir);
+    globalThis.expect(Nodefs.readdirSync(dir, {}).toSorted(Primitive_string.compare)).toEqual([
+      "component-manifest.json",
+      "config.base.json",
+      "config.json",
+      "ui-hints.json",
+      "ui-slots.js"
+    ]);
+    globalThis.expect(snapshot()).toEqual(before);
+  });
+});
+
+export {
+  tmpdir,
+  snapshot,
+}
+/*  Not a pure module */

package/tests/ShellConfigTest.res

@@ -26,11 +26,35 @@ let threw = (f: unit => unit): bool =>
   }
 
 describe("ShellConfig.overlay", () => {
-  testSync("is empty when the deployment declares nothing", () => {
+  testSync("carries only the environment when the deployment declares nothing", () => {
     let out = ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)
-    expect(out->Dict.keysToArray)->toEqual([])
+    expect(out->Dict.keysToArray)->toEqual(["environment", "environmentPurpose"])
   })
 
+  // The shell badges everything that is not production; locally it says so.
+  testSync("names the environment and its purpose local", () => {
+    let out = ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)
+    expect((out->str("environment"), out->str("environmentPurpose")))->toEqual((
+      Some("local"),
+      Some("local"),
+    ))
+  })
+
+  testSync("refuses a shellConfig naming either environment key", () =>
+    expect(
+      ["environment", "environmentPurpose"]->Array.map(
+        key =>
+          threw(
+            () =>
+              ShellConfig.overlay(
+                ~bakedManifest=None,
+                ~shellConfig=Some(Dict.fromArray([(key, JSON.Encode.string("prod"))])),
+              )->ignore,
+          ),
+      ),
+    )->toEqual([true, true])
+  )
+
   testSync("points manifestUrl at the bake's default key", () => {
     let out = ShellConfig.overlay(~bakedManifest=Some(manifest()), ~shellConfig=None)
     expect(out->str("manifestUrl"))->toEqual(Some("/component-manifest.json"))
@@ -147,11 +171,25 @@ describe("ShellConfig.emit", () => {
     expect(out->str("apiEndpoint"))->toEqual(Some("/graphql"))
   })
 
-  testSync("leaves a platform that declares nothing entirely alone", () => {
+  testSync("adds only the environment for a platform that declares nothing", () => {
     let dir = distWithConfig()
     ShellConfig.emit(~bakedManifest=None, ~shellConfig=None, ~dir)
-    expect(NodeFs.readFileSync(NodePath.join([dir, "config.json"])))->toEqual(shipped)
-    expect(NodeFs.existsSync(NodePath.join([dir, "config.base.json"])))->toBe(false)
+    let out = readConfig(dir)
+    expect(out->Dict.keysToArray)->toEqual([
+      "apiEndpoint",
+      "appName",
+      "environment",
+      "environmentPurpose",
+    ])
+    expect(readBaseline(dir)->str("appName"))->toEqual(Some("Shipped"))
+  })
+
+  // The environment alone is no declaration: a directory with no config.json to
+  // overlay is left as it is rather than refused.
+  testSync("writes nothing and refuses nothing when only the environment has no baseline", () => {
+    let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-shellconfig-"]))
+    ShellConfig.emit(~bakedManifest=None, ~shellConfig=None, ~dir)
+    expect(NodeFs.readdirSyncNames(dir, {}))->toEqual([])
   })
 
   // The whole reason a baseline is kept: boot 2 overlaying boot 1's output would
@@ -273,8 +311,8 @@ describe("ShellConfig.overlay — adminGroup", () => {
   testSync("is absent while the administrator role keeps its own name", () => {
     Reventless.Role.clearGroups()
     expect(
-      ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)->Dict.keysToArray,
-    )->toEqual([])
+      ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)->Dict.get("adminGroup"),
+    )->toEqual(None)
   })
 
   testSync("carries the group a renamed administrator role maps to", () => {