@solidrt/cli 0.0.49 → 0.0.51

package/src/commands/server.ts

@@ -2,8 +2,8 @@ import pkg from "../../package.json"
 import { source, isSource, isPrebuilt, values } from "../args"
 import { state, shutdown, print, printErr } from "../util"
 import { findProjectRoot, typecheck, reportTypes } from "./check"
-import { bundle } from "../bundler"
-import { buildManifest, projectDirFor } from "../project"
+import { bundle, bundleMaps, prebuiltManifest } from "../bundler"
+import { projectDirFor } from "../project"
 import { startServer, buildReload, sendReload, showBuildFailure } from "../dev-server"
 import { startRepl } from "../repl"
 import { startWatcher } from "../watcher"
@@ -34,11 +34,11 @@ export async function runServerCommand() {
     let initialResult = await bundle()
     if (initialResult) {
       state.currentCode = initialResult.code
-      state.currentMap = initialResult.map
+      state.currentMaps = bundleMaps(initialResult)
       state.currentManifest = initialResult.manifest
       await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
         latch: true,
-        map: state.currentMap,
+        maps: state.currentMaps,
       })
     } else {
       await showBuildFailure()
@@ -46,7 +46,7 @@ export async function runServerCommand() {
   } else if (source && isPrebuilt && source.endsWith(".srt.js")) {
     let path = resolve(source)
     state.currentCode = await Bun.file(path).text()
-    state.currentManifest = buildManifest(state.currentCode, path)
+    state.currentManifest = prebuiltManifest(state.currentCode, path, state.projectDir)
     await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), { latch: true })
   }
 

package/src/dev-server.ts

@@ -28,8 +28,7 @@ export let DEV_PORT = resolveDevPort()
 
 // The dev server itself is a flux script (packages/cli/server/), spawned by
 // srt: bundling, file watching, and the repl stay here and drive the server
-// process over its loopback-only /__internal__/ routes. See
-// docs/flux-dev-server-plan.md.
+// process over its loopback-only /__internal__/ routes.
 
 const INTERNAL_BASE = `http://${DEV_HOST}:${DEV_PORT}/__internal__`
 
