@reventlessdev/reventless-local 3.0.0-alpha.216 → 3.0.0-alpha.218

package/tests/ShellConfigTest.res

@@ -0,0 +1,221 @@
+open JestGlobals
+
+// The `config.json` overlay the local platform puts on the host shell's shipped
+// file. Two things are under test and they fail differently: the key set (what a
+// deployment's declaration turns into) and the baseline (what makes a second
+// boot, and a *withdrawn* declaration, land where they should). Every failure
+// here is silent at the point it happens and loud a long way away — a shell that
+// boots with the wrong surface, or none.
+
+let _ = TestRunner.setup()
+
+let manifest = (~key: option<string>=?): ReventlessInfra.Platform.bakedManifest => {
+  components: [{plugin: "Catalog", views: ["Products"], commands: []}],
+  key: ?key,
+}
+
+let str = (d: dict<JSON.t>, k: string): option<string> =>
+  d->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+
+let threw = (f: unit => unit): bool =>
+  try {
+    f()
+    false
+  } catch {
+  | _ => true
+  }
+
+describe("ShellConfig.overlay", () => {
+  testSync("is empty when the deployment declares nothing", () => {
+    let out = ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)
+    expect(out->Dict.keysToArray)->toEqual([])
+  })
+
+  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"))
+  })
+
+  // The key and the URL are one string: the bake writes to the dist root, which
+  // is also the shell's URL root. A renamed file that kept the default URL would
+  // 404 on a shell that has no admin API to fall back to.
+  testSync("follows a renamed bake", () => {
+    let out = ShellConfig.overlay(
+      ~bakedManifest=Some(manifest(~key="storefront.json")),
+      ~shellConfig=None,
+    )
+    expect(out->str("manifestUrl"))->toEqual(Some("/storefront.json"))
+  })
+
+  testSync("passes the deployment's own keys through verbatim", () => {
+    let out = ShellConfig.overlay(
+      ~bakedManifest=None,
+      ~shellConfig=Some(
+        Dict.fromArray([
+          ("appName", JSON.Encode.string("Online Shop")),
+          ("elevatedGroups", ["Admin"]->Array.map(JSON.Encode.string)->JSON.Encode.array),
+        ]),
+      ),
+    )
+    expect(out->str("appName"))->toEqual(Some("Online Shop"))
+    expect(out->Dict.get("elevatedGroups")->Option.isSome)->toBe(true)
+  })
+
+  // Silently resolving it either way points the shell at a manifest the platform
+  // did not write, with nothing in the diff to say so.
+  testSync("refuses a shellConfig key the platform computes", () =>
+    expect(
+      threw(() =>
+        ShellConfig.overlay(
+          ~bakedManifest=Some(manifest()),
+          ~shellConfig=Some(
+            Dict.fromArray([("manifestUrl", JSON.Encode.string("/elsewhere.json"))]),
+          ),
+        )->ignore
+      ),
+    )->toBe(true)
+  )
+})
+
+describe("ShellConfig.emit", () => {
+  let shipped = `{\n  "apiEndpoint": "/graphql",\n  "appName": "Shipped"\n}`
+
+  let distWithConfig = () => {
+    let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-shellconfig-"]))
+    NodeFs.writeFileSync(NodePath.join([dir, "config.json"]), shipped)
+    dir
+  }
+
+  let readJson = (path: string): dict<JSON.t> =>
+    NodeFs.readFileSync(path)->JSON.parseOrThrow->JSON.Decode.object->Option.getOrThrow
+
+  let readConfig = (dir: string) => readJson(NodePath.join([dir, "config.json"]))
+  let readBaseline = (dir: string) => readJson(NodePath.join([dir, "config.base.json"]))
+
+  let named = name => Some(Dict.fromArray([("appName", JSON.Encode.string(name))]))
+
+  testSync("merges the overlay onto the shipped file and keeps its other keys", () => {
+    let dir = distWithConfig()
+    ShellConfig.emit(~bakedManifest=Some(manifest()), ~shellConfig=None, ~dir)
+    let out = readConfig(dir)
+    expect(out->str("manifestUrl"))->toEqual(Some("/component-manifest.json"))
+    expect(out->str("apiEndpoint"))->toEqual(Some("/graphql"))
+  })
+
+  testSync("leaves a platform that declares nothing entirely alone", () => {
+    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)
+  })
+
+  // The whole reason a baseline is kept: boot 2 overlaying boot 1's output would
+  // read `appName: "First"` as shipped and carry it forever.
+  testSync("starts every boot from the shipped file, not the last output", () => {
+    let dir = distWithConfig()
+    ShellConfig.emit(~bakedManifest=None, ~shellConfig=named("First"), ~dir)
+    ShellConfig.emit(~bakedManifest=None, ~shellConfig=named("Second"), ~dir)
+    expect(readConfig(dir)->str("appName"))->toEqual(Some("Second"))
+    expect(readBaseline(dir)->str("appName"))->toEqual(Some("Shipped"))
+  })
+
+  // Withdrawing a declaration has to be as reachable as making it: a lingering
+  // manifestUrl points the shell at a file nothing writes any more, and the
+  // symptom is an empty shop.
+  testSync("restores the shipped file once the declaration is withdrawn", () => {
+    let dir = distWithConfig()
+    ShellConfig.emit(~bakedManifest=Some(manifest()), ~shellConfig=None, ~dir)
+    ShellConfig.emit(~bakedManifest=None, ~shellConfig=None, ~dir)
+    let out = readConfig(dir)
+    expect(out->Dict.get("manifestUrl"))->toEqual(None)
+    expect(out->str("appName"))->toEqual(Some("Shipped"))
+  })
+
+  // Writing only the declared keys would boot a shell with no apiEndpoint, and
+  // that failure surfaces nowhere near here.
+  testSync("refuses to overlay a dist that ships no config.json", () => {
+    let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-shellconfig-"]))
+    expect(
+      threw(() => ShellConfig.emit(~bakedManifest=Some(manifest()), ~shellConfig=None, ~dir)),
+    )->toBe(true)
+  })
+})
+
+// ── Journeys ──────────────────────────────────────────────────────────────
+//
+// One curated surface per audience, beside the default one. The property under
+// test throughout is that a deployment declaring none is untouched: journeys are
+// what a shop with several audiences opts into, and every existing deployment
+// has exactly one.
+
+let withJourneys = (
+  ~journeys: array<ReventlessInfra.Platform.bakedJourney>,
+): ReventlessInfra.Platform.bakedManifest => {
+  components: [{plugin: "Catalog", views: ["Products"], commands: []}],
+  journeys,
+}
+
+let shopper: ReventlessInfra.Platform.bakedJourney = {
+  group: "Shopper",
+  components: [{plugin: "Catalog", views: ["Products"], commands: []}],
+}
+
+let fulfilment: ReventlessInfra.Platform.bakedJourney = {
+  group: "Fulfilment",
+  components: [{plugin: "Ordering", views: ["Orders"], commands: ["ShipOrder"]}],
+  key: "fulfilment.json",
+}
+
+describe("ShellConfig.overlay — journeys", () => {
+  open Expect
+
+  // The regression line. A shell that has never heard of journeys must not
+  // suddenly find a key it does not know.
+  testSync("a bake declaring no journeys writes no map", () => {
+    let out = ShellConfig.overlay(~bakedManifest=Some(manifest()), ~shellConfig=None)
+    expect(out->Dict.get("journeyManifestUrls"))->toEqual(None)
+  })
+
+  testSync("an empty journeys array is the same as none", () => {
+    let out = ShellConfig.overlay(~bakedManifest=Some(withJourneys(~journeys=[])), ~shellConfig=None)
+    expect(out->Dict.get("journeyManifestUrls"))->toEqual(None)
+  })
+
+  // The default journey keeps `manifestUrl`, so a caller matching no declared
+  // group lands where every caller landed before.
+  testSync("keeps manifestUrl as the default journey", () => {
+    let out = ShellConfig.overlay(
+      ~bakedManifest=Some(withJourneys(~journeys=[shopper])),
+      ~shellConfig=None,
+    )
+    expect(out->str("manifestUrl"))->toEqual(Some("/component-manifest.json"))
+  })
+
+  testSync("maps each declared group to its own file", () => {
+    let out = ShellConfig.overlay(
+      ~bakedManifest=Some(withJourneys(~journeys=[shopper, fulfilment])),
+      ~shellConfig=None,
+    )
+    let map =
+      out->Dict.get("journeyManifestUrls")->Option.flatMap(JSON.Decode.object)->Option.getOrThrow
+    expect((map->str("Shopper"), map->str("Fulfilment")))->toEqual((
+      // Derived from the group, lower-cased, because a key is part of a URL.
+      Some("/component-manifest-shopper.json"),
+      // Named explicitly, and the declaration wins.
+      Some("/fulfilment.json"),
+    ))
+  })
+
+  // A passthrough cannot redirect a key the platform computes — the same rule
+  // `manifestUrl` already carries, extended to the map it now writes beside it.
+  testSync("refuses a shellConfig that sets the journey map itself", () =>
+    expect(
+      threw(() =>
+        ShellConfig.overlay(
+          ~bakedManifest=Some(withJourneys(~journeys=[shopper])),
+          ~shellConfig=Some(Dict.fromArray([("journeyManifestUrls", JSON.Encode.object(Dict.make()))])),
+        )->ignore
+      ),
+    )->toBe(true)
+  )
+})

