@solidrt/cli 0.0.50 → 0.0.52

package/src/server/mode.ts

@@ -0,0 +1,92 @@
+// What this server serves, decided by the cwd and the entry argument and
+// never by searching upward. The rule and its table live in
+// packages/cli/src/lib/mode.ts (the bun copy the one-shot commands use); this is
+// the same table for the server, over flux:fs - two honest copies rather
+// than an fs shim (okf/done/srt-command-folders.md):
+//
+//   cwd has package.json   argument   mode
+//   yes                    none       project (entry = solidrt.entry, default src/index.tsx)
+//   no                     none       error
+//   no                     file       file
+//   yes                    file       error, unless --project (project at cwd,
+//                                     entry overridden) or --file (ignore the project)
+//
+// The key (the canonical project root, or the canonical file path) is what
+// the registry and every control response name.
+
+import { file, realpath } from "flux:fs"
+import { join } from "flux:path"
+import { fail } from "./args"
+
+export type Mode =
+  | { mode: "project"; key: string; projectDir: string; entry: string }
+  | { mode: "file"; key: string; projectDir: null; entry: string }
+
+const DEFAULT_ENTRY = "src/index.tsx"
+// A prebuilt .srt.js ends with .js, so it is admitted by the same list.
+export const ENTRY_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"]
+
+export async function resolveMode(args: { entry: string | undefined; project: boolean; file: boolean }): Promise<Mode> {
+  let cwd = await realpath(".")
+  let hasPkg = await file(join(cwd, "package.json")).exists()
+  let source = args.entry
+
+  if (source !== undefined && !ENTRY_EXTENSIONS.some((ext) => source.endsWith(ext))) {
+    fail(`Not an app entry: ${source} (expected .tsx, .jsx, .ts, .js or .srt.js)`)
+  }
+  if (source !== undefined && !(await file(source).exists())) fail(`Entry not found: ${source}`)
+  if (args.file && args.project) fail("--file and --project exclude each other")
+
+  if (source === undefined) {
+    if (args.file || args.project) fail("--file and --project need an entry file")
+    if (!hasPkg) fail(`No package.json in ${cwd}. Run from the project root, or pass a file to use on its own.`)
+    let declared = await declaredEntry(cwd)
+    let entry = join(cwd, declared ?? DEFAULT_ENTRY)
+    if (!(await file(entry).exists())) {
+      fail(`Entry not found: ${entry}${declared ? "" : ' (set "solidrt": { "entry": ... } in package.json)'}`)
+    }
+    return { mode: "project", key: cwd, projectDir: cwd, entry }
+  }
+
+  let entry = await realpath(source)
+  if (hasPkg && !args.file && !args.project) {
+    fail(
+      `${cwd} is a project (it has a package.json) and ${source} is a file: pass --project to use the project with this entry, or --file to use the file on its own.`,
+    )
+  }
+  if (hasPkg && args.project) return { mode: "project", key: cwd, projectDir: cwd, entry }
+  if (!hasPkg && args.project) fail(`--project needs a package.json in ${cwd}`)
+  return { mode: "file", key: entry, projectDir: null, entry }
+}
+
+// The project's declared entry (`"solidrt": { "entry" }` in package.json),
+// relative to the project root. Only the one field the server needs is
+// checked here; the bun commands validate the whole key (src/lib/project.ts).
+async function declaredEntry(dir: string): Promise<string | undefined> {
+  let pkg = await file(join(dir, "package.json"))
+    .json()
+    .catch(() => fail(`Unreadable package.json in ${dir}`))
+  let config = pkg?.solidrt
+  if (config === undefined) return undefined
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    fail('"solidrt" in package.json must be an object')
+  }
+  if ("entry" in config && typeof config.entry !== "string") fail('"solidrt": "entry" must be a string')
+  return config.entry
+}
+
+/** The directory the file routes serve: the entry's directory. */
+export function sourceDirOf(mode: Mode): string {
+  return dirname(mode.entry)
+}
+
+/** The parent of a path (flux:path has no dirname); "." for a bare name. */
+export function dirname(path: string): string {
+  let i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"))
+  return i <= 0 ? (i === 0 ? path.slice(0, 1) : ".") : path.slice(0, i)
+}
+
+/** `path` made absolute against `base` when it is not already. */
+export function absolute(path: string, base: string): string {
+  return /^([A-Za-z]:)?[\\/]/.test(path) ? path : join(base, path)
+}

