@reventlessdev/reventless-local 3.0.0-alpha.244 → 3.0.0-alpha.246

package/tests/LocalPlatformStartTest.res.mjs

@@ -0,0 +1,210 @@
+// 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 JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as LocalPlatformStart$ReventlessLocal from "../src/LocalPlatformStart.res.mjs";
+import * as LocalPlatformRegistry$ReventlessLocal from "../src/LocalPlatformRegistry.res.mjs";
+
+function tempRoot() {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-start-"));
+}
+
+function sqliteStore(path) {
+  return {
+    kind: "sqlite",
+    path: path
+  };
+}
+
+let memoryStore = {
+  kind: "memory",
+  path: undefined
+};
+
+function writeAt(cwd, port, store, pidOpt) {
+  let pid = pidOpt !== undefined ? pidOpt : process.pid;
+  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, pid, cwd);
+}
+
+function withoutBypass(f) {
+  let previous = process.env[LocalPlatformStart$ReventlessLocal.bypassEnv];
+  Stdlib_Dict.$$delete(process.env, LocalPlatformStart$ReventlessLocal.bypassEnv);
+  let restore = () => {
+    if (previous !== undefined) {
+      process.env[LocalPlatformStart$ReventlessLocal.bypassEnv] = previous;
+      return;
+    }
+  };
+  try {
+    f();
+    return restore();
+  } catch (e) {
+    restore();
+    throw e;
+  }
+}
+
+globalThis.describe("LocalPlatformStart.guardReset", () => {
+  globalThis.test("refuses a reset of a store a live platform opened, naming it", () => {
+    let cwd = tempRoot();
+    let store = Nodepath.join(cwd, ".reventless", "local.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: store
+    }, undefined);
+    let val;
+    try {
+      val = LocalPlatformStart$ReventlessLocal.guardReset(store, cwd, undefined);
+    } catch (raw_e) {
+      let e = Primitive_exceptions.internalToException(raw_e);
+      if (e.RE_EXN_ID === "JsExn") {
+        let message = Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "");
+        globalThis.expect(message.includes(":4000")).toEqual(true);
+        globalThis.expect(message.includes(process.pid.toString())).toEqual(true);
+        return;
+      }
+      throw e;
+    }
+    JestGlobals.fail("expected the reset to be refused");
+  });
+  globalThis.test("matches a relative configured path against the absolute registered one", () => {
+    let cwd = tempRoot();
+    let absolute = Nodepath.join(process.cwd(), ".reventless", "guard-probe.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: absolute
+    }, undefined);
+    globalThis.expect(Stdlib_Option.isSome(LocalPlatformStart$ReventlessLocal.servedBy("./.reventless/guard-probe.db", cwd, undefined))).toEqual(true);
+  });
+  globalThis.test("lets a reset through when nothing is serving that file", () => {
+    let cwd = tempRoot();
+    let path = Nodepath.join(cwd, "other.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: path
+    }, undefined);
+    globalThis.expect(LocalPlatformStart$ReventlessLocal.servedBy(Nodepath.join(cwd, "local.db"), cwd, undefined)).toEqual(undefined);
+    LocalPlatformStart$ReventlessLocal.guardReset(Nodepath.join(cwd, "local.db"), cwd, undefined);
+  });
+  globalThis.test("lets a reset through when the platform holding the store is gone", () => {
+    let cwd = tempRoot();
+    let store = Nodepath.join(cwd, "local.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: store
+    }, 2147483646);
+    LocalPlatformStart$ReventlessLocal.guardReset(store, cwd, undefined);
+  });
+  globalThis.test("ignores a platform that keeps its store in memory", () => {
+    let cwd = tempRoot();
+    writeAt(cwd, 4010, memoryStore, undefined);
+    LocalPlatformStart$ReventlessLocal.guardReset(Nodepath.join(cwd, "local.db"), cwd, undefined);
+  });
+});
+
+globalThis.describe("LocalPlatformStart.orAddressRunning", () => {
+  globalThis.test("refuses a reset before it addresses the platform holding the store", () => {
+    let cwd = tempRoot();
+    let relative = "./.reventless/order-probe.db";
+    let path = Nodepath.resolve(relative);
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: path
+    }, undefined);
+    let previousBackend = process.env["REVENTLESS_LOCAL_BACKEND"];
+    process.env["REVENTLESS_LOCAL_BACKEND"] = `sqlite:` + relative + `?reset`;
+    let outcome;
+    try {
+      LocalPlatformStart$ReventlessLocal.orAddressRunning(cwd, undefined);
+      outcome = "returned or exited";
+    } catch (raw_e) {
+      let e = Primitive_exceptions.internalToException(raw_e);
+      if (e.RE_EXN_ID === "JsExn") {
+        outcome = Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "");
+      } else {
+        throw e;
+      }
+    }
+    if (previousBackend !== undefined) {
+      process.env["REVENTLESS_LOCAL_BACKEND"] = previousBackend;
+    } else {
+      Stdlib_Dict.$$delete(process.env, "REVENTLESS_LOCAL_BACKEND");
+    }
+    globalThis.expect(outcome.includes("refusing to reset")).toEqual(true);
+    globalThis.expect(outcome.includes(":4000")).toEqual(true);
+  });
+});
+
+globalThis.describe("LocalPlatformStart.decide", () => {
+  globalThis.test("starts where nothing is running", () => withoutBypass(() => {
+    globalThis.expect(LocalPlatformStart$ReventlessLocal.decide(tempRoot(), undefined)).toEqual("Start");
+  }));
+  globalThis.test("addresses the one platform already serving this directory", () => withoutBypass(() => {
+    let cwd = tempRoot();
+    let path = Nodepath.join(cwd, "local.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: path
+    }, undefined);
+    let entries = LocalPlatformStart$ReventlessLocal.decide(cwd, undefined);
+    if (typeof entries !== "object") {
+      return JestGlobals.fail("expected the running platform to be addressed");
+    }
+    let entries$1 = entries._0;
+    globalThis.expect(entries$1.map(e => e.port)).toEqual([4000]);
+    let lines = LocalPlatformStart$ReventlessLocal.report(entries$1);
+    globalThis.expect(lines.length).toEqual(2);
+    globalThis.expect(lines.join("\n").includes(":4000")).toEqual(true);
+  }));
+  globalThis.test("names all of them when two are running", () => withoutBypass(() => {
+    let cwd = tempRoot();
+    let path = Nodepath.join(cwd, "local.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: path
+    }, undefined);
+    writeAt(cwd, 4010, memoryStore, undefined);
+    let entries = LocalPlatformStart$ReventlessLocal.decide(cwd, undefined);
+    if (typeof entries !== "object") {
+      return JestGlobals.fail("expected both running platforms to be reported");
+    }
+    let printed = LocalPlatformStart$ReventlessLocal.report(entries._0).join("\n");
+    globalThis.expect(printed.includes(":4000")).toEqual(true);
+    globalThis.expect(printed.includes(":4010")).toEqual(true);
+  }));
+  globalThis.test("starts anyway when REVENTLESS_DOMAIN_PORT names a port", () => {
+    let cwd = tempRoot();
+    let path = Nodepath.join(cwd, "local.db");
+    writeAt(cwd, 4000, {
+      kind: "sqlite",
+      path: path
+    }, undefined);
+    let previous = process.env[LocalPlatformStart$ReventlessLocal.bypassEnv];
+    process.env[LocalPlatformStart$ReventlessLocal.bypassEnv] = "4010";
+    let decision = LocalPlatformStart$ReventlessLocal.decide(cwd, undefined);
+    if (previous !== undefined) {
+      process.env[LocalPlatformStart$ReventlessLocal.bypassEnv] = previous;
+    } else {
+      Stdlib_Dict.$$delete(process.env, LocalPlatformStart$ReventlessLocal.bypassEnv);
+    }
+    globalThis.expect(decision).toEqual("Start");
+  });
+});
+
+let deadPid = 2147483646;
+
+export {
+  tempRoot,
+  deadPid,
+  sqliteStore,
+  memoryStore,
+  writeAt,
+  withoutBypass,
+}
+/*  Not a pure module */

