@joystack/cli 0.1.45 → 0.1.46

package/lib/static-server.mjs

@@ -3,7 +3,8 @@
 //
 //   /games/<slug>/…   → the game folder
 //   /shared/…         → the engine bundle's shared/ tree
-//   /__reload         → SSE; pings open tabs when a watched file changes
+//   /__reload         → SSE; tells open tabs the version they run on is replaced
+//   /__joystack/dev   → the versions' state; reload, and auto-reload on or off
 //
 // Mounts are ORDERED — first prefix match wins. That ordering is how
 // overrides/shared/… will shadow the engine bundle (Slice 2): the game's
@@ -12,7 +13,7 @@ import http from 'node:http';
 import { connect as connectTcp } from 'node:net';
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { readdirSync, readFileSync, statSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { readFileSync, statSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
 import { extname, join, normalize, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { gunzipSync } from 'node:zlib';
@@ -48,19 +49,38 @@ const REPLAY_URL_RE = new RegExp(`^/games/[^/]+/(?:${STATE_DIRS_RE})/replays/([a
 // one of them carries a dash and none of them is a word.
 const LATEST_ALIAS = 'last';
 
-// The page's half of /__reload. Two events arrive on it: `reload`, a watched
-// file changed, and `room`, the multiplayer room was rebuilt and restarted. A
-// page under `joystack dev --no-reload` ignores `reload`. Every page honours
-// `room`: a restarted room may speak a different wire schema, and a page still
-// on the old one drops every snapshot and sits on a frozen world.
-const reloadClient = (events) => `<script>
+// The page's half of /__reload, under `joystack dev` (live-versions.mjs). Every
+// page the server serves belongs to one version of the game, and leaves when
+// that version stops being the one served:
+//
+//   game    a game page. It reloads as soon as an update starts, so no game
+//           runs while files are replaced; the server answers it with the
+//           "Updating…" page, then the game.
+//   status  the "Updating…" or error page. It reloads when a version is ready.
+//   other   any other page (the Assets page). It reloads once the new version
+//           is served.
+//
+// The stream sends `reload` after every switch, and the status (JSON) on
+// connecting and whenever it changes. A page whose version is not the one in
+// the status reloads at once: it was served just before a switch.
+const reloadClient = (kind, version, token) => `<script>
 (() => {
-  const on = ${JSON.stringify(events)};
+  const kind = ${JSON.stringify(kind)};
+  const version = ${JSON.stringify(version)};
   let alive = false;
+  let leaving = false;
+  const leave = () => { if (!leaving) { leaving = true; location.reload(); } };
   function connect() {
-    const es = new EventSource('/__reload');
+    const es = new EventSource('/__reload?page=' + kind + '&token=${token}');
     es.onopen = () => { alive = true; };
-    es.onmessage = (e) => { if (on.includes(e.data)) location.reload(); };
+    es.onmessage = (e) => {
+      if (e.data === 'reload') return leave();
+      let s;
+      try { s = JSON.parse(e.data); } catch { return; }
+      if (kind === 'game' && (s.state !== 'ready' || s.version !== version)) return leave();
+      if (kind === 'status' && s.state === 'ready') return leave();
+      if (kind === 'status') window.dispatchEvent(new CustomEvent('joystack-status', { detail: s }));
+    };
     es.onerror = () => {
       es.close();
       setTimeout(connect, alive ? 200 : 1000);
@@ -71,15 +91,50 @@ const reloadClient = (events) => `<script>
 })();
 </script>`;
 
-// Models and sounds are watched as well as code and images: re-exporting a .glb
-// or a .wav from an editor is an edit to the game, and the page showing it (the
-// game or the Assets page) should reload just as it does for a source file.
-const WATCH_EXTS = new Set([
-  '.html', '.css', '.js', '.mjs', '.json', '.svg',
-  '.png', '.jpg', '.jpeg', '.gif', '.webp',
-  '.glb', '.gltf', '.bin',
-  '.wav', '.mp3', '.ogg', '.m4a', '.flac',
-]);
+// The one line of a failed build a person needs: the first error it reports,
+// with the game's paths written from the game folder and the build's own
+// location left off. The whole error stays in the terminal and in
+// GET /__joystack/dev, where an agent reads it.
+export function errorSummary(text, gameDir = null) {
+  const lines = String(text ?? '').split('\n').map((l) => l.trim()).filter(Boolean)
+    // Node's own warnings ride along on the build's output.
+    .filter((l) => !/^\(node:\d+\)|^\(Use `node --trace-warnings|^Reparsing as ES module|^To eliminate this warning|package\.json\.$/.test(l));
+  const first = lines.find((l) => l.startsWith('✘')) ?? lines.find((l) => /error|cannot|not defined|unexpected/i.test(l)) ?? lines[0] ?? '';
+  let line = first.replace(/^✘\s*/, '').replace(/^\S+:\d+(?::\d+)?\s+—\s+/, '').replace(/^Expansion threw:\s*/, '');
+  if (gameDir) {
+    // Any absolute path into the game folder, however it is spelled: with
+    // either separator, a drive letter, /private on macOS, or a Windows short
+    // name for a folder above the game's.
+    const name = String(gameDir).split(/[\\/]/).filter(Boolean).at(-1).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    line = line.replace(new RegExp(`(?:file:/+)?(?:[A-Za-z]:)?[\\\\/][^\\s'"]*?[\\\\/]${name}[\\\\/]([^\\s'"]*)`, 'g'), (_, rest) => rest.replace(/\\/g, '/'));
+  }
+  const missing = /^Cannot find module '([^']+)' imported from (\S+)$/.exec(line);
+  if (missing) return `${missing[1]} does not exist, but ${missing[2]} imports it.`;
+  return line;
+}
+
+// What a game page is answered with while no version can be shown: an update
+// in progress, or the error from the last one.
+function statusPage(status, gameDir) {
+  const failed = status.state === 'failed';
+  const esc = (t) => String(t).replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' })[c]);
+  return `<!doctype html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${failed ? 'The game has an error' : 'Updating…'}</title>
+<style>
+html,body{margin:0;height:100%;background:#0b0b10;color:#e5e7eb;font:15px/1.5 system-ui,sans-serif}
+main{min-height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:10px;padding:24px;box-sizing:border-box;text-align:center}
+.spin{width:28px;height:28px;border:3px solid #374151;border-top-color:#e5e7eb;border-radius:50%;animation:s .8s linear infinite}
+@keyframes s{to{transform:rotate(360deg)}}
+h1{font-size:16px;font-weight:600;margin:0}
+p{margin:0;max-width:34em;color:#9ca3af;overflow-wrap:anywhere}
+</style></head>
+<body><main data-joystack-status="${failed ? 'failed' : 'updating'}">
+${failed
+    ? `<h1>The game has an error</h1><p>${esc(errorSummary(status.error, gameDir))}</p>`
+    : '<div class="spin"></div><h1>Updating…</h1>'}
+</main></body></html>`;
+}
 
 // The toolbox → agent report channel (see handleAgentInbox below). The path is
 // a contract with the toolbox shell's ctx.toAgent(); the cap keeps a runaway
