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

package/src/adapter/EventHistory/EventHistoryResolvers_GraphQL.res.mjs

@@ -8,6 +8,7 @@ import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
+import * as Auth_GraphqlContext$ReventlessLocal from "../Auth/Auth_GraphqlContext.res.mjs";
 import * as Plugin_EventQuerySchema$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_EventQuerySchema.res.mjs";
 
 function comparePosition(a, b) {
@@ -153,6 +154,62 @@ function readFilter(args) {
   };
 }
 
+function suppliedFilterKeys(f) {
+  return Stdlib_Array.filterMap([
+    [
+      "entityId",
+      Stdlib_Option.isSome(f.entityId)
+    ],
+    [
+      "tagKey",
+      Stdlib_Option.isSome(f.tagKey)
+    ],
+    [
+      "tagValue",
+      Stdlib_Option.isSome(f.tagValue)
+    ],
+    [
+      "eventTypes",
+      Stdlib_Option.isSome(f.eventTypes)
+    ],
+    [
+      "user",
+      Stdlib_Option.isSome(f.user)
+    ],
+    [
+      "timeFrom",
+      Stdlib_Option.isSome(f.timeFrom)
+    ],
+    [
+      "timeTo",
+      Stdlib_Option.isSome(f.timeTo)
+    ]
+  ], param => {
+    if (param[1]) {
+      return param[0];
+    }
+  });
+}
+
+function callerOf(ctx) {
+  let operation = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(ctx), d => d["params"]), Stdlib_JSON.Decode.object), d => d["operationName"]), Stdlib_JSON.Decode.string);
+  let user = Auth_GraphqlContext$ReventlessLocal.extractIdentity(ctx).userId;
+  if (operation !== undefined) {
+    return `operation "` + operation + `" as ` + user;
+  } else {
+    return `an unnamed operation as ` + user;
+  }
+}
+
+function describeCaller(ctx, filter) {
+  let keys = suppliedFilterKeys(filter);
+  if (keys.length !== 0) {
+    return callerOf(ctx) + `, with filter [` + keys.join(", ") + `]`;
+  } else {
+    return callerOf(ctx) + `, with no filter`;
+  }
+}
+
 function matchesTag(r, f) {
   let match = f.tagKey;
   let match$1 = f.tagValue;
@@ -305,7 +362,7 @@ function Make(Bus) {
       }
       seen.add(displayName);
       let fieldName = Plugin_EventQuerySchema$ReventlessCore.historyFieldName(params.pluginName, displayName);
-      let resolver = async (_root, args, _ctx) => {
+      let resolver = async (_root, args, ctx) => {
         let f = readFilter(args);
         let replay = Bus.getEventLogReplay(entry.busKey);
         let records;
@@ -314,7 +371,7 @@ function Make(Bus) {
           if (entityId !== undefined) {
             records = await readAggregate(replay, entityId);
           } else {
-            log.warn("EventHistoryResolvers_GraphQL", undefined, fieldName + `: ` + displayName + ` is an aggregate event log — it can only be read per entity. Supply filter.entityId.`);
+            log.warn("EventHistoryResolvers_GraphQL", undefined, fieldName + `: ` + displayName + ` is an aggregate event log — it can only be read per entity. ` + (`Supply filter.entityId. Asked by ` + describeCaller(ctx, f) + `.`));
             records = [];
           }
         } else {
@@ -353,6 +410,9 @@ export {
   metaJsonFromEnvelope,
   recordJson,
   readFilter,
+  suppliedFilterKeys,
+  callerOf,
+  describeCaller,
   matchesTag,
   matchesFilter,
   paginate,

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))
+  })
+})

package/tests/UiSlotsTest.res.mjs