@@ -62,9 +61,10 @@ async function post(path: string, body: object) {
  * or to every client when omitted. `latch` keeps the message for late-joining
  * clients (code reloads latch, one-shot bytecode loads do not); `sourceDir`
  * moves the server's file-serving root (repl `load`; the project root is
- * fixed for the life of the run); `map` is the bundle's sourcemap, kept
- * server-side for stack-trace remapping (omitting it clears the server's map,
- * so a mapless reload never remaps against a stale one).
+ * fixed for the life of the run); `maps` is the bundle's sourcemaps keyed by
+ * module name ("main", each isolate id), kept server-side for stack-trace
+ * remapping (omitting it clears the server's maps, so a mapless reload never
+ * remaps against stale ones).
  */
 export async function sendReload(
   message: object,
@@ -73,7 +73,7 @@ export async function sendReload(
     latch?: boolean
     sourceDir?: string
     entry?: string
-    map?: string | null
+    maps?: Record<string, string> | null
   } = {},
 ) {
   await post("/reload", { message, ...opts })
@@ -291,7 +291,7 @@ export async function startServer() {
   process.on("exit", removeLiveRecord)
 
   // mDNS advertise (dropped, code kept for future use - see
-  // docs/flux-dev-server-plan.md): the p2p ticket is the cross-device connect
+  // okf/backlog/mdns-discovery.md): the p2p ticket is the cross-device connect
   // story now. If advertise returns, it belongs next to the server (a flux
   // capability), not here.
   //

package/src/packer.ts

@@ -1,18 +1,18 @@
 import { existsSync, readFileSync } from "node:fs"
 import { dirname, join } from "node:path"
 import { requireBinary } from "./util"
-import { compileToBytecode } from "./bundler"
 import type { PackFolder } from "./pack-folder"
 
-// Trailer magic identifying the runner an embedded payload belongs to. Must match
-// the runner-side checks: fluxrt -> flux/src/bin/fluxrt.rs, solidrt ->
-// lattice/src/main.rs (load_embedded_payload).
+// Trailer magic identifying the runner an embedded payload belongs to. Must
+// match the runner-side checks: both runners parse the trailer through
+// forge/src/trailer.rs (readers: lattice/src/main.rs, flux/src/bin/fluxrt.rs).
 const MAGIC = {
   fluxrt: Buffer.from([0x46, 0x4c, 0x55, 0x58, 0x52, 0x54, 0x88, 0x44]), // "FLUXRT\x88\x44"
   solidrt: Buffer.from([0x53, 0x4f, 0x4c, 0x49, 0x44, 0x52, 0x54, 0x88, 0x44]), // "SOLIDRT\x88\x44"
 }
 
-// Section kinds in the solidrt trailer. Must match lattice/src/main.rs.
+// Section kinds in the trailer. Must match forge/src/trailer.rs (fluxrt only
+// consumes kind-2 file sections; solidrt consumes all three).
 const SECTION_MANIFEST = 1
 const SECTION_FILE = 2
 const SECTION_GL_LIB = 3
@@ -92,12 +92,16 @@ export function packSolid(folder: PackFolder, bytecode: Buffer): Buffer {
   return packSections(runnerBytes, sections, MAGIC.solidrt)
 }
 
-// Compile JS to bytecode and append it to the fluxrt runner as its
-// single-payload trailer: [bytecode][u64 offset LE][8-byte magic].
-export async function packFlux(jsCode: string): Promise<Buffer> {
-  let bytecode = await compileToBytecode(jsCode)
+// The single-file flux executable: the fluxrt runner plus the program in the
+// same section trailer packSolid uses, kind-2 file sections only -
+// "bundle.bin" is the program, each isolate module "isolates/<id>.bin".
+// Like packSolid, this assembles precompiled bytecode; the pack command
+// compiles.
+export function packFlux(bytecode: Buffer, isolates: { id: string; bytecode: Buffer }[] = []): Buffer {
   let runnerBytes = readFileSync(requireBinary("fluxrt"))
-  let offsetBuf = Buffer.allocUnsafe(8)
-  offsetBuf.writeBigUInt64LE(BigInt(runnerBytes.length))
-  return Buffer.concat([runnerBytes, bytecode, offsetBuf, MAGIC.fluxrt])
+  let sections: Section[] = [
+    { kind: SECTION_FILE, bytes: bytecode, name: "bundle.bin" },
+    ...isolates.map((i) => ({ kind: SECTION_FILE, bytes: i.bytecode, name: `isolates/${i.id}.bin` })),
+  ]
+  return packSections(runnerBytes, sections, MAGIC.fluxrt)
 }

package/src/prompt.ts

@@ -1,18 +1,21 @@
-import { createInterface, emitKeypressEvents } from "node:readline"
+import * as clack from "@clack/prompts"
+
+// Thin wrappers over @clack/prompts. Every prompt guards on a TTY: a non-TTY
+// stdin resolves the default rather than blocking on input that will never
+// arrive. Cancelling (ctrl-c) exits the process.
+
+function unwrap<T>(value: T | symbol): T {
+  if (clack.isCancel(value)) {
+    clack.cancel("Cancelled")
+    process.exit(130)
+  }
+  return value as T
+}
 
-// Single-line text prompt with an optional default (shown in parentheses, used
-// when the answer is blank). Non-TTY stdin resolves the default rather than
-// blocking on input that will never arrive.
-export function text(message: string, def = ""): Promise<string> {
-  return new Promise<string>((resolve) => {
-    if (!process.stdin.isTTY) return resolve(def)
-    let rl = createInterface({ input: process.stdin, output: process.stdout })
-    let suffix = def ? ` (${def})` : ""
-    rl.question(`? ${message}${suffix}: `, (answer) => {
-      rl.close()
-      resolve(answer.trim() || def)
-    })
-  })
+// Single-line text prompt; a blank answer resolves the default.
+export async function text(message: string, def = ""): Promise<string> {
+  if (!process.stdin.isTTY) return def
+  return unwrap(await clack.text({ message, defaultValue: def, placeholder: def }))
 }
 
 export interface SelectOption {
@@ -20,65 +23,36 @@ export interface SelectOption {
   value: string
 }
 
-// Minimal arrow-key single-select prompt, built on node:readline (same
-// dependency-free approach as repl.ts). Renders the option list, moves the
-// highlight on up/down, resolves the chosen value on enter. Options are plain
-// strings or { label, value } pairs when the display text differs from the
-// resolved value. Callers guard on process.stdin.isTTY; a non-TTY stdin here
-// resolves the first option rather than hanging on input that will never
-// arrive.
-export function select(message: string, options: Array<string | SelectOption>): Promise<string> {
+// Arrow-key single-select; non-TTY resolves the first option.
+export async function select(message: string, options: Array<string | SelectOption>): Promise<string> {
   let items = options.map((o) => (typeof o === "string" ? { label: o, value: o } : o))
-  return new Promise((resolve) => {
-    let input = process.stdin
-    let output = process.stdout
-    if (!input.isTTY) return resolve(items[0]!.value)
-
-    let selected = 0
-    emitKeypressEvents(input)
-    let wasRaw = input.isRaw
-    input.setRawMode(true)
-
-    let render = (first = false) => {
-      // After the first paint the cursor sits below the block; move it back up
-      // to the message line so the list redraws in place.
-      if (!first) output.write(`\x1b[${items.length + 1}A`)
-      output.write(`\x1b[K? ${message}\n`)
-      for (let i = 0; i < items.length; i++) {
-        let active = i === selected
-        let pointer = active ? "\x1b[36m> " : "  "
-        let reset = active ? "\x1b[0m" : ""
-        output.write(`\x1b[K${pointer}${items[i]!.label}${reset}\n`)
-      }
-    }
-
-    let cleanup = () => {
-      input.off("keypress", onKey)
-      input.setRawMode(wasRaw)
-      input.pause()
-    }
+  if (!process.stdin.isTTY) return items[0]!.value
+  return unwrap(await clack.select({ message, options: items }))
+}
 
-    let onKey = (_str: string, key: { name: string; ctrl: boolean } | undefined) => {
-      if (!key) return
-      if (key.name === "up") {
-        selected = (selected - 1 + items.length) % items.length
-        render()
-      } else if (key.name === "down") {
-        selected = (selected + 1) % items.length
-        render()
-      } else if (key.name === "return" || key.name === "enter") {
-        cleanup()
-        output.write("\n")
-        resolve(items[selected]!.value)
-      } else if (key.ctrl && (key.name === "c" || key.name === "d")) {
-        cleanup()
-        output.write("\n")
-        process.exit(130)
-      }
-    }
+export interface MultiSelectOption {
+  label: string
+  value: string
+  checked?: boolean
+}
 
-    input.on("keypress", onKey)
-    input.resume()
-    render(true)
-  })
+// Space toggles, enter confirms; resolves the selected values in option
+// order. Non-TTY resolves the preselected values.
+export async function multiselect(message: string, options: MultiSelectOption[]): Promise<string[]> {
+  let preset = options.filter((o) => o.checked).map((o) => o.value)
+  if (!process.stdin.isTTY) return preset
+  let picked = unwrap(
+    await clack.multiselect({
+      message,
+      options: options.map((o) => ({ label: o.label, value: o.value })),
+      initialValues: preset,
+      required: false,
+    }),
+  )
+  return options.filter((o) => picked.includes(o.value)).map((o) => o.value)
 }
+
+// Boxed informational message; silent on a non-TTY.
+export function note(message: string, title?: string) {
+  if (process.stdin.isTTY) clack.note(message, title)
+}

package/src/repl.ts

@@ -3,8 +3,7 @@ import { resolve, dirname } from "path"
 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 } from "./project"
+import { bundle, bundleMaps, prebuiltManifest } from "./bundler"
 import { startWatcher, stopWatcher } from "./watcher"
 
 // Resolve repl client indexes ("0 2") against the server's client list,
@@ -28,7 +27,7 @@ async function cmdStop(args: string) {
   if (!args) {
     stopWatcher()
     state.currentCode = null
-    state.currentMap = null
+    state.currentMaps = null
     state.currentManifest = null
     state.source = undefined
     await sendStop()
@@ -51,18 +50,18 @@ async function cmdReload(args: string) {
       return
     }
     state.currentCode = result.code
-    state.currentMap = result.map
+    state.currentMaps = bundleMaps(result)
     state.currentManifest = result.manifest
   }
   let msg = buildReload({ code: state.currentCode, manifest: state.currentManifest })
   if (!args) {
-    await sendReload(msg, { latch: true, map: state.currentMap })
+    await sendReload(msg, { latch: true, maps: state.currentMaps })
     print("[cli] Sent reload to all clients")
     return
   }
   let ids = await indexesToIds(args)
   if (ids.length) {
-    await sendReload(msg, { clients: ids, map: state.currentMap })
+    await sendReload(msg, { clients: ids, maps: state.currentMaps })
     print(`[cli] Sent reload to client(s) ${ids.join(", ")}`)
   }
 }
@@ -104,7 +103,13 @@ async function cmdLoad(file: string) {
   // Same rule as /__control__/load (control.ts): a server run serves the
   // project it started in, and an entry outside the project root cannot
   // resolve the project's dependencies anyway.
-  let norm = (p: string) => p.replace(/\\/g, "/")
+  // Windows paths are case-insensitive and the same drive shows up as both
+  // `c:` and `C:` (an editor-spawned bridge keeps its parent's spelling), so a
+  // drive-letter path folds case; a POSIX path stays exact.
+  let norm = (p: string) => {
+    let s = p.replace(/\\/g, "/")
+    return /^[a-zA-Z]:\//.test(s) ? s.toLowerCase() : s
+  }
   let root = norm(state.projectDir).replace(/\/+$/, "") + "/"
   if (!norm(path).startsWith(root)) {
     printErr(`[cli] Entry is outside the project root: ${path} is not under ${state.projectDir}. Restart srt in that project to work on it.`)
@@ -117,12 +122,12 @@ async function cmdLoad(file: string) {
       return
     }
     state.currentCode = result.code
-    state.currentMap = result.map
+    state.currentMaps = bundleMaps(result)
     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)
+    state.currentMaps = null
+    state.currentManifest = prebuiltManifest(state.currentCode, path, state.projectDir)
   } 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.
@@ -144,7 +149,7 @@ async function cmdLoad(file: string) {
     latch: true,
     sourceDir: state.sourceDir,
     entry: file.endsWith(".tsx") ? path : undefined,
-    map: state.currentMap,
+    maps: state.currentMaps,
   })
   print(`[cli] Loaded ${file}`)
 }
@@ -185,6 +190,17 @@ function guard(p: Promise<void>) {
 }
 
 export function startRepl() {
+  // Without a terminal there is nobody to prompt, and stdin is at EOF from the
+  // start: readline would fire `close` immediately and shutdown() would tear
+  // down the server, the client and the registry record about a second after
+  // boot. A backgrounded or supervisor-launched srt therefore runs with no
+  // repl at all, kept alive by the server process and the watcher, and stopped
+  // with a signal. See okf/backlog/srt-run-exits-on-stdin-eof.md.
+  if (!process.stdin.isTTY) {
+    print("[cli] No terminal on stdin, running without the repl")
+    return
+  }
+
   state.rl = createInterface({ input: process.stdin, output: process.stdout, completer })
   state.rl.setPrompt("srt> ")
 

package/src/util.ts

@@ -8,9 +8,10 @@ export let state = {
   // What srt believes the current bundle is; the server process keeps its own
   // latched copy for late-joining clients (see packages/cli/server/).
   currentCode: null as string | null,
-  // 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 composed sourcemaps (dev builds), keyed by module name
+  // ("main", each isolate id), sent to the server alongside reloads so it can
+  // remap logged stack traces to .tsx positions.
+  currentMaps: null as Record<string, 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,

package/src/watcher.ts

@@ -2,7 +2,7 @@ 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"
+import { bundle, bundleMaps } from "./bundler"
 
 let watchers: ReturnType<typeof watch>[] = []
 
@@ -25,11 +25,11 @@ async function rebuild(filename: string) {
     return
   }
   state.currentCode = result.code
-  state.currentMap = result.map
+  state.currentMaps = bundleMaps(result)
   state.currentManifest = result.manifest
   await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
     latch: true,
-    map: state.currentMap,
+    maps: state.currentMaps,
   })
 }
 
@@ -53,6 +53,10 @@ export function startWatcher() {
   watchers.push(
     watch(watchDir, { recursive: true }, (_event, filename) => {
       if (!filename) return
+      // Dot directories are never sources: .srt-data in particular is this
+      // server's own output (isolate bundles are .js files in there), and
+      // rebuilding on it would rebuild forever.
+      if (filename.split(sep).some((part, i, parts) => i < parts.length - 1 && part.startsWith("."))) return
       if (!/\.(tsx?|jsx?)$/.test(filename) && !(covered && isAsset(filename))) return
       rebuild(filename)
     }),

package/scaffold/templates/components/template.json

@@ -1,4 +0,0 @@
-{
-  "level": "components",
-  "description": "components starter application"
-}

package/scaffold/templates/default/template.json

@@ -1,4 +0,0 @@
-{
-  "level": "core",
-  "description": "core starter application"
-}