@joystack/cli 0.0.0-stage → 0.1.43

package/lib/room-reload.mjs

@@ -0,0 +1,168 @@
+// Room hot-reload for `joystack dev`.
+//
+// The room bundle (room-server.mjs) is frozen at build time and partykit runs
+// it as-is, so an edit to a room-authoritative file — entity data, an override,
+// a server sim, a manifest — reaches the client (page reload) but not the room
+// unless something rebuilds it. This module is that something: a poll watcher
+// over the bundle's actual inputs plus the room-shaped game trees, and a
+// reloader that rebuilds and restarts the partykit child on change.
+//
+// Restarting the child drops the room's in-memory world on purpose: the state
+// was seeded from pre-edit files, and the page reload the static watcher
+// already fires makes the next join reseed from the fresh ones. A rebuild that
+// FAILS must never take the working room down with it — the creator gets the
+// old room and a loud message, not a dead stack.
+import { readdirSync, statSync } from 'node:fs';
+import { extname, join } from 'node:path';
+
+// Extensions that can be a room input when watching a whole dir. Explicit
+// files (bundle metafile inputs) are watched regardless of extension.
+const ROOM_EXTS = new Set(['.js', '.mjs', '.json', '.wasm']);
+
+function snapshot(files, dirs) {
+  const out = new Map();
+  for (const f of files) {
+    try {
+      out.set(f, statSync(f).mtimeMs);
+    } catch {
+      out.set(f, -1); // a vanished input is a change too
+    }
+  }
+  const walk = (dir) => {
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch {
+      return; // the tree may not exist yet — its first file appearing is a change
+    }
+    for (const name of names) {
+      if (name.startsWith('.') || name === 'node_modules') continue;
+      const p = join(dir, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p);
+      else if (ROOM_EXTS.has(extname(name).toLowerCase())) out.set(p, st.mtimeMs);
+    }
+  };
+  for (const d of dirs) walk(d);
+  return out;
+}
+
+function differs(a, b) {
+  if (a.size !== b.size) return true;
+  for (const [k, v] of a) if (b.get(k) !== v) return true;
+  return false;
+}
+
+export function createFileWatcher({ files = [], dirs = [], intervalMs = 400, onChange = null }) {
+  // Two independent baselines: the explicit file list (which setFiles swaps
+  // between rebuilds) and the dir walk (which setFiles must never touch). One
+  // merged map couldn't tell a dropped input apart from a dir-walk entry.
+  let watchedFiles = [...files];
+  const watchedDirs = [...dirs];
+  let fileSnap = snapshot(watchedFiles, []);
+  let dirSnap = snapshot([], watchedDirs);
+  const oneShots = [];
+  const timer = setInterval(() => {
+    const nextFiles = snapshot(watchedFiles, []);
+    const nextDirs = snapshot([], watchedDirs);
+    if (differs(fileSnap, nextFiles) || differs(dirSnap, nextDirs)) {
+      fileSnap = nextFiles;
+      dirSnap = nextDirs;
+      while (oneShots.length) oneShots.pop()();
+      // Fire-and-forget on purpose, but a rejection out of the handler must
+      // not become an unhandled rejection that takes the dev stack down.
+      try {
+        Promise.resolve(onChange?.()).catch(() => {});
+      } catch {
+        /* handler threw synchronously — the handler owns its own reporting */
+      }
+    }
+  }, intervalMs);
+  timer.unref();
+  return {
+    setFiles(next) {
+      // Swap the file LIST without rebaselining mtimes: an edit that landed
+      // after the last poll (mid-rebuild, before this call) must still diff
+      // on the next tick. Only genuinely new paths get a fresh stat; entries
+      // already tracked keep their last-observed mtime.
+      const merged = new Map();
+      for (const f of next) {
+        if (fileSnap.has(f)) merged.set(f, fileSnap.get(f));
+        else merged.set(f, snapshot([f], []).get(f));
+      }
+      watchedFiles = [...next];
+      fileSnap = merged;
+    },
+    onNextChange(fn) {
+      oneShots.push(fn);
+    },
+    close() {
+      clearInterval(timer);
+    },
+  };
+}
+
+export function createRoomReloader({ build, spawnChild, killChild, log, onRebuilt = null }) {
+  let current = null; // { cwd, child }
+  let running = false;
+  let dirty = false;
+  let stopped = false;
+
+  async function onChange() {
+    if (stopped) return;
+    if (running) {
+      dirty = true;
+      return;
+    }
+    running = true;
+    try {
+      do {
+        dirty = false;
+        let built;
+        try {
+          built = await build();
+        } catch (err) {
+          log(`✗ room rebuild failed — the running room still serves your PREVIOUS code:\n${err.message}`);
+          continue;
+        }
+        // stop() may race any await in here (`joystack test` tearing the stack
+        // down, SIGINT): once stopped, spawning would leak a detached room
+        // child forever. The check must repeat AFTER the kill too — killChild
+        // waits for the child's exit and can take seconds (SIGTERM, then the
+        // SIGKILL escalation), which is the widest window a stop() can land in.
+        if (stopped) return;
+        try {
+          await killChild(current.child);
+          if (stopped) return;
+          const child = spawnChild(built.cwd);
+          current = { cwd: built.cwd, child };
+        } catch (err) {
+          log(`✗ room restart failed — fix the cause, then edit any room file to retry:\n${err.message}`);
+          continue;
+        }
+        onRebuilt?.(built);
+        log('→ room server rebuilt and restarted (room state reseeds on the next join)');
+      } while (dirty && !stopped);
+    } finally {
+      running = false;
+    }
+  }
+
+  return {
+    attach(cwd, child) {
+      current = { cwd, child };
+    },
+    onChange,
+    stop() {
+      stopped = true;
+    },
+    get current() {
+      return current;
+    },
+  };
+}