package/tests/ShellConfigTest.res.mjs

@@ -0,0 +1,203 @@
+// 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_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+import * as ShellConfig$ReventlessLocal from "../src/ShellConfig.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+function manifest(key) {
+  return {
+    components: [{
+        plugin: "Catalog",
+        views: ["Products"],
+        commands: []
+      }],
+    key: key
+  };
+}
+
+function str(d, k) {
+  return Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.string);
+}
+
+function threw(f) {
+  try {
+    f();
+    return false;
+  } catch (exn) {
+    return true;
+  }
+}
+
+globalThis.describe("ShellConfig.overlay", () => {
+  globalThis.test("is empty when the deployment declares nothing", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, undefined);
+    globalThis.expect(Object.keys(out)).toEqual([]);
+  });
+  globalThis.test("points manifestUrl at the bake's default key", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(manifest(undefined), undefined);
+    globalThis.expect(str(out, "manifestUrl")).toEqual("/component-manifest.json");
+  });
+  globalThis.test("follows a renamed bake", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(manifest("storefront.json"), undefined);
+    globalThis.expect(str(out, "manifestUrl")).toEqual("/storefront.json");
+  });
+  globalThis.test("passes the deployment's own keys through verbatim", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, Object.fromEntries([
+      [
+        "appName",
+        "Online Shop"
+      ],
+      [
+        "elevatedGroups",
+        ["Admin"].map(prim => prim)
+      ]
+    ]));
+    globalThis.expect(str(out, "appName")).toEqual("Online Shop");
+    globalThis.expect(Stdlib_Option.isSome(out["elevatedGroups"])).toBe(true);
+  });
+  globalThis.test("refuses a shellConfig key the platform computes", () => {
+    globalThis.expect(threw(() => {
+      ShellConfig$ReventlessLocal.overlay(manifest(undefined), Object.fromEntries([[
+          "manifestUrl",
+          "/elsewhere.json"
+        ]]));
+    })).toBe(true);
+  });
+});
+
+globalThis.describe("ShellConfig.emit", () => {
+  let shipped = `{\n  "apiEndpoint": "/graphql",\n  "appName": "Shipped"\n}`;
+  let distWithConfig = () => {
+    let dir = Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-shellconfig-"));
+    Nodefs.writeFileSync(Nodepath.join(dir, "config.json"), shipped, "utf8");
+    return dir;
+  };
+  let readJson = path => Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(path, "utf8"))), undefined);
+  let readConfig = dir => readJson(Nodepath.join(dir, "config.json"));
+  let readBaseline = dir => readJson(Nodepath.join(dir, "config.base.json"));
+  let named = name => Object.fromEntries([[
+      "appName",
+      name
+    ]]);
+  globalThis.test("merges the overlay onto the shipped file and keeps its other keys", () => {
+    let dir = distWithConfig();
+    ShellConfig$ReventlessLocal.emit(manifest(undefined), undefined, dir);
+    let out = readConfig(dir);
+    globalThis.expect(str(out, "manifestUrl")).toEqual("/component-manifest.json");
+    globalThis.expect(str(out, "apiEndpoint")).toEqual("/graphql");
+  });
+  globalThis.test("leaves a platform that declares nothing entirely alone", () => {
+    let dir = distWithConfig();
+    ShellConfig$ReventlessLocal.emit(undefined, undefined, dir);
+    globalThis.expect(Nodefs.readFileSync(Nodepath.join(dir, "config.json"), "utf8")).toEqual(shipped);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(dir, "config.base.json"))).toBe(false);
+  });
+  globalThis.test("starts every boot from the shipped file, not the last output", () => {
+    let dir = distWithConfig();
+    ShellConfig$ReventlessLocal.emit(undefined, named("First"), dir);
+    ShellConfig$ReventlessLocal.emit(undefined, named("Second"), dir);
+    globalThis.expect(str(readConfig(dir), "appName")).toEqual("Second");
+    globalThis.expect(str(readBaseline(dir), "appName")).toEqual("Shipped");
+  });
+  globalThis.test("restores the shipped file once the declaration is withdrawn", () => {
+    let dir = distWithConfig();
+    ShellConfig$ReventlessLocal.emit(manifest(undefined), undefined, dir);
+    ShellConfig$ReventlessLocal.emit(undefined, undefined, dir);
+    let out = readConfig(dir);
+    globalThis.expect(out["manifestUrl"]).toEqual(undefined);
+    globalThis.expect(str(out, "appName")).toEqual("Shipped");
+  });
+  globalThis.test("refuses to overlay a dist that ships no config.json", () => {
+    let dir = Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-shellconfig-"));
+    globalThis.expect(threw(() => ShellConfig$ReventlessLocal.emit(manifest(undefined), undefined, dir))).toBe(true);
+  });
+});
+
+function withJourneys(journeys) {
+  return {
+    components: [{
+        plugin: "Catalog",
+        views: ["Products"],
+        commands: []
+      }],
+    journeys: journeys
+  };
+}
+
+let shopper_components = [{
+    plugin: "Catalog",
+    views: ["Products"],
+    commands: []
+  }];
+
+let shopper = {
+  group: "Shopper",
+  components: shopper_components
+};
+
+let fulfilment_components = [{
+    plugin: "Ordering",
+    views: ["Orders"],
+    commands: ["ShipOrder"]
+  }];
+
+let fulfilment_key = "fulfilment.json";
+
+let fulfilment = {
+  group: "Fulfilment",
+  components: fulfilment_components,
+  key: fulfilment_key
+};
+
+globalThis.describe("ShellConfig.overlay — journeys", () => {
+  globalThis.test("a bake declaring no journeys writes no map", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(manifest(undefined), undefined);
+    globalThis.expect(out["journeyManifestUrls"]).toEqual(undefined);
+  });
+  globalThis.test("an empty journeys array is the same as none", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(withJourneys([]), undefined);
+    globalThis.expect(out["journeyManifestUrls"]).toEqual(undefined);
+  });
+  globalThis.test("keeps manifestUrl as the default journey", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(withJourneys([shopper]), undefined);
+    globalThis.expect(str(out, "manifestUrl")).toEqual("/component-manifest.json");
+  });
+  globalThis.test("maps each declared group to its own file", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(withJourneys([
+      shopper,
+      fulfilment
+    ]), undefined);
+    let map = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(out["journeyManifestUrls"], Stdlib_JSON.Decode.object), undefined);
+    globalThis.expect([
+      str(map, "Shopper"),
+      str(map, "Fulfilment")
+    ]).toEqual([
+      "/component-manifest-shopper.json",
+      "/fulfilment.json"
+    ]);
+  });
+  globalThis.test("refuses a shellConfig that sets the journey map itself", () => {
+    globalThis.expect(threw(() => {
+      ShellConfig$ReventlessLocal.overlay(withJourneys([shopper]), Object.fromEntries([[
+          "journeyManifestUrls",
+          {}
+        ]]));
+    })).toBe(true);
+  });
+});
+
+export {
+  manifest,
+  str,
+  threw,
+  withJourneys,
+  shopper,
+  fulfilment,
+}
+/*  Not a pure module */