@@ -0,0 +1,196 @@
+// 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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as UiSlots$ReventlessLocal from "../src/UiSlots.res.mjs";
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+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))
+}
+`;
+
+function tmpdir(prefix) {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), prefix));
+}
+
+function emptyDist() {
+  return tmpdir("reventless-uislots-dist-");
+}
+
+function declaredFile(contents) {
+  let path = Nodepath.join(tmpdir("reventless-uislots-src-"), "storefront-slots.js");
+  Nodefs.writeFileSync(path, contents, "utf8");
+  return path;
+}
+
+function servedPath(dir) {
+  return Nodepath.join(dir, "ui-slots.js");
+}
+
+function served(dir) {
+  return Nodefs.readFileSync(Nodepath.join(dir, "ui-slots.js"), "utf8");
+}
+
+function isServed(dir) {
+  return Nodefs.existsSync(Nodepath.join(dir, "ui-slots.js"));
+}
+
+function threw(f) {
+  try {
+    f();
+    return false;
+  } catch (exn) {
+    return true;
+  }
+}
+
+globalThis.describe("UiSlots.emit", () => {
+  globalThis.test("serves the declared module verbatim", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    UiSlots$ReventlessLocal.emit(declaredFile(declared), dir);
+    globalThis.expect(Nodefs.readFileSync(Nodepath.join(dir, "ui-slots.js"), "utf8")).toEqual(declared);
+  });
+  globalThis.test("writes nothing when the platform declares no slots file", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    UiSlots$ReventlessLocal.emit(undefined, dir);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(dir, "ui-slots.js"))).toBe(false);
+  });
+  globalThis.test("removes the served module once the declaration is withdrawn", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    UiSlots$ReventlessLocal.emit(declaredFile(declared), dir);
+    UiSlots$ReventlessLocal.emit(undefined, dir);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(dir, "ui-slots.js"))).toBe(false);
+  });
+  globalThis.test("withdrawing twice is not an error", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    UiSlots$ReventlessLocal.emit(undefined, dir);
+    globalThis.expect(threw(() => UiSlots$ReventlessLocal.emit(undefined, dir))).toBe(false);
+  });
+  globalThis.test("refuses a declaration naming a file that does not exist", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    let missing = Nodepath.join(tmpdir("reventless-uislots-src-"), "absent.js");
+    globalThis.expect(threw(() => UiSlots$ReventlessLocal.emit(missing, dir))).toBe(true);
+  });
+  globalThis.test("leaves the last good module in place when the declaration is bad", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    UiSlots$ReventlessLocal.emit(declaredFile(declared), dir);
+    let missing = Nodepath.join(tmpdir("reventless-uislots-src-"), "absent.js");
+    threw(() => UiSlots$ReventlessLocal.emit(missing, dir));
+    globalThis.expect(Nodefs.readFileSync(Nodepath.join(dir, "ui-slots.js"), "utf8")).toEqual(declared);
+  });
+  globalThis.test("serves a module it cannot vouch for rather than refusing it", () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    let broken = "export const register = (r) => {";
+    UiSlots$ReventlessLocal.emit(declaredFile(broken), dir);
+    globalThis.expect(Nodefs.readFileSync(Nodepath.join(dir, "ui-slots.js"), "utf8")).toEqual(broken);
+  });
+});
+
+function waitForReload(timeoutMsOpt, edit, uiSlotsFile, dir) {
+  let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 4000;
+  return new Promise((resolve, param) => {
+    let fired = {
+      contents: 0
+    };
+    let watcher = {
+      contents: undefined
+    };
+    let deadline = {
+      contents: undefined
+    };
+    let retry = {
+      contents: undefined
+    };
+    let finish = () => {
+      Stdlib_Option.forEach(watcher.contents, prim => {
+        prim.close();
+      });
+      Stdlib_Option.forEach(deadline.contents, prim => {
+        clearTimeout(prim);
+      });
+      Stdlib_Option.forEach(retry.contents, prim => {
+        clearTimeout(prim);
+      });
+      resolve(fired.contents);
+    };
+    let editUntilSeen = () => {
+      edit();
+      retry.contents = Primitive_option.some(setTimeout(editUntilSeen, 1000));
+    };
+    watcher.contents = UiSlots$ReventlessLocal.watch(uiSlotsFile, dir, () => {
+      fired.contents = fired.contents + 1 | 0;
+      finish();
+    });
+    deadline.contents = Primitive_option.some(setTimeout(finish, timeoutMs));
+    editUntilSeen();
+  });
+}
+
+globalThis.describe("UiSlots.watch", () => {
+  globalThis.test("watches nothing when the platform declares no slots file", () => {
+    globalThis.expect(UiSlots$ReventlessLocal.watch(undefined, undefined, () => {})).toEqual(undefined);
+  });
+  globalThis.test("declines to watch a path whose directory is gone, without throwing", () => {
+    let missing = Nodepath.join(tmpdir("reventless-uislots-gone-"), "nowhere", "slots.js");
+    globalThis.expect(UiSlots$ReventlessLocal.watch(missing, undefined, () => {})).toEqual(undefined);
+  });
+  globalThis.test("re-serves the module when it changes, and says so", async () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    let path = declaredFile(declared);
+    UiSlots$ReventlessLocal.emit(path, dir);
+    let fired = await waitForReload(undefined, () => {
+      Nodefs.writeFileSync(path, edited, "utf8");
+    }, path, dir);
+    globalThis.expect([
+      fired > 0,
+      Nodefs.readFileSync(Nodepath.join(dir, "ui-slots.js"), "utf8")
+    ]).toEqual([
+      true,
+      edited
+    ]);
+  });
+  globalThis.test("keeps serving the last good copy when the file is momentarily unreadable", async () => {
+    let dir = tmpdir("reventless-uislots-dist-");
+    let path = declaredFile(declared);
+    UiSlots$ReventlessLocal.emit(path, dir);
+    let fired = await waitForReload(1500, () => {
+      Nodefs.writeFileSync(path, edited, "utf8");
+      Nodefs.unlinkSync(path);
+    }, path, dir);
+    globalThis.expect([
+      fired,
+      Nodefs.readFileSync(Nodepath.join(dir, "ui-slots.js"), "utf8")
+    ]).toEqual([
+      0,
+      declared
+    ]);
+  });
+});
+
+let retryEvery = 1000;
+
+export {
+  declared,
+  edited,
+  tmpdir,
+  emptyDist,
+  declaredFile,
+  servedPath,
+  served,
+  isServed,
+  threw,
+  retryEvery,
+  waitForReload,
+}
+/*  Not a pure module */