fix(webapp): serialize registry reloads and clear readiness timeout

Author: nicktrn

apps/webapp/app/utils/reloadingRegistry.server.ts

@@ -48,13 +48,17 @@ export type ReloadingRegistryOptions<T> = {
 export function createReloadingRegistry<T>(opts: ReloadingRegistryOptions<T>): ReloadingRegistry<T> {
   let snapshot: T | undefined;
   let loaded = false;
+  let loadSeq = 0;
   let resolveReady!: () => void;
   const isReady = new Promise<void>((resolve) => {
     resolveReady = resolve;
   });
 
   async function doLoad() {
-    snapshot = await opts.load();
+    const seq = ++loadSeq;
+    const next = await opts.load();
+    if (seq < loadSeq) return; // a newer load started while we were awaiting; don't clobber
+    snapshot = next;
     lastSuccessfulLoadAt.set({ name: opts.name }, Date.now() / 1000);
     if (!loaded) {
       loaded = true;
@@ -110,10 +114,17 @@ export function createReloadingRegistry<T>(opts: ReloadingRegistryOptions<T>): R
     reload: doLoad,
     async waitUntilReady(timeoutMs: number) {
       if (loaded || timeoutMs <= 0) return;
-      await Promise.race([
-        isReady,
-        new Promise<void>((resolve) => setTimeout(resolve, timeoutMs)),
-      ]);
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          isReady,
+          new Promise<void>((resolve) => {
+            timer = setTimeout(resolve, timeoutMs);
+          }),
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
     },
     stop,
   };

apps/webapp/test/reloadingRegistry.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { createReloadingRegistry } from "~/utils/reloadingRegistry.server";
 
 describe("createReloadingRegistry", () => {
@@ -55,4 +55,62 @@ describe("createReloadingRegistry", () => {
     expect(reg.current()).toBe(2);
     reg.stop();
   });
+
+  it("newer load wins even if an older load resolves later", async () => {
+    // load hands the test a deferred resolver per call so completion order is controllable.
+    const deferred: Array<(value: number) => void> = [];
+    const reg = createReloadingRegistry({
+      name: "test-e",
+      intervalMs: 10_000,
+      load: () =>
+        new Promise<number>((resolve) => {
+          deferred.push(resolve);
+        }),
+    });
+
+    // deferred[0] is the startup load; let it complete with an initial value.
+    deferred[0](0);
+    await reg.isReady;
+
+    // start two overlapping loads; don't await yet (deferred[1] older, deferred[2] newer)
+    const older = reg.reload();
+    const newer = reg.reload();
+
+    // resolve the NEWER load first, then the OLDER load last
+    deferred[2](2);
+    deferred[1](1);
+    await Promise.all([older, newer]);
+
+    // the older load completing last must NOT clobber the newer snapshot
+    expect(reg.current()).toBe(2);
+    reg.stop();
+  });
+
+  it("waitUntilReady clears its timeout when ready wins", async () => {
+    const clearSpy = vi.spyOn(global, "clearTimeout");
+    // load resolves only when the test releases it, so waitUntilReady runs the
+    // race while still unloaded (it would return early if already loaded)
+    let releaseLoad!: () => void;
+    const loadGate = new Promise<void>((resolve) => {
+      releaseLoad = resolve;
+    });
+    const reg = createReloadingRegistry({
+      name: "test-f",
+      intervalMs: 10_000,
+      load: async () => {
+        await loadGate;
+        return 1;
+      },
+    });
+
+    // long timeout so isReady is what actually wins the race
+    const waiting = reg.waitUntilReady(10_000);
+    releaseLoad();
+    await reg.isReady;
+    await waiting;
+
+    expect(clearSpy).toHaveBeenCalled();
+    clearSpy.mockRestore();
+    reg.stop();
+  });
 });