package/tests/UiHintsTest.res

@@ -0,0 +1,94 @@
+open JestGlobals
+
+// The `ui-hints.json` the local platform serves. Two things are under test:
+// which file wins (the declaration or the host-shell package's own dev-mode
+// fallback), and the baseline that makes a second boot — and a *withdrawn*
+// declaration — land where they should. Every failure here is quiet: hints are
+// presentation, so the symptom is a menu that reads slightly wrong.
+
+let _ = TestRunner.setup()
+
+let shipped = `{"Catalog": {"views": {"Products": {"nav": {"label": "Shipped"}}}}}`
+let declared = `{"Catalog": {"views": {"Products": {"nav": {"label": "Declared"}}}}}`
+
+let tmpdir = prefix => NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), prefix]))
+
+let distWithHints = () => {
+  let dir = tmpdir("reventless-uihints-dist-")
+  NodeFs.writeFileSync(NodePath.join([dir, "ui-hints.json"]), shipped)
+  dir
+}
+
+let declaredFile = (contents: string) => {
+  let path = NodePath.join([tmpdir("reventless-uihints-src-"), "ui-hints.json"])
+  NodeFs.writeFileSync(path, contents)
+  path
+}
+
+let served = (dir: string) => NodeFs.readFileSync(NodePath.join([dir, "ui-hints.json"]))
+let baselinePath = (dir: string) => NodePath.join([dir, "ui-hints.base.json"])
+
+let threw = (f: unit => unit): bool =>
+  try {
+    f()
+    false
+  } catch {
+  | _ => true
+  }
+
+describe("UiHints.emit", () => {
+  testSync("serves the declared file verbatim", () => {
+    let dir = distWithHints()
+    UiHints.emit(~uiHintsFile=Some(declaredFile(declared)), ~dir)
+    expect(served(dir))->toEqual(declared)
+  })
+
+  // An undeclared platform has to be byte-identical to one built before this
+  // module existed, or every shell repo demonstration breaks to fix a problem
+  // it does not have.
+  testSync("leaves a platform that declares nothing entirely alone", () => {
+    let dir = distWithHints()
+    UiHints.emit(~uiHintsFile=None, ~dir)
+    expect(served(dir))->toEqual(shipped)
+    expect(NodeFs.existsSync(baselinePath(dir)))->toBe(false)
+  })
+
+  // Boot 2 seeding its baseline from boot 1's output would freeze the first
+  // declaration in as "shipped" and make the withdrawal below unreachable.
+  testSync("starts every boot from the shipped file, not the last output", () => {
+    let dir = distWithHints()
+    UiHints.emit(~uiHintsFile=Some(declaredFile(declared)), ~dir)
+    UiHints.emit(~uiHintsFile=Some(declaredFile(shipped)), ~dir)
+    expect(NodeFs.readFileSync(baselinePath(dir)))->toEqual(shipped)
+  })
+
+  testSync("restores the shipped file once the declaration is withdrawn", () => {
+    let dir = distWithHints()
+    UiHints.emit(~uiHintsFile=Some(declaredFile(declared)), ~dir)
+    UiHints.emit(~uiHintsFile=None, ~dir)
+    expect(served(dir))->toEqual(shipped)
+  })
+
+  // All three failures below produce the same symptom if swallowed — hints that
+  // quietly are not applied — so each has to be the boot's problem, not the
+  // reader's.
+  testSync("refuses a declaration naming a file that does not exist", () => {
+    let dir = distWithHints()
+    let missing = NodePath.join([tmpdir("reventless-uihints-src-"), "absent.json"])
+    expect(threw(() => UiHints.emit(~uiHintsFile=Some(missing), ~dir)))->toBe(true)
+  })
+
+  testSync("refuses a declared file that is not JSON", () => {
+    let dir = distWithHints()
+    expect(threw(() => UiHints.emit(~uiHintsFile=Some(declaredFile("not json")), ~dir)))->toBe(true)
+  })
+
+  // Read before anything is touched: a bad declaration must not leave the
+  // served file half-replaced, which would be worse than either outcome.
+  testSync("leaves the served file untouched when the declaration is bad", () => {
+    let dir = distWithHints()
+    let _ = threw(() => UiHints.emit(~uiHintsFile=Some(declaredFile("not json")), ~dir))
+    expect(served(dir))->toEqual(shipped)
+    expect(NodeFs.existsSync(baselinePath(dir)))->toBe(false)
+  })
+})