@@ -87,6 +142,8 @@ const WATCH_EXTS = new Set([
 // screenshot, so its cap is larger; anyone else (a LAN device, a --share
 // tester) sends small JSON summaries only.
 export const AGENT_INBOX_PATH = '/__joystack/agent-inbox';
+// The versions' control lane (handleDevControl).
+export const DEV_CONTROL_PATH = '/__joystack/dev';
 const AGENT_INBOX_MAX_BYTES = 2 * 1024 * 1024;
 const AGENT_INBOX_LOCAL_MAX_BYTES = 8 * 1024 * 1024;
 // A page can post in a loop. The agent is woken at most this often: a request
@@ -250,51 +307,16 @@ const MIME = {
   '.bin': 'application/octet-stream',
 };
 
-function collectMtimes(roots) {
-  const out = new Map();
-  for (const root of roots) {
-    if (!existsSync(root)) continue;
-    const walk = (dir) => {
-      let names;
-      try {
-        names = readdirSync(dir);
-      } catch {
-        return;
-      }
-      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 (WATCH_EXTS.has(extname(name).toLowerCase())) out.set(p, st.mtimeMs);
-      }
-    };
-    walk(root);
-  }
-  return out;
-}
-
-function mtimesChanged(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 createStaticServer({
   slug,
   mounts,
   projectDir = null,
-  watchDirs = [],
-  injectReload = true,
-  // The build every session is stamped with, when the game served is a copy
-  // frozen at startup (`joystack dev --no-reload`); null to hash projectDir.
+  // The build every session is stamped with, or a function returning it, when
+  // the game served is a copy (a version, see setGame); null to hash projectDir.
   fixedBuild = null,
-  watchIntervalMs = 400,
+  // `joystack dev`'s versions (live-versions.mjs): { status(), reload(),
+  // setAuto(on) }. Null serves the mounts as they are, with no reload.
+  versions = null,
   identity,
   log = console.log,
   // A framework-v2 game's lowered skeleton — injected into the entry HTML as an
@@ -319,19 +341,17 @@ export function createStaticServer({
   // The tunnel hostname `joystack dev --share` opened to this server, once it is
   // up (setShareHost). See trustedHost.
   let shareHost = null;
-  // The injected skeleton is LIVE, not frozen at startup: a v2 hot-reload
-  // rebuilds the room with a fresh skeleton, and `setSkeleton` below pushes that
-  // same skeleton here so the next page load injects it. Without this the client
-  // keeps injecting the startup skeleton after an edit while the room ships the
-  // new one, and assembleGraph throws "kind X re-ran N ... but the skeleton has
-  // M" on the next reload.
+  // The mounts, the skeleton and the build stamp are one version of the game,
+  // replaced together by setGame.
   let currentSkeleton = skeleton;
+  let currentVersion = 0;
 
   // Normalize mounts: url ends with '/', dir has no trailing separator.
-  const table = mounts.map(({ url, dir }) => ({
+  const normalized = (list) => list.map(({ url, dir }) => ({
     url: url.endsWith('/') ? url : url + '/',
     dir: normalize(dir),
   }));
+  let table = normalized(mounts);
 
   // URL path → filesystem path. Mounts are tried in order and FALL THROUGH:
   // the first mount that actually contains the file wins. That ordering is
@@ -366,35 +386,25 @@ export function createStaticServer({
 
   const reload = new EventEmitter();
   reload.setMaxListeners(0);
-  let watchTimer = null;
-  // The build a new session is stamped with. Hashing the game reads every
-  // file and runs git, so it is done once and kept until the watcher sees a
-  // file change; without a watcher nothing would say when it went stale, so it
-  // is computed for each session instead.
-  let buildCache = null;
-  const currentBuild = () => {
-    if (fixedBuild) return { ...fixedBuild, engine: engineVersion };
-    if (buildCache) return buildCache;
-    const build = { ...gameBuild(projectDir), engine: engineVersion };
-    if (watchTimer) buildCache = build;
-    return build;
-  };
-  if (watchDirs.length) {
-    let snapshot = collectMtimes(watchDirs);
-    watchTimer = setInterval(() => {
-      const next = collectMtimes(watchDirs);
-      if (mtimesChanged(snapshot, next)) {
-        snapshot = next;
-        buildCache = null;
-        reload.emit('reload');
-      }
-    }, watchIntervalMs);
-    watchTimer.unref();
-  }
+  // The build a new session is stamped with: the version's, or, serving the
+  // folder itself, a hash of it taken for each session, since nothing says
+  // when a kept one would go stale.
+  const currentBuild = () => ({ ...((typeof fixedBuild === 'function' ? fixedBuild() : fixedBuild) ?? gameBuild(projectDir)), engine: engineVersion });
+
+  // Game pages of each version: those connected to /__reload, and those served
+  // and not connected yet, by the token their reload client carries. A switch
+  // waits until no page of the previous version is left (pagesGone).
+  const gamePages = new Map(); // token → { version, connected, servedAt }
+  let nextToken = 1;
 
   const gameEntry = `/games/${slug}/index.html`;
 
   function serveHtml(req, res, fsPath, urlPath, query) {
+    const gamePage = /^\/games\/[^/]+\//.test(urlPath);
+    const status = versions?.status();
+    if (gamePage && status && status.state !== 'ready') {
+      return sendBody(res, 200, statusPage(status, projectDir) + reloadClient('status', currentVersion, 0), MIME['.html']);
+    }
     let html = readFileSync(fsPath, 'utf8');
     html = rewriteHtmlScripts(html, { baseUrl: urlPath, resolveUrl });
     html = withLegacyImportMap(html);
@@ -434,9 +444,13 @@ export function createStaticServer({
         ...(shared ? { shareHost } : {}),
       });
     }
-    if (watchDirs.length) {
-      const events = injectReload ? ['reload', 'room'] : ['room'];
-      const client = reloadClient(events);
+    if (versions) {
+      let token = 0;
+      if (gamePage) {
+        token = nextToken++;
+        gamePages.set(token, { version: currentVersion, connected: false, servedAt: Date.now() });
+      }
+      const client = reloadClient(gamePage ? 'game' : 'other', currentVersion, token);
       html = html.includes('</body>') ? html.replace('</body>', client + '</body>') : html + client;
     }
     sendBody(res, 200, html, MIME['.html']);
@@ -734,26 +748,79 @@ export function createStaticServer({
     return json(200, { stream, deleted: true });
   }
 
-  function handleSse(res) {
+  function handleSse(res, query) {
     res.writeHead(200, {
       'Content-Type': 'text/event-stream',
       'Cache-Control': 'no-cache',
       Connection: 'keep-alive',
     });
     res.write(':connected\n\n');
+    const page = gamePages.get(Number(query.get('token')));
+    if (page) page.connected = true;
     const push = () => res.write('data: reload\n\n');
-    const pushRoom = () => res.write('data: room\n\n');
+    const pushStatus = (s) => res.write(`data: ${JSON.stringify(s)}\n\n`);
+    if (versions) pushStatus(publicStatus());
     const keepalive = setInterval(() => res.write(':keepalive\n\n'), 10_000);
     keepalive.unref();
     reload.on('reload', push);
-    reload.on('room', pushRoom);
+    reload.on('status', pushStatus);
     res.on('close', () => {
       clearInterval(keepalive);
       reload.off('reload', push);
-      reload.off('room', pushRoom);
+      reload.off('status', pushStatus);
+      if (page) {
+        gamePages.delete(Number(query.get('token')));
+        reload.emit('page-gone');
+      }
     });
   }
 
+  // The versions' state as pages and the control endpoint see it.
+  const publicStatus = () => ({ ...versions.status(), version: currentVersion });
+
+  // GET  /__joystack/dev               the state (see live-versions.mjs)
+  // POST /__joystack/dev/reload        make a version of the files as they are
+  // POST /__joystack/dev/auto { auto } auto-reload on or off
+  //
+  // Changing the mode or reloading changes what every viewer of the game
+  // gets, so it is taken only from this machine, never from a phone on the
+  // network or a --share tester.
+  async function handleDevControl(req, res, urlPath) {
+    const json = (status, body) => {
+      const buf = Buffer.from(JSON.stringify(body));
+      res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': buf.length, 'Cache-Control': 'no-store' });
+      res.end(buf);
+    };
+    if (urlPath === DEV_CONTROL_PATH) {
+      if (req.method !== 'GET') return json(405, { error: 'GET only' });
+      if (!sameOrigin(req, { shareHost })) return json(403, { error: 'cross-origin request rejected' });
+      return json(200, publicStatus());
+    }
+    if (req.method !== 'POST') return json(405, { error: 'POST only' });
+    if (!sameOrigin(req, { shareHost }) || !fromThisMachine(req)) return json(403, { error: 'only from this machine' });
+    if (urlPath === `${DEV_CONTROL_PATH}/reload`) {
+      versions.reload();
+      return json(202, publicStatus());
+    }
+    if (urlPath === `${DEV_CONTROL_PATH}/auto`) {
+      let body;
+      try {
+        let text = '';
+        for await (const c of req) {
+          text += c;
+          if (text.length > 1024) return json(413, { error: 'body too large' });
+        }
+        body = JSON.parse(text);
+      } catch {
+        return json(400, { error: 'expected { "auto": true } or { "auto": false }' });
+      }
+      if (typeof body?.auto !== 'boolean') return json(400, { error: 'expected { "auto": true } or { "auto": false }' });
+      versions.setAuto(body.auto);
+      return json(200, publicStatus());
+    }
+    return json(404, { error: 'not found' });
+  }
+
   // The agent inbox — the toolbox → agent channel. A dev tool in the running
   // game POSTs an envelope ({ tool, at, device, payload } stamped by the
   // toolbox shell, plus an optional `message` the person typed and an optional
@@ -1060,7 +1127,10 @@ export function createStaticServer({
   const server = http.createServer((req, res) => {
     const reqUrl = new URL(req.url, 'http://x');
     const urlPath = canonicalDevPath(reqUrl.pathname);
-    if (urlPath === '/__reload') return handleSse(res);
+    if (urlPath === '/__reload') return handleSse(res, reqUrl.searchParams);
+    if (versions && (urlPath === DEV_CONTROL_PATH || urlPath.startsWith(`${DEV_CONTROL_PATH}/`))) {
+      return handleDevControl(req, res, urlPath).catch(() => res.headersSent ? res.end() : (res.writeHead(500), res.end('500')));
+    }
     // Without a projectDir there is nowhere to land a report — the route
     // simply doesn't exist (falls through to 404), same as any unknown path.
     if (urlPath === AGENT_INBOX_PATH && projectDir) return handleAgentInbox(req, res);
@@ -1198,16 +1268,45 @@ export function createStaticServer({
       return server.address()?.port;
     },
     resolveUrl,
-    // Swap the skeleton injected into subsequent page loads — the v2 hot-reload
-    // path calls this after each room rebuild so the client and room never
-    // disagree on the lowered graph.
-    setSkeleton(next) {
-      currentSkeleton = next ?? null;
+    // Serve another version: its mounts, its skeleton and its build stamp,
+    // all at once. Open pages are told to reload.
+    setGame({ id, mounts: next, skeleton: nextSkeleton = null, build = null }) {
+      table = normalized(next);
+      currentSkeleton = nextSkeleton;
+      fixedBuild = build;
+      currentVersion = id;
+      reload.emit('reload');
     },
-    // The multiplayer room was rebuilt and restarted: every open page reloads,
-    // so none is left on a wire schema the new room no longer speaks.
-    roomRestarted() {
-      reload.emit('room');
+    // The versions' state changed (live-versions.mjs onStatus).
+    statusChanged() {
+      if (versions) reload.emit('status', publicStatus());
+    },
+    // Resolves once no game page of a version other than `id` is open, or
+    // after `timeoutMs`. A page served but not connected yet counts for two
+    // seconds: its reload client may still be on its way.
+    async pagesGone(id, { timeoutMs = 5000 } = {}) {
+      const deadline = Date.now() + timeoutMs;
+      for (;;) {
+        const now = Date.now();
+        let open = false;
+        for (const [token, p] of gamePages) {
+          if (p.version === id) continue;
+          if (!p.connected && now - p.servedAt > 2000) gamePages.delete(token);
+          else open = true;
+        }
+        if (!open || now > deadline) return !open;
+        // Woken as a page leaves; the timer is for pages served and never
+        // connected, which no event announces.
+        await new Promise((r) => {
+          const done = () => {
+            clearTimeout(timer);
+            reload.off('page-gone', done);
+            r();
+          };
+          const timer = setTimeout(done, 200);
+          reload.on('page-gone', done);
+        });
+      }
     },
     // Trust the tunnel hostname `joystack dev --share` opened (see trustedHost);
     // null to stop.
@@ -1229,7 +1328,6 @@ export function createStaticServer({
           if (JSON.parse(readFileSync(file, 'utf8')).token === inboxToken) unlinkSync(file);
         } catch { /* never written, or already replaced */ }
       }
-      if (watchTimer) clearInterval(watchTimer);
       history?.close();
       server.close();
       server.closeAllConnections?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joystack/cli",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "description": "Joystack game development CLI \u2014 dev server, login, and publishing for standalone Joystack games.",
   "type": "module",
   "license": "Apache-2.0",

package/lib/room-reload.mjs

@@ -1,168 +0,0 @@
-// 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;
-    },
-  };
-}