package/src/server/rebuild.ts

@@ -0,0 +1,90 @@
+import { command } from "flux:subprocess"
+import { dir, file } from "flux:fs"
+import { state } from "./state"
+import { armWatcher } from "./watcher"
+import type { BundleOutput } from "../types/bundle"
+
+// The single rebuild-and-push path: the initial bundle at start, every
+// MCP reload and every reload-on-save go through here. The bundle itself
+// runs in a bun subprocess (`srt bundle --json`, the one thing only bun can
+// do); this side latches the result for late-joining clients, broadcasts
+// it, and re-arms the watcher from the bundle's inputs (watcher.ts).
+
+// Build the reload message for the client protocol. `manifest` is the
+// bundle's version manifest JSON string; when present, clients install the
+// push into their version store before applying it (absent for the
+// build-failure trigger, which must never be installed). proxyHttp is a
+// message flag, not a build input.
+function buildReload(code: string, manifest?: string) {
+  let config = state.config
+  return {
+    type: "reload",
+    proxyHttp: config.proxyHttp,
+    args: config.args,
+    ...(manifest ? { manifest } : {}),
+    code,
+  }
+}
+
+// Reload code that fails to start the engine on purpose. The runtime treats a
+// startup error like any app that never called render() and falls back to its
+// baked-in BSOD screen, so a build that doesn't compile shows the BSOD instead
+// of leaving the previous app frozen on screen.
+const BSOD_TRIGGER = `throw new Error("SolidRT: build failed")`
+
+function latchAndSend(text: string) {
+  state.currentReload = text
+  for (let [ws, info] of state.clients) {
+    // The runtime restarts the app's clock with the app.
+    info.timeScale = 1
+    ws.send(text)
+  }
+}
+
+/** Latch the build-failure trigger and push it, so every client (and any
+ * that connects later) shows the BSOD instead of a stale app. */
+export function showBuildFailure() {
+  state.currentMaps = null
+  latchAndSend(JSON.stringify(buildReload(BSOD_TRIGGER)))
+}
+
+// Rebuild from config.entry via `srt bundle --json` (a bun subprocess run
+// in config.cwd with config.entryArgs, so it resolves the mode this server
+// did), then latch (for late-joining clients) and broadcast the reload to
+// every connected client. Resolves with an error message on failure (a build
+// error), or null on success.
+export async function rebuildAndBroadcast(): Promise<string | null> {
+  let config = state.config
+  let args = [...config.srt.slice(1), "bundle", "--json", "--dev", ...config.entryArgs]
+  if (config.minify) args.push("--minify")
+
+  let result = await command(config.srt[0]!, args, { cwd: config.cwd }).output()
+  if (!result.success) {
+    let stderr = typeof result.stderr === "string" ? result.stderr : ""
+    armWatcher(null)
+    return `Rebuild failed:\n${stderr.trim()}`
+  }
+
+  // The bundle is one JSON object on stdout (types/bundle.d.ts).
+  let bundle: BundleOutput
+  try {
+    bundle = JSON.parse(typeof result.stdout === "string" ? result.stdout : "")
+  } catch {
+    armWatcher(null)
+    return "Rebuild failed: unreadable bundler output"
+  }
+  armWatcher(bundle.inputs ?? null)
+  // Isolate bundles are manifest assets clients fetch from our /isolates/
+  // route (served from cacheDir), so they must be on disk before the push.
+  let maps: Record<string, string> = {}
+  if (bundle.map) maps.main = bundle.map
+  for (let isolate of bundle.isolates ?? []) {
+    let path = `${config.cacheDir}/isolates/${isolate.id}.js`
+    await dir(path.slice(0, path.lastIndexOf("/"))).create()
+    await file(path).write(isolate.code)
+    if (isolate.map) maps[isolate.id] = isolate.map
+  }
+  state.currentMaps = Object.keys(maps).length ? maps : null
+  latchAndSend(JSON.stringify(buildReload(bundle.code ?? "", bundle.manifest)))
+  return null
+}

