@solidrt/cli 0.0.32 → 0.0.33

package/src/repl.ts

@@ -4,6 +4,7 @@ import { readdirSync } from "node:fs"
 import { state, print, printErr, shutdown } from "./util"
 import { buildReload, getClients, sendReload, sendStop, sendStats, sendWatch, showBuildFailure } from "./dev-server"
 import { bundle } from "./bundler"
+import { buildManifest, projectDirFor } from "./project"
 import { startWatcher, stopWatcher } from "./watcher"
 
 // Resolve repl client indexes ("0 2") against the server's client list,
@@ -28,6 +29,7 @@ async function cmdStop(args: string) {
     stopWatcher()
     state.currentCode = null
     state.currentMap = null
+    state.currentManifest = null
     state.source = undefined
     await sendStop()
     print("[cli] Sent stop to all clients")
@@ -50,8 +52,9 @@ async function cmdReload(args: string) {
     }
     state.currentCode = result.code
     state.currentMap = result.map
+    state.currentManifest = result.manifest
   }
-  let msg = buildReload({ code: state.currentCode })
+  let msg = buildReload({ code: state.currentCode, manifest: state.currentManifest })
   if (!args) {
     await sendReload(msg, { latch: true, map: state.currentMap })
     print("[cli] Sent reload to all clients")
@@ -106,9 +109,11 @@ async function cmdLoad(file: string) {
     }
     state.currentCode = result.code
     state.currentMap = result.map
+    state.currentManifest = result.manifest
   } else if (file.endsWith(".srt.js")) {
     state.currentCode = await Bun.file(path).text()
     state.currentMap = null
+    state.currentManifest = buildManifest(state.currentCode, path)
   } else if (file.endsWith(".srt.bin")) {
     let bytes = await Bun.file(path).arrayBuffer()
     // One-shot: bytecode loads are pushed but not latched for late joiners.
@@ -121,12 +126,15 @@ async function cmdLoad(file: string) {
   }
   state.source = path
   state.sourceDir = dirname(path)
+  state.projectDir = projectDirFor(path)
   startWatcher()
   // The load also moves the server's file-serving root to the new source dir,
-  // and its rebuild entry to the new file (for a later MCP reload).
-  await sendReload(buildReload({ code: state.currentCode }), {
+  // its /assets/ root to the new project dir, and its rebuild entry to the
+  // new file (for a later MCP reload).
+  await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
     latch: true,
     sourceDir: state.sourceDir,
+    projectDir: state.projectDir,
     entry: file.endsWith(".tsx") ? path : undefined,
     map: state.currentMap,
   })

package/src/util.ts

@@ -11,8 +11,14 @@ export let state = {
   // The bundle's composed sourcemap (dev builds), sent to the server alongside
   // reloads so it can remap logged stack traces to .tsx positions.
   currentMap: null as string | null,
+  // The bundle's version manifest (canonical JSON string, see buildManifest);
+  // travels with code reloads so clients install the push as a version.
+  currentManifest: null as string | null,
   source: undefined as string | undefined,
   sourceDir: process.cwd(),
+  // The project root the assets/ convention hangs off (see project.ts
+  // projectDirFor); the server's /assets/ route serves from under it.
+  projectDir: process.cwd(),
   child: null as ReturnType<typeof Bun.spawn> | null,
   // The spawned flux dev-server process (see dev-server.ts startServer).
   serverProc: null as ReturnType<typeof Bun.spawn> | null,

package/src/watcher.ts

@@ -1,43 +1,69 @@
-import { watch } from "node:fs"
-import { resolve, dirname } from "path"
+import { existsSync, watch } from "node:fs"
+import { resolve, dirname, sep, basename } from "path"
 import { state, print, printErr } from "./util"
 import { buildReload, sendReload, showBuildFailure, watchAllowed } from "./dev-server"
 import { bundle } from "./bundler"
 
-let currentWatcher: ReturnType<typeof watch> | null = null
+let watchers: ReturnType<typeof watch>[] = []
 
 export function stopWatcher() {
-  if (currentWatcher) {
-    currentWatcher.close()
-    currentWatcher = null
+  for (let w of watchers) w.close()
+  watchers = []
+}
+
+async function rebuild(filename: string) {
+  if (!(await watchAllowed())) {
+    print(`[cli] Change detected: ${filename} (auto-reload paused by agent; "watch on" resumes)`)
+    return
   }
+
+  print(`[cli] Change detected: ${filename}`)
+  let result = await bundle(state.source)
+  if (!result) {
+    printErr("[cli] Build failed, waiting for changes...")
+    await showBuildFailure()
+    return
+  }
+  state.currentCode = result.code
+  state.currentMap = result.map
+  state.currentManifest = result.manifest
+  await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
+    latch: true,
+    map: state.currentMap,
+  })
 }
 
 export function startWatcher() {
   if (!state.source) return
   let watchDir = dirname(resolve(state.source))
 
-  if (currentWatcher) currentWatcher.close()
+  stopWatcher()
+
+  // An asset edit re-pushes too: the assets/ tree is part of the manifest, so
+  // clients install the new version. The tree roots at the project dir; the
+  // project dir is an ancestor of (or equal to) the entry's dir, so assets/
+  // is inside watchDir exactly when they are the same dir. An assets/ folder
+  // created after startup needs a restart or `load` to be picked up.
+  let assetsDir = resolve(state.projectDir, "assets")
+  let covered = resolve(state.projectDir) === watchDir
+  let isAsset = (filename: string) =>
+    (filename === "assets" || filename.startsWith("assets" + sep)) && !basename(filename).startsWith(".")
 
   print(`[cli] Watching ${watchDir} for changes...`)
-  currentWatcher = watch(watchDir, { recursive: true }, async (_event, filename) => {
-    if (!filename) return
-    if (!/\.(tsx?|jsx?)$/.test(filename)) return
-
-    if (!(await watchAllowed())) {
-      print(`[cli] Change detected: ${filename} (auto-reload paused by agent; "watch on" resumes)`)
-      return
-    }
-
-    print(`[cli] Change detected: ${filename}`)
-    let result = await bundle(state.source)
-    if (!result) {
-      printErr("[cli] Build failed, waiting for changes...")
-      await showBuildFailure()
-      return
-    }
-    state.currentCode = result.code
-    state.currentMap = result.map
-    await sendReload(buildReload({ code: state.currentCode }), { latch: true, map: state.currentMap })
-  })
+  watchers.push(
+    watch(watchDir, { recursive: true }, (_event, filename) => {
+      if (!filename) return
+      if (!/\.(tsx?|jsx?)$/.test(filename) && !(covered && isAsset(filename))) return
+      rebuild(filename)
+    }),
+  )
+
+  if (!covered && existsSync(assetsDir)) {
+    watchers.push(
+      watch(assetsDir, { recursive: true }, (_event, filename) => {
+        if (!filename || basename(filename).startsWith(".")) return
+        rebuild("assets" + sep + filename)
+      }),
+    )
+  }
 }