package/tests/UiHintsTest.res.mjs

@@ -0,0 +1,99 @@
+// 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 UiHints$ReventlessLocal from "../src/UiHints.res.mjs";
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let shipped = `{"Catalog": {"views": {"Products": {"nav": {"label": "Shipped"}}}}}`;
+
+let declared = `{"Catalog": {"views": {"Products": {"nav": {"label": "Declared"}}}}}`;
+
+function tmpdir(prefix) {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), prefix));
+}
+
+function distWithHints() {
+  let dir = tmpdir("reventless-uihints-dist-");
+  Nodefs.writeFileSync(Nodepath.join(dir, "ui-hints.json"), shipped, "utf8");
+  return dir;
+}
+
+function declaredFile(contents) {
+  let path = Nodepath.join(tmpdir("reventless-uihints-src-"), "ui-hints.json");
+  Nodefs.writeFileSync(path, contents, "utf8");
+  return path;
+}
+
+function served(dir) {
+  return Nodefs.readFileSync(Nodepath.join(dir, "ui-hints.json"), "utf8");
+}
+
+function baselinePath(dir) {
+  return Nodepath.join(dir, "ui-hints.base.json");
+}
+
+function threw(f) {
+  try {
+    f();
+    return false;
+  } catch (exn) {
+    return true;
+  }
+}
+
+globalThis.describe("UiHints.emit", () => {
+  globalThis.test("serves the declared file verbatim", () => {
+    let dir = distWithHints();
+    UiHints$ReventlessLocal.emit(declaredFile(declared), dir);
+    globalThis.expect(served(dir)).toEqual(declared);
+  });
+  globalThis.test("leaves a platform that declares nothing entirely alone", () => {
+    let dir = distWithHints();
+    UiHints$ReventlessLocal.emit(undefined, dir);
+    globalThis.expect(served(dir)).toEqual(shipped);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(dir, "ui-hints.base.json"))).toBe(false);
+  });
+  globalThis.test("starts every boot from the shipped file, not the last output", () => {
+    let dir = distWithHints();
+    UiHints$ReventlessLocal.emit(declaredFile(declared), dir);
+    UiHints$ReventlessLocal.emit(declaredFile(shipped), dir);
+    globalThis.expect(Nodefs.readFileSync(Nodepath.join(dir, "ui-hints.base.json"), "utf8")).toEqual(shipped);
+  });
+  globalThis.test("restores the shipped file once the declaration is withdrawn", () => {
+    let dir = distWithHints();
+    UiHints$ReventlessLocal.emit(declaredFile(declared), dir);
+    UiHints$ReventlessLocal.emit(undefined, dir);
+    globalThis.expect(served(dir)).toEqual(shipped);
+  });
+  globalThis.test("refuses a declaration naming a file that does not exist", () => {
+    let dir = distWithHints();
+    let missing = Nodepath.join(tmpdir("reventless-uihints-src-"), "absent.json");
+    globalThis.expect(threw(() => UiHints$ReventlessLocal.emit(missing, dir))).toBe(true);
+  });
+  globalThis.test("refuses a declared file that is not JSON", () => {
+    let dir = distWithHints();
+    globalThis.expect(threw(() => UiHints$ReventlessLocal.emit(declaredFile("not json"), dir))).toBe(true);
+  });
+  globalThis.test("leaves the served file untouched when the declaration is bad", () => {
+    let dir = distWithHints();
+    threw(() => UiHints$ReventlessLocal.emit(declaredFile("not json"), dir));
+    globalThis.expect(served(dir)).toEqual(shipped);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(dir, "ui-hints.base.json"))).toBe(false);
+  });
+});
+
+export {
+  shipped,
+  declared,
+  tmpdir,
+  distWithHints,
+  declaredFile,
+  served,
+  baselinePath,
+  threw,
+}
+/*  Not a pure module */