package/src/server/registry.ts

@@ -0,0 +1,138 @@
+// The dev server registry: ~/.solidrt/servers/<key hash>/live.json, one
+// folder per server key, written by the server itself once its port is
+// bound and removed when it exits, so `srt client`, `srt mcp` and the
+// console resolve a server without any per-project config
+// (okf/backlog/cli-flux-migration.md). The process that owns the pid and the
+// port owns the record, so a record whose pid is dead is stale and nothing
+// else; readers still confirm with a control call. The bun readers live in
+// packages/cli/src/lib/registry.ts and dev-dir.ts (the same paths and hash).
+//
+// The folder also remembers the last bound port so the next run tries it
+// first: a project keeps its port in practice, and tunnel tickets and client
+// recents stay valid, without anyone choosing a number.
+
+import { dir, file, realpath } from "flux:fs"
+import { join } from "flux:path"
+import { alive, homedir, pid } from "flux:process"
+import { fail } from "./args"
+import type { ServerConfig } from "./config"
+import type { LiveRecord } from "../types/registry"
+
+const RECORD_FILE = "live.json"
+const PORT_FILE = "port"
+
+/** All dev-tooling state lives in ~/.solidrt (one rule on every platform). */
+export function devDir(...parts: string[]): string {
+  let home = homedir()
+  if (!home) fail("No home directory: the dev server keeps its state under ~/.solidrt")
+  return join(home, ".solidrt", ...parts)
+}
+
+/** A server's folder: `servers/<sha256 of its canonical key, truncated>/`.
+ * The name is never parsed back; live.json inside is the record. */
+export async function serverDirFor(key: string): Promise<string> {
+  let digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key))
+  let hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("")
+  return devDir("servers", hex.slice(0, 16))
+}
+
+type Entry = { path: string; record: LiveRecord }
+
+// Every well-formed record on disk, alive or not, with its file path.
+// Malformed records are skipped, not fatal.
+async function records(): Promise<Entry[]> {
+  let root = devDir("servers")
+  let entries = await dir(root)
+    .entries()
+    .catch(() => [])
+  let found: Entry[] = []
+  for (let entry of entries) {
+    if (entry.type !== "directory") continue
+    let path = join(root, entry.name, RECORD_FILE)
+    let record = await file(path)
+      .json()
+      .catch(() => null)
+    if (typeof record?.pid === "number" && typeof record?.port === "number" && typeof record?.key === "string") {
+      found.push({ path, record })
+    }
+  }
+  return found
+}
+
+/** Every readable record whose process is alive. */
+export async function liveRecords(): Promise<LiveRecord[]> {
+  return (await records()).filter((e) => alive(e.record.pid)).map((e) => e.record)
+}
+
+/** Drop every record whose process is gone. A server removes its own record
+ * on exit, so one left behind is a crash's fossil. Runs at server start, the
+ * one moment every registry user passes through, so readers never write. */
+export async function pruneDeadRecords() {
+  for (let { path, record } of await records()) {
+    if (!alive(record.pid)) await file(path).remove().catch(() => {})
+  }
+}
+
+// Whether the control API on the record's port answers for the record's key:
+// every control response names the key it serves.
+async function serves(record: LiveRecord): Promise<boolean> {
+  let control = new AbortController()
+  let timer = setTimeout(() => control.abort(), 1000)
+  try {
+    let resp = await fetch(`http://127.0.0.1:${record.port}/__control__/clients`, { signal: control.signal })
+    return resp.headers.get("x-solidrt-project") === record.key
+  } catch {
+    return false
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/** The running server for the canonical `key`, if any. Keys from different
+ * processes agree on the path, not the spelling, so compare canonical. The
+ * record is a hint and the server is authoritative: a candidate whose server
+ * does not answer for the key is a pid reused by an unrelated process, and
+ * is dropped instead of reported as a clash. */
+export async function runningFor(key: string): Promise<LiveRecord | undefined> {
+  for (let { path, record } of await records()) {
+    if (!alive(record.pid)) continue
+    if (record.key === key || (await realpath(record.key).catch(() => null)) === key) {
+      if (await serves(record)) return record
+      await file(path).remove().catch(() => {})
+    }
+  }
+  return undefined
+}
+
+/** The port this server bound last time, or null on a first run. */
+export async function rememberedPort(serverDir: string): Promise<number | null> {
+  let text = await file(join(serverDir, PORT_FILE))
+    .text()
+    .catch(() => "")
+  let port = Number(text.trim())
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null
+}
+
+/** Write the record and remember the port. */
+export async function writeRecord(config: ServerConfig, port: number, address: string) {
+  await dir(config.serverDir).create()
+  let record: LiveRecord = {
+    pid,
+    port,
+    address,
+    key: config.key,
+    mode: config.mode,
+    entry: config.entry,
+    projectDir: config.projectDir,
+    started: new Date().toISOString(),
+  }
+  await file(join(config.serverDir, RECORD_FILE)).write(JSON.stringify(record))
+  await file(join(config.serverDir, PORT_FILE)).write(String(port))
+}
+
+/** Drop the record; the port memory and the tunnel key stay. */
+export async function removeRecord(serverDir: string) {
+  await file(join(serverDir, RECORD_FILE))
+    .remove()
+    .catch(() => {})
+}

package/src/server/remap.ts

@@ -0,0 +1,60 @@
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping"
+
+// Stack-trace remapping for forwarded client logs. The runtime evaluates the
+// app bundle as module "main" and each isolate bundle under its isolate id,
+// so QuickJS frames cite bundle positions like "at boom (main:212:9)" or
+// "at boom (worker:65:13)". With the current reload's sourcemaps latched on
+// the server (state.currentMaps, keyed by module name), those positions are
+// rewritten to the original .tsx sources before a log entry is buffered. A
+// module without a map is left as it is: a position is never remapped against
+// another module's map.
+
+// Parsed maps are cached per module name and map text; a reload swaps the
+// texts and the next lookup rebuilds the tracers. Entries for removed modules
+// linger unused, which is harmless.
+let cached = new Map<string, { text: string; tracer: TraceMap | null }>()
+
+function tracerFor(name: string, text: string): TraceMap | null {
+  let entry = cached.get(name)
+  if (!entry || entry.text !== text) {
+    let tracer: TraceMap | null = null
+    try {
+      tracer = new TraceMap(JSON.parse(text))
+    } catch {
+      // A malformed map disables remapping for this module until the next reload.
+    }
+    entry = { text, tracer }
+    cached.set(name, entry)
+  }
+  return entry.tracer
+}
+
+let REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g
+
+/**
+ * Rewrite every "NAME:LINE:COL" (or "NAME:LINE") position in `text`, for each
+ * module NAME in `maps`, to its original source position, e.g.
+ * "src/app.tsx:42:7". Positions a map has no entry for, positions of modules
+ * without a map, and all text when `maps` is null, pass through unchanged.
+ * QuickJS lines and columns are 1-based; sourcemap columns are 0-based.
+ */
+export function remapPositions(text: string, maps: Record<string, string> | null): string {
+  if (!maps) return text
+  for (let [name, map] of Object.entries(maps)) {
+    if (!text.includes(name + ":")) continue
+    let t = tracerFor(name, map)
+    if (!t) continue
+    // The leading capture keeps a name from matching inside a longer one
+    // ("audio" inside "workers/audio" or "app" inside "src/app.tsx").
+    let pattern = new RegExp(`(^|[^\\w/.$-])${name.replace(REGEX_SPECIALS, "\\$&")}:(\\d+)(?::(\\d+))?\\b`, "g")
+    text = text.replace(pattern, (frame, prefix, line, column) => {
+      let pos = originalPositionFor(t, {
+        line: parseInt(line, 10),
+        column: column ? Math.max(parseInt(column, 10) - 1, 0) : 0,
+      })
+      if (pos.source == null || pos.line == null) return frame
+      return `${prefix}${pos.source}:${pos.line}:${(pos.column ?? 0) + 1}`
+    })
+  }
+  return text
+}

package/src/server/repl.ts

@@ -0,0 +1,223 @@
+import { isTTY, on, write } from "flux:tty"
+import { dir } from "flux:fs"
+import type { ServerWebSocket } from "flux:http"
+import { state } from "./state"
+import { rebuildAndBroadcast, showBuildFailure } from "./rebuild"
+import { clientList, loadEntry, setStats, setUserInputMuted, setWatchActive } from "./control"
+import { ENTRY_EXTENSIONS, absolute } from "./mode"
+import { startLineEditor } from "./line-editor"
+import type { Completion } from "./line-editor"
+
+// The repl on the server's own terminal: the same actions the control API
+// offers a coding agent, typed by hand. A line editor over flux:tty raw mode
+// (line-editor.ts: history, Tab completion of commands and `load` paths);
+// where raw mode is refused, cooked lines from the terminal's own line
+// discipline. Only with a terminal on stdin: a server started by a
+// supervisor, the console or a background `&` has none, runs without a
+// prompt, and stops on a signal.
+
+const PROMPT = "srt> "
+const HELP = "Commands: load <file>, reload [id...], stop [id...], list, stats [on|off], watch on|off, mute on|off, quit, help"
+const COMMANDS = ["load ", "reload", "stop", "list", "stats", "watch ", "mute ", "quit", "exit", "help"]
+
+// The clients named by a list of ids ("0 2", as `list` prints them), or
+// every client for no ids. Unknown ids are reported and skipped.
+function targets(args: string): ServerWebSocket[] {
+  let entries = [...state.clients.entries()]
+  if (!args) return entries.map(([ws]) => ws)
+  let found: ServerWebSocket[] = []
+  for (let token of args.split(/\s+/)) {
+    let id = parseInt(token, 10)
+    let entry = entries.find(([, info]) => info.id === id)
+    if (!entry) {
+      console.log(`No client with id ${token}`)
+      continue
+    }
+    found.push(entry[0])
+  }
+  return found
+}
+
+function describe(args: string, count: number): string {
+  return args ? `client(s) ${args.split(/\s+/).join(", ")}` : `all ${count} client(s)`
+}
+
+async function cmdReload(args: string) {
+  let error = await rebuildAndBroadcast()
+  if (error) {
+    console.error(error)
+    showBuildFailure()
+    return
+  }
+  if (args) {
+    // rebuildAndBroadcast pushed to everyone; a selective reload re-sends
+    // the latched bundle to the named clients only, which is what it meant
+    // before the push existed. Kept for the one case it still serves: a
+    // client that missed the broadcast.
+    for (let ws of targets(args)) if (state.currentReload) ws.send(state.currentReload)
+  }
+  console.log(`[cli] Sent reload to ${describe(args, state.clients.size)}`)
+}
+
+function cmdStop(args: string) {
+  let text = JSON.stringify({ type: "stop" })
+  let list = targets(args)
+  for (let ws of list) ws.send(text)
+  if (list.length) console.log(`[cli] Sent stop to ${describe(args, list.length)}`)
+}
+
+async function cmdLoad(file: string) {
+  if (!file) {
+    console.log("Usage: load <file>")
+    return
+  }
+  let result = await loadEntry(file)
+  if ("error" in result) {
+    console.error(result.error)
+    if (result.status === 502) showBuildFailure()
+    return
+  }
+  console.log(`[cli] Loaded ${result.entry}`)
+}
+
+function cmdList() {
+  let clients = clientList(true)
+  if (clients.length === 0) {
+    console.log("No connected clients")
+    return
+  }
+  console.log(`${clients.length} connected client(s):`)
+  for (let c of clients) {
+    console.log(`  ${c.id}: ${c.address ?? "unknown"} [${c.platform}, ${c.version}]`)
+  }
+}
+
+// "on" | "off" | "" (toggle) for the three switches; anything else is a
+// usage error, reported with the command's usage line.
+function toggle(args: string, current: boolean, usage: string): boolean | undefined {
+  if (args === "on") return true
+  if (args === "off") return false
+  if (!args) return !current
+  console.log(usage)
+  return undefined
+}
+
+function cmdStats(args: string) {
+  let on = toggle(args, state.stats, "Usage: stats [on|off]")
+  if (on === undefined) return
+  setStats(on)
+  console.log(`[cli] Stats overlay ${on ? "on" : "off"}`)
+}
+
+function cmdWatch(args: string) {
+  let on = toggle(args, !state.watchPaused, "Usage: watch on|off")
+  if (on === undefined) return
+  setWatchActive(on)
+}
+
+function cmdMute(args: string) {
+  let on = toggle(args, state.userInputMuted, "Usage: mute on|off")
+  if (on === undefined) return
+  setUserInputMuted(on)
+}
+
+// The word and the rest of the line, trimmed.
+function split(line: string): [string, string] {
+  let cmd = line.trim()
+  let i = cmd.indexOf(" ")
+  return i < 0 ? [cmd, ""] : [cmd.slice(0, i), cmd.slice(i + 1).trim()]
+}
+
+async function dispatch(line: string, quit: () => void): Promise<void> {
+  let [cmd, args] = split(line)
+  switch (cmd) {
+    case "":
+      return
+    case "reload":
+      return cmdReload(args)
+    case "stop":
+      return cmdStop(args)
+    case "load":
+      return cmdLoad(args)
+    case "list":
+      return cmdList()
+    case "stats":
+      return cmdStats(args)
+    case "watch":
+      return cmdWatch(args)
+    case "mute":
+      return cmdMute(args)
+    case "quit":
+    case "exit":
+      return quit()
+    case "help":
+      console.log(HELP)
+      return
+    default:
+      console.log(`Unknown command: ${cmd}`)
+  }
+}
+
+// Tab completion: a command name, or for `load` a path relative to what
+// loadEntry resolves against (the project dir, or the served file's dir):
+// directories and app entries only.
+async function complete(line: string): Promise<Completion> {
+  if (!line.startsWith("load ")) {
+    return { matches: COMMANDS.filter((c) => c.startsWith(line)), replace: line }
+  }
+  let partial = line.slice(5)
+  let slash = partial.lastIndexOf("/")
+  let dirPart = slash < 0 ? "" : partial.slice(0, slash + 1)
+  let prefix = partial.slice(dirPart.length)
+  let base = state.config.projectDir ?? state.config.sourceDir
+  let matches: string[] = []
+  try {
+    for (let entry of await dir(absolute(dirPart || ".", base)).entries()) {
+      if (!entry.name.startsWith(prefix)) continue
+      if (entry.type === "directory") matches.push(entry.name + "/")
+      else if (ENTRY_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) matches.push(entry.name)
+    }
+  } catch {}
+  return { matches, replace: prefix }
+}
+
+// Start the repl when a terminal is attached; `quit` ends the server (the
+// quit command, Ctrl-C, or stdin closing). Returns the function that
+// detaches it, for the server's shutdown.
+export function startRepl(quit: () => void): () => void {
+  if (!isTTY) {
+    console.log("[cli] No terminal on stdin, running without the repl")
+    return () => {}
+  }
+  try {
+    return startLineEditor({ prompt: PROMPT, onLine: (line) => dispatch(line, quit), onQuit: quit, complete })
+  } catch (e) {
+    console.log(`[cli] ${String(e)}; using plain line input`)
+    return startLineInput(quit)
+  }
+}
+
+// Cooked-mode fallback: the terminal edits the line, this side prompts.
+// Commands run one at a time: a line typed while one runs waits for it, so
+// its output and the next prompt keep their order. No prompt once the
+// server is shutting down (quit, or a signal mid-command).
+function startLineInput(quit: () => void): () => void {
+  let attached = true
+  let prompt = () => {
+    if (attached) write(PROMPT)
+  }
+  let chain = Promise.resolve()
+  let offLine = on("line", (line) => {
+    chain = chain.then(() => dispatch(line, quit)).then(prompt, (e) => {
+      console.error(`[cli] ${String(e)}`)
+      prompt()
+    })
+  })
+  let offClose = on("close", quit)
+  prompt()
+  return () => {
+    attached = false
+    offLine()
+    offClose()
+  }
+}

package/src/server/state.ts

@@ -0,0 +1,54 @@
+// Server-side state shared by the route handlers: what the protocol needs,
+// plus what main.ts resolved at startup (config.ts).
+
+import type { ServerWebSocket } from "flux:http"
+import type { ServerConfig } from "./config"
+import type { ClientEntry } from "../types/control"
+
+export let state = {
+  config: undefined as unknown as ServerConfig,
+  clients: new Map<ServerWebSocket, ClientEntry>(),
+  nextClientId: 0,
+  /**
+   * Identity of this server run, included in control responses that carry
+   * cross-call state (client ids, log seq cursors). Both reset on restart, so
+   * a consumer that sees the generation change knows its ids and cursors are
+   * from a dead server and must be re-fetched.
+   */
+  generation: Date.now(),
+  /**
+   * The latched reload message (JSON text), replayed to late-joining clients.
+   * Set by a successful rebuild (and the build-failure trigger).
+   */
+  currentReload: null as string | null,
+  /**
+   * The running bundle's sourcemaps (JSON text, bundle -> .tsx sources),
+   * keyed by the module name stack frames cite ("main" for the app, the
+   * isolate id for each isolate), used to remap stack traces in forwarded
+   * client logs (see control.ts). Replaced on every reload; a reload without
+   * maps clears them so frames are never remapped against a stale map.
+   */
+  currentMaps: null as Record<string, string> | null,
+  /** The address clients reach this server on (host:port), set once bound. */
+  serverUrl: "",
+  stats: false,
+  /**
+   * Whether the user's own input is muted on every client, for an agent
+   * measuring or testing (the `mute` message; `welcome` carries it to a client
+   * joining while muted). Set by /mute.
+   */
+  userInputMuted: false,
+  /**
+   * Whether reload-on-save is paused (the /watch endpoint, srt mcp's
+   * pause_watch), so an agent's half-finished saves are not pushed to the
+   * user's screens while it edits; its explicit reload still is.
+   */
+  watchPaused: false,
+  // Capture events from all connected clients share one clock (captureStartMs,
+  // integer milliseconds) so they merge into one coherent timeline, tagged by
+  // `device`. Streamed to disk as JSON Lines - see main.ts's "capture" handling.
+  captureStartMs: 0,
+  captureLastAt: 0, // ms, same clock as captureStartMs
+  /** Serializes capture appends so events land on disk in arrival order. */
+  captureChain: Promise.resolve(),
+}

package/{server → src/server}/tsconfig.json

@@ -8,5 +8,5 @@
     "noUncheckedIndexedAccess": true,
     "types": ["@solidrt/flux-types"]
   },
-  "include": ["."]
+  "include": [".", "../types"]
 }