package/tests/ShellConfigTest.res

@@ -77,6 +77,47 @@ describe("ShellConfig.overlay", () => {
   )
 })
 
+// The key that makes the served module reachable. `UiSlots` writes the file and
+// this writes its name, and neither alone is the feature: a file nothing imports
+// and a key pointing at a 404 both leave every mode drawing its own regions,
+// which is what an undeclared deployment already does. Nothing about the running
+// app distinguishes the three.
+describe("ShellConfig.overlay — uiSlotsFile", () => {
+  testSync("unset ⇒ no uiSlotsUrl", () => {
+    let out = ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)
+    expect(out->Dict.get("uiSlotsUrl")->Option.isNone)->toBe(true)
+  })
+
+  testSync("declared ⇒ the URL the platform serves the module from", () => {
+    let out = ShellConfig.overlay(
+      ~bakedManifest=None,
+      ~uiSlotsFile="/src/storefront-slots.js",
+      ~shellConfig=None,
+    )
+    expect(out->Dict.get("uiSlotsUrl"))->toEqual(Some(JSON.Encode.string("/ui-slots.js")))
+  })
+
+  // Withdrawal has to clear the key as well as the file. The baseline is what
+  // does it — this pins that the overlay stops asserting the key, without which
+  // the shipped config could never come back.
+  testSync("withdrawn ⇒ the overlay stops naming it, so the baseline restores", () => {
+    let out = ShellConfig.overlay(~bakedManifest=None, ~shellConfig=None)
+    expect(out->Dict.keysToArray->Array.includes("uiSlotsUrl"))->toBe(false)
+  })
+
+  testSync("refuses a shellConfig key redirecting the computed module", () =>
+    expect(
+      threw(() =>
+        ShellConfig.overlay(
+          ~bakedManifest=None,
+          ~uiSlotsFile="/src/storefront-slots.js",
+          ~shellConfig=Some(Dict.fromArray([("uiSlotsUrl", JSON.Encode.string("/elsewhere.js"))])),
+        )->ignore
+      ),
+    )->toBe(true)
+  )
+})
+
 describe("ShellConfig.emit", () => {
   let shipped = `{\n  "apiEndpoint": "/graphql",\n  "appName": "Shipped"\n}`
 

package/tests/ShellConfigTest.res.mjs

@@ -36,19 +36,19 @@ function threw(f) {
 
 globalThis.describe("ShellConfig.overlay", () => {
   globalThis.test("is empty when the deployment declares nothing", () => {
-    let out = ShellConfig$ReventlessLocal.overlay(undefined, undefined);
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, 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);
+    let out = ShellConfig$ReventlessLocal.overlay(manifest(undefined), 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);
+    let out = ShellConfig$ReventlessLocal.overlay(manifest("storefront.json"), undefined, 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([
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, undefined, Object.fromEntries([
       [
         "appName",
         "Online Shop"
@@ -63,7 +63,7 @@ globalThis.describe("ShellConfig.overlay", () => {
   });
   globalThis.test("refuses a shellConfig key the platform computes", () => {
     globalThis.expect(threw(() => {
-      ShellConfig$ReventlessLocal.overlay(manifest(undefined), Object.fromEntries([[
+      ShellConfig$ReventlessLocal.overlay(manifest(undefined), undefined, Object.fromEntries([[
           "manifestUrl",
           "/elsewhere.json"
         ]]));
@@ -71,6 +71,29 @@ globalThis.describe("ShellConfig.overlay", () => {
   });
 });
 
+globalThis.describe("ShellConfig.overlay — uiSlotsFile", () => {
+  globalThis.test("unset ⇒ no uiSlotsUrl", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, undefined, undefined);
+    globalThis.expect(Stdlib_Option.isNone(out["uiSlotsUrl"])).toBe(true);
+  });
+  globalThis.test("declared ⇒ the URL the platform serves the module from", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, "/src/storefront-slots.js", undefined);
+    globalThis.expect(out["uiSlotsUrl"]).toEqual("/ui-slots.js");
+  });
+  globalThis.test("withdrawn ⇒ the overlay stops naming it, so the baseline restores", () => {
+    let out = ShellConfig$ReventlessLocal.overlay(undefined, undefined, undefined);
+    globalThis.expect(Object.keys(out).includes("uiSlotsUrl")).toBe(false);
+  });
+  globalThis.test("refuses a shellConfig key redirecting the computed module", () => {
+    globalThis.expect(threw(() => {
+      ShellConfig$ReventlessLocal.overlay(undefined, "/src/storefront-slots.js", Object.fromEntries([[
+          "uiSlotsUrl",
+          "/elsewhere.js"
+        ]]));
+    })).toBe(true);
+  });
+});
+
 globalThis.describe("ShellConfig.emit", () => {
   let shipped = `{\n  "apiEndpoint": "/graphql",\n  "appName": "Shipped"\n}`;
   let distWithConfig = () => {
@@ -87,35 +110,35 @@ globalThis.describe("ShellConfig.emit", () => {
     ]]);
   globalThis.test("merges the overlay onto the shipped file and keeps its other keys", () => {
     let dir = distWithConfig();
-    ShellConfig$ReventlessLocal.emit(manifest(undefined), undefined, dir);
+    ShellConfig$ReventlessLocal.emit(manifest(undefined), 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);
+    ShellConfig$ReventlessLocal.emit(undefined, 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);
+    ShellConfig$ReventlessLocal.emit(undefined, undefined, named("First"), dir);
+    ShellConfig$ReventlessLocal.emit(undefined, 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);
+    ShellConfig$ReventlessLocal.emit(manifest(undefined), undefined, undefined, dir);
+    ShellConfig$ReventlessLocal.emit(undefined, 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);
+    globalThis.expect(threw(() => ShellConfig$ReventlessLocal.emit(manifest(undefined), undefined, undefined, dir))).toBe(true);
   });
 });
 
@@ -157,22 +180,22 @@ let fulfilment = {
 
 globalThis.describe("ShellConfig.overlay — journeys", () => {
   globalThis.test("a bake declaring no journeys writes no map", () => {
-    let out = ShellConfig$ReventlessLocal.overlay(manifest(undefined), undefined);
+    let out = ShellConfig$ReventlessLocal.overlay(manifest(undefined), 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);
+    let out = ShellConfig$ReventlessLocal.overlay(withJourneys([]), undefined, undefined);
     globalThis.expect(out["journeyManifestUrls"]).toEqual(undefined);
   });
   globalThis.test("keeps manifestUrl as the default journey", () => {
-    let out = ShellConfig$ReventlessLocal.overlay(withJourneys([shopper]), undefined);
+    let out = ShellConfig$ReventlessLocal.overlay(withJourneys([shopper]), undefined, 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);
+    ]), undefined, undefined);
     let map = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(out["journeyManifestUrls"], Stdlib_JSON.Decode.object), undefined);
     globalThis.expect([
       str(map, "Shopper"),
@@ -184,7 +207,7 @@ globalThis.describe("ShellConfig.overlay — journeys", () => {
   });
   globalThis.test("refuses a shellConfig that sets the journey map itself", () => {
     globalThis.expect(threw(() => {
-      ShellConfig$ReventlessLocal.overlay(withJourneys([shopper]), Object.fromEntries([[
+      ShellConfig$ReventlessLocal.overlay(withJourneys([shopper]), undefined, Object.fromEntries([[
           "journeyManifestUrls",
           {}
         ]]));

package/tests/UiSlotsTest.res

@@ -0,0 +1,197 @@
+open JestGlobals
+
+// The `ui-slots.js` the local platform serves. Two things are under test: that a
+// declared module reaches the served dist/ unaltered, and that an undeclared
+// platform serves *nothing* — which is where this parts company with the hints
+// file, whose "nothing" means the host-shell package's own fallback.
+//
+// Every failure here is quiet in the worst way. Hints going unapplied read as a
+// menu that is slightly wrong; renderers going unapplied read as a surface that
+// was never customised, which is indistinguishable from one nobody customised.
+
+let _ = TestRunner.setup()
+
+// The shape the shell actually calls (`SlotModules.load`): one `register`
+// export, handed `h` and the registry. Nothing here evaluates it — the bytes are
+// what is under test — but a fixture that misstated the contract would be read
+// as documentation of it.
+let declared = `export function register({ h, slots }) {
+  slots.row("gallery.tile", ({ row }) => h("span", null, row.name))
+}
+`
+let edited = `export function register({ h, slots }) {
+  slots.row("gallery.tile", ({ row }) => h("strong", null, row.name))
+}
+`
+
+let tmpdir = prefix => NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), prefix]))
+
+// No shipped counterpart, deliberately: the shell ships no slots module, and a
+// fixture that invented one would test a fallback this seam must not have.
+let emptyDist = () => tmpdir("reventless-uislots-dist-")
+
+let declaredFile = (contents: string) => {
+  let path = NodePath.join([tmpdir("reventless-uislots-src-"), "storefront-slots.js"])
+  NodeFs.writeFileSync(path, contents)
+  path
+}
+
+let servedPath = (dir: string) => NodePath.join([dir, "ui-slots.js"])
+let served = (dir: string) => NodeFs.readFileSync(servedPath(dir))
+let isServed = (dir: string) => NodeFs.existsSync(servedPath(dir))
+
+let threw = (f: unit => unit): bool =>
+  try {
+    f()
+    false
+  } catch {
+  | _ => true
+  }
+
+describe("UiSlots.emit", () => {
+  testSync("serves the declared module verbatim", () => {
+    let dir = emptyDist()
+    UiSlots.emit(~uiSlotsFile=Some(declaredFile(declared)), ~dir)
+    expect(served(dir))->toEqual(declared)
+  })
+
+  // An undeclared platform has to be byte-identical to one built before this
+  // module existed.
+  testSync("writes nothing when the platform declares no slots file", () => {
+    let dir = emptyDist()
+    UiSlots.emit(~uiSlotsFile=None, ~dir)
+    expect(isServed(dir))->toBe(false)
+  })
+
+  // The counterpart to the hints baseline. There is no file to restore, so the
+  // state to return to is "no file" — leaving yesterday's renderers in place
+  // with nothing in the deployment to explain them is the failure a baseline
+  // exists to prevent, arriving by the other road.
+  testSync("removes the served module once the declaration is withdrawn", () => {
+    let dir = emptyDist()
+    UiSlots.emit(~uiSlotsFile=Some(declaredFile(declared)), ~dir)
+    UiSlots.emit(~uiSlotsFile=None, ~dir)
+    expect(isServed(dir))->toBe(false)
+  })
+
+  testSync("withdrawing twice is not an error", () => {
+    let dir = emptyDist()
+    UiSlots.emit(~uiSlotsFile=None, ~dir)
+    expect(threw(() => UiSlots.emit(~uiSlotsFile=None, ~dir)))->toBe(false)
+  })
+
+  // The one failure this side can see, and it has to be the boot's problem: a
+  // declaration pointing nowhere registers no renderers and says nothing about
+  // why, which reads as a seam that does not work.
+  testSync("refuses a declaration naming a file that does not exist", () => {
+    let dir = emptyDist()
+    let missing = NodePath.join([tmpdir("reventless-uislots-src-"), "absent.js"])
+    expect(threw(() => UiSlots.emit(~uiSlotsFile=Some(missing), ~dir)))->toBe(true)
+  })
+
+  // Read before anything is touched: a bad declaration must not leave the served
+  // module half-replaced, which would be worse than either outcome.
+  testSync("leaves the last good module in place when the declaration is bad", () => {
+    let dir = emptyDist()
+    UiSlots.emit(~uiSlotsFile=Some(declaredFile(declared)), ~dir)
+    let missing = NodePath.join([tmpdir("reventless-uislots-src-"), "absent.js"])
+    let _ = threw(() => UiSlots.emit(~uiSlotsFile=Some(missing), ~dir))
+    expect(served(dir))->toEqual(declared)
+  })
+
+  // The deliberate non-check. There is no cheap way to know a module is good
+  // short of evaluating it, the deploy half cannot do it either, and a check
+  // that only ran locally would let a file pass the loop it was authored in and
+  // fail the one it ships to. The shell reports what it could not import.
+  testSync("serves a module it cannot vouch for rather than refusing it", () => {
+    let dir = emptyDist()
+    let broken = "export const register = (r) => {"
+    UiSlots.emit(~uiSlotsFile=Some(declaredFile(broken)), ~dir)
+    expect(served(dir))->toEqual(broken)
+  })
+})
+
+// The dev loop. Real `fs.watch` events rather than a stubbed clock, because what
+// is being tested IS the plumbing — a debounce over a fake timer would pass with
+// the watcher wired to nothing.
+//
+// The repeated edit is not belt-and-braces: `fs.watch` does not promise that a
+// write landing near the watcher's creation is reported, and on macOS a write
+// that beats the FSEvents stream up is not reported late but not at all. See the
+// long note in `UiHintsTest` — the same reasoning and the same interval.
+let retryEvery = 1000
+
+let waitForReload = (~timeoutMs: int=4000, ~edit: unit => unit, ~uiSlotsFile, ~dir) =>
+  Promise.make((resolve, _) => {
+    let fired = ref(0)
+    let watcher = ref(None)
+    let deadline = ref(None)
+    let retry = ref(None)
+    // Resolves with a count rather than rejecting on the deadline: "nothing was
+    // re-served" is an expected answer here, and a rejection would make the
+    // assertion read as an infrastructure failure.
+    let finish = () => {
+      watcher.contents->Option.forEach(NodeFs.watcherClose)
+      deadline.contents->Option.forEach(clearTimeout)
+      retry.contents->Option.forEach(clearTimeout)
+      resolve(fired.contents)
+    }
+    let rec editUntilSeen = () => {
+      edit()
+      retry := Some(setTimeout(editUntilSeen, retryEvery))
+    }
+    watcher :=
+      UiSlots.watch(~uiSlotsFile, ~dir, ~onReload=() => {
+        fired := fired.contents + 1
+        finish()
+      })
+    deadline := Some(setTimeout(finish, timeoutMs))
+    editUntilSeen()
+  })
+
+describe("UiSlots.watch", () => {
+  testSync("watches nothing when the platform declares no slots file", () =>
+    expect(UiSlots.watch(~uiSlotsFile=None, ~onReload=() => ()))->toEqual(None)
+  )
+
+  testSync("declines to watch a path whose directory is gone, without throwing", () => {
+    let missing = NodePath.join([tmpdir("reventless-uislots-gone-"), "nowhere", "slots.js"])
+    expect(UiSlots.watch(~uiSlotsFile=Some(missing), ~onReload=() => ()))->toEqual(None)
+  })
+
+  test("re-serves the module when it changes, and says so", async () => {
+    let dir = emptyDist()
+    let path = declaredFile(declared)
+    UiSlots.emit(~uiSlotsFile=Some(path), ~dir)
+    let fired = await waitForReload(
+      ~uiSlotsFile=Some(path),
+      ~dir,
+      ~edit=() => NodeFs.writeFileSync(path, edited),
+    )
+    expect((fired > 0, served(dir)))->toEqual((true, edited))
+  })
+
+  // Mid-session the file going unreadable is almost always an editor between two
+  // writes, and killing a running dev server over a keystroke would make this
+  // worse than the restart it replaces. The previous copy stands, and the save
+  // completing is itself the next event, so recovery needs no second trigger.
+  test("keeps serving the last good copy when the file is momentarily unreadable", async () => {
+    let dir = emptyDist()
+    let path = declaredFile(declared)
+    UiSlots.emit(~uiSlotsFile=Some(path), ~dir)
+    let fired = await waitForReload(
+      ~timeoutMs=1500,
+      ~uiSlotsFile=Some(path),
+      ~dir,
+      // Write-then-unlink rather than a bare unlink, so the edit stays repeatable
+      // for the retry above: it raises events every time and lands in the same
+      // absent state each time. It is also what a rename-based editor save
+      // actually does — the window this is about is the one between the two.
+      ~edit=() => {
+        NodeFs.writeFileSync(path, edited)
+        NodeFs.unlinkSync(path)
+      },
+    )
+    expect((fired, served(dir)))->toEqual((0, declared))
+  })
+})