@valentinkolb/cloud 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valentinkolb/cloud",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Modular Hono+SolidJS framework for building per-app docker services behind a dynamic gateway. Powers cloud.stuve-ulm.de.",
   "license": "MIT",
   "repository": {

package/src/_internal/define-app.ts

@@ -367,7 +367,7 @@ export const defineApp = <const S extends AppSettingsMap = {}>(opts: AppOptions<
       stopping = true;
       log.info(`Stopping: ${meta.id}`);
       try { if (startOpts.lifecycle?.stop) await startOpts.lifecycle.stop(cloudCtx); } catch {}
-      stopRuntimeWatcher();
+      await stopRuntimeWatcher();
       await heartbeat.stop();
     };
 

package/src/_internal/runtime-watcher.ts

@@ -3,8 +3,8 @@
  *
  * `defineApp().start()` and the `middleware.runtime()` factory both call
  * `ensureRuntimeWatcher()` — the first call subscribes to the Redis
- * registry and starts refreshing on every event; subsequent calls are
- * no-ops. Reads happen via `getCurrentRuntime()`.
+ * registry and starts refreshing on every event; subsequent calls
+ * await the same in-flight init promise. Reads happen via `getCurrentRuntime()`.
  *
  * One process = one app = one watcher; lives until `stopRuntimeWatcher()`
  * (called from defineApp's shutdown handler) or process exit.
@@ -17,37 +17,53 @@ import { buildRuntimeFromRegistry } from "./runtime-context";
 const log = logger("runtime-watcher");
 
 let current: CloudRuntime | undefined;
-let started = false;
+let initPromise: Promise<void> | undefined;
+let watcherTask: Promise<void> | undefined;
 let abort: AbortController | undefined;
 
 const refresh = async () => {
   current = buildRuntimeFromRegistry(await listApps());
 };
 
-export const ensureRuntimeWatcher = async (): Promise<void> => {
-  if (started) return;
-  started = true;
-  await refresh();
-  abort = new AbortController();
-  void (async () => {
-    try {
-      const snap = await appRegistry.snapshot({ prefix: "apps/" });
-      for await (const _ev of appRegistry
-        .reader({ prefix: "apps/", after: snap.cursor })
-        .stream({ signal: abort.signal })) {
-        await refresh();
+export const ensureRuntimeWatcher = (): Promise<void> => {
+  // Concurrent callers (start() + first request) wait on the same init —
+  // returning before `current` is populated would race getCurrentRuntime().
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    await refresh();
+    abort = new AbortController();
+    watcherTask = (async () => {
+      try {
+        const snap = await appRegistry.snapshot({ prefix: "apps/" });
+        for await (const _ev of appRegistry
+          .reader({ prefix: "apps/", after: snap.cursor })
+          .stream({ signal: abort!.signal })) {
+          await refresh();
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") return;
+        log.error("Registry watcher failed", { error: err instanceof Error ? err.message : String(err) });
       }
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") return;
-      log.error("Registry watcher failed", { error: err instanceof Error ? err.message : String(err) });
-    }
+    })();
   })();
+  return initPromise;
 };
 
-export const stopRuntimeWatcher = (): void => {
+export const stopRuntimeWatcher = async (): Promise<void> => {
+  // Await the watcher loop's exit before clearing state — otherwise an
+  // in-flight refresh() can write `current` after we cleared it, or a
+  // restart can overlap two readers.
   abort?.abort();
+  if (watcherTask) {
+    try {
+      await watcherTask;
+    } catch {
+      // already logged inside the loop
+    }
+  }
   abort = undefined;
-  started = false;
+  watcherTask = undefined;
+  initPromise = undefined;
   current = undefined;
 };