@solidrt/cli 0.0.26 → 0.0.28

package/src/commands/mcp.ts

@@ -5,16 +5,26 @@
 //
 // stdout is the JSON-RPC channel; nothing here may print to it.
 
+import { z } from "zod"
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js"
+import { resolve } from "node:path"
 import { DEV_PORT } from "../dev-server"
 
 const CONTROL_BASE = `http://127.0.0.1:${DEV_PORT}/__control__`
 
 type ControlResult = { ok: true; body: any } | { ok: false; message: string }
 
-async function control(path: string): Promise<ControlResult> {
+async function control(path: string, method: "GET" | "POST" = "GET", payload?: unknown): Promise<ControlResult> {
   let resp
   try {
-    resp = await fetch(CONTROL_BASE + path)
+    let init: RequestInit = { method }
+    if (payload !== undefined) {
+      init.headers = { "content-type": "application/json" }
+      init.body = JSON.stringify(payload)
+    }
+    resp = await fetch(CONTROL_BASE + path, init)
   } catch {
     return {
       ok: false,
@@ -29,70 +39,147 @@ async function control(path: string): Promise<ControlResult> {
   return { ok: true, body }
 }
 
-let TOOLS = [
+let CLIENT_ARG = z
+  .number()
+  .int()
+  .describe("Client id from list_clients (default: the only connected client)")
+  .optional()
+
+let SAVE_TO_ARG = z
+  .string()
+  .describe(
+    "Also write the PNG to this file path (relative paths resolve against the project root; parent directories are created)",
+  )
+  .optional()
+
+let TOOLS: { name: string; description: string; inputSchema: Record<string, z.ZodTypeAny> }[] = [
   {
     name: "list_clients",
     description:
-      "List the app clients connected to the SolidRT dev server. Each entry has id (pass it as `client` to the other tools), platform, runtime version, and the capability names compiled into that client's runtime.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      "List the app clients connected to the SolidRT dev server. Returns `generation` (identity of this server run: client ids and log cursors are only valid within one generation, so if it changed since your last call, re-fetch ids and cursors) and `clients`. Each entry has id (pass it as `client` to the other tools), platform, runtime version (git describe; a -dirty suffix means the binary was built from uncommitted engine changes), build profile (debug/release), and the capability names compiled into that client's runtime. Use version/profile to check whether a connected binary contains a given engine change before debugging against it.",
+    inputSchema: {},
   },
   {
     name: "get_logs",
     description:
-      "Read console output and runtime errors from connected app clients. Returns entries (seq, at, client, level, text) plus `latest`, the newest seq. Pass `since` (a seq or `latest` from a previous call) to only get newer entries; pass `wait_ms` to hold the call until new output arrives, e.g. right after triggering a reload.",
+      "Read console output and runtime errors from connected app clients. Returns entries (seq, at, client, level, text; consecutive identical entries are collapsed into one with a `repeats` count and the run's last seq), plus `latest` (the newest seq) and `generation` (identity of this server run; if it changed since your last call, your seq cursor and client ids are stale - start over from since 0). Pass `since` (a seq or `latest` from a previous call) to only get newer entries; pass `wait_ms` to hold the call until new output arrives, e.g. right after triggering a reload; pass `level`/`contains` to filter, e.g. level \"error\" to skip chatty output.",
     inputSchema: {
-      type: "object",
-      properties: {
-        since: {
-          type: "integer",
-          description: "Only return entries with seq greater than this (default 0: the whole buffer)",
-        },
-        wait_ms: {
-          type: "integer",
-          description: "If nothing is newer than `since`, wait up to this many milliseconds for new output (max 30000)",
-        },
-      },
-      additionalProperties: false,
+      since: z
+        .number()
+        .int()
+        .describe("Only return entries with seq greater than this (default 0: the whole buffer)")
+        .optional(),
+      wait_ms: z
+        .number()
+        .int()
+        .describe("If nothing matches newer than `since`, wait up to this many milliseconds for new output (max 30000)")
+        .optional(),
+      level: z
+        .string()
+        .describe('Only return entries with one of these levels, comma-separated (e.g. "error" or "error,warn")')
+        .optional(),
+      contains: z
+        .string()
+        .describe("Only return entries whose text contains this substring (case-insensitive)")
+        .optional(),
     },
   },
   {
     name: "get_stats",
     description:
-      "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        client: { type: "integer", description: "Client id from list_clients (default: the only connected client)" },
-      },
-      additionalProperties: false,
-    },
+      "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count. Layout-activity counters cover the last full rebuild, raw: nodes (live node count), measureCalls (text measures; mostly cache hits, cheap), paraShapes (paragraphs actually shaped; the expensive signal - high layoutMs with near-zero paraShapes means the cost is not text shaping), dirtiedNodes (layout caches cleared by property writes since the previous rebuild; how much of the tree a write burst invalidated), cacheGets/cacheHits (layout-cache lookups during the rebuild; a hit on a container skips its whole subtree, so a healthy incremental rebuild shows a near-100% hit rate - a low rate at scale means the layout cache is being defeated).",
+    inputSchema: { client: CLIENT_ARG },
   },
   {
     name: "get_render_tree",
     description:
-      "Snapshot of a running app client's render tree: node id, kind, window-relative box (x, y, width, height), text content, and children. Use it to verify what the app actually rendered and where.",
+      "Snapshot of a running app client's render tree: node id, kind, window-relative box (x, y, width, height), text content, and children. Use it to verify what the app actually rendered and where. Whole trees get large: prefer `query` to find nodes by kind or text first, then `root` + `depth` to inspect the region around a match. A node whose children were cut off by `depth` carries `childCount`; descend into it with root=<its id>.",
     inputSchema: {
-      type: "object",
-      properties: {
-        client: { type: "integer", description: "Client id from list_clients (default: the only connected client)" },
-      },
-      additionalProperties: false,
+      root: z
+        .number()
+        .int()
+        .describe("Only return the subtree under this node id (default: the whole tree)")
+        .optional(),
+      depth: z
+        .number()
+        .int()
+        .describe("Levels of children to include below the root (default: unlimited; 0 = the root node only)")
+        .optional(),
+      query: z
+        .string()
+        .describe(
+          "Search instead of snapshot: return `matches`, nodes whose kind equals or text contains this " +
+            "(case-insensitive), each with a `path` of ancestor ids from the search root. Combine with `root` to " +
+            "scope the search; `depth` is ignored.",
+        )
+        .optional(),
+      client: CLIENT_ARG,
     },
   },
   {
     name: "get_snapshot",
     description:
-      "Capture a PNG image of any node in a running app client's render tree, by node id (get ids from get_render_tree). Returns the rendered pixels of that node's subtree, so you can see what the app actually drew. The node must be currently mounted and have a non-zero layout box.",
+      "Capture a PNG image of any node in a running app client's render tree, by node id (get ids from get_render_tree). Returns the rendered pixels of that node's subtree, so you can see what the app actually drew. The node must be currently mounted and have a non-zero layout box. Works on an idle client (the capture requests its own frame); a timeout means the client's JS thread is busy or wedged, not that the app is idle.",
+    inputSchema: {
+      nodeId: z.number().int().describe("Id of the node to capture, from get_render_tree"),
+      save_to: SAVE_TO_ARG,
+      client: CLIENT_ARG,
+    },
+  },
+  {
+    name: "get_gpu_resources",
+    description:
+      "Inventory of a running app client's GPU resources: textures (id, size, whether a shader renders into it), vertex buffers (id, byteLength), and shader/pipeline targets (output textureId, kind, bufferId, topology, drawCount, depth, attribute layout, bound sampler texture ids, last-applied uniform values). Use it when the render tree is just a <texture> leaf and the interesting state lives behind it; follow up with get_texture or get_buffer to see contents.",
+    inputSchema: { client: CLIENT_ARG },
+  },
+  {
+    name: "get_texture",
+    description:
+      "Read back any GPU texture from a running app client as a PNG, by texture id (from get_gpu_resources, or the id returned by createImage/createShader/createPipeline in app code). Works on sampled textures (atlases, data textures) and shader/pipeline render targets alike, without needing a frame. Pass x/y/width/height to crop, e.g. one tile of an atlas.",
     inputSchema: {
-      type: "object",
-      properties: {
-        nodeId: { type: "integer", description: "Id of the node to capture, from get_render_tree" },
-        client: { type: "integer", description: "Client id from list_clients (default: the only connected client)" },
-      },
-      required: ["nodeId"],
-      additionalProperties: false,
+      id: z.number().int().describe("Texture id, from get_gpu_resources"),
+      x: z.number().int().describe("Crop rect left edge in texture pixels (requires y, width, height)").optional(),
+      y: z.number().int().describe("Crop rect top edge in texture pixels").optional(),
+      width: z.number().int().describe("Crop rect width in texture pixels").optional(),
+      height: z.number().int().describe("Crop rect height in texture pixels").optional(),
+      save_to: SAVE_TO_ARG,
+      client: CLIENT_ARG,
     },
   },
+  {
+    name: "get_buffer",
+    description:
+      "Read back part of a GPU vertex buffer from a running app client, decoded to numbers. Returns values plus byteOffset/byteLength actually read and bufferByteLength. Reads are capped at 64 KiB per call; page through larger buffers with offset. Use it to verify geometry after a writeBuffer, e.g. the dynamic sprite tail of a vertex buffer.",
+    inputSchema: {
+      id: z.number().int().describe("Buffer id, from get_gpu_resources"),
+      offset: z.number().int().describe("Byte offset to start reading at (default 0)").optional(),
+      length: z.number().int().describe("Number of values to read (default: the rest of the buffer, capped)").optional(),
+      as: z.enum(["f32", "u16", "u8"]).describe("How to decode the bytes (default f32)").optional(),
+      client: CLIENT_ARG,
+    },
+  },
+  {
+    name: "list_debug",
+    description:
+      "List the debug commands the running app registered via registerDebug from srt:dev. Returns the command names; call one with call_debug. Empty when the app registered none.",
+    inputSchema: { client: CLIENT_ARG },
+  },
+  {
+    name: "call_debug",
+    description:
+      "Call a debug command the running app registered via registerDebug from srt:dev, by name (from list_debug). `args` is passed to the command's function as its single argument; the command's return value comes back JSON-serialized (undefined as null). Commands run synchronously on the app's JS thread - use them to query app state (positions, counters, internal flags) or trigger app behavior (toggle a mode, open a door) without touching its real input handling.",
+    inputSchema: {
+      name: z.string().describe("Debug command name, from list_debug"),
+      args: z.record(z.string(), z.any()).describe("Argument object passed to the command (default: none)").optional(),
+      client: CLIENT_ARG,
+    },
+  },
+  {
+    name: "reload",
+    description:
+      "Rebuild the app from source and push it to every connected client. Call this after editing the app's .tsx/.jsx source to apply the changes: it bundles once and reloads all clients, so a burst of edits becomes a single explicit reload. Returns the number of clients reloaded, or a build error if the source failed to compile. Follow with get_logs to see runtime output from the reloaded app.",
+    inputSchema: {},
+  },
 ]
 
 function clientParam(args: any): string {
@@ -107,50 +194,102 @@ async function callTool(name: string, args: any): Promise<ControlResult> {
       let params = new URLSearchParams()
       if (typeof args?.since === "number") params.set("since", String(args.since))
       if (typeof args?.wait_ms === "number") params.set("wait", String(args.wait_ms))
+      if (typeof args?.level === "string") params.set("level", args.level)
+      if (typeof args?.contains === "string") params.set("contains", args.contains)
       let qs = params.toString()
       return control(qs ? `/logs?${qs}` : "/logs")
     }
     case "get_stats":
       return control(`/stats${clientParam(args)}`)
-    case "get_render_tree":
-      return control(`/tree${clientParam(args)}`)
+    case "get_render_tree": {
+      let params = new URLSearchParams()
+      if (typeof args?.root === "number") params.set("root", String(args.root))
+      if (typeof args?.depth === "number") params.set("depth", String(args.depth))
+      if (typeof args?.query === "string") params.set("query", args.query)
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      let qs = params.toString()
+      return control(qs ? `/tree?${qs}` : "/tree")
+    }
+    case "reload":
+      return control("/reload", "POST")
     case "get_snapshot": {
       if (typeof args?.nodeId !== "number") return { ok: false, message: "get_snapshot requires a numeric nodeId" }
       let params = new URLSearchParams({ node: String(args.nodeId) })
       if (typeof args?.client === "number") params.set("client", String(args.client))
       return control(`/snapshot?${params.toString()}`)
     }
+    case "get_gpu_resources":
+      return control(`/gpu${clientParam(args)}`)
+    case "list_debug":
+      return control(`/debug${clientParam(args)}`)
+    case "call_debug": {
+      if (typeof args?.name !== "string") return { ok: false, message: "call_debug requires a command name" }
+      let params = new URLSearchParams({ name: args.name })
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/debug?${params.toString()}`, "POST", args?.args)
+    }
+    case "get_texture": {
+      if (typeof args?.id !== "number") return { ok: false, message: "get_texture requires a numeric id" }
+      let params = new URLSearchParams({ id: String(args.id) })
+      for (let key of ["x", "y", "width", "height"]) {
+        if (typeof args?.[key] === "number") params.set(key, String(args[key]))
+      }
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/texture?${params.toString()}`)
+    }
+    case "get_buffer": {
+      if (typeof args?.id !== "number") return { ok: false, message: "get_buffer requires a numeric id" }
+      let params = new URLSearchParams({ id: String(args.id) })
+      if (typeof args?.offset === "number") params.set("offset", String(args.offset))
+      if (typeof args?.length === "number") params.set("length", String(args.length))
+      if (typeof args?.as === "string") params.set("as", args.as)
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/buffer?${params.toString()}`)
+    }
     default:
       return { ok: false, message: `Unknown tool: ${name}` }
   }
 }
 
-export async function runMcpCommand() {
-  let { Server } = await import("@modelcontextprotocol/sdk/server/index.js")
-  let { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js")
-  let { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js")
-
-  let server = new Server({ name: "solidrt", version: "0.0.0" }, { capabilities: { tools: {} } })
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }))
-
-  server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
-    let name = request.params.name
-    let result = await callTool(name, request.params.arguments ?? {})
-    if (!result.ok) {
-      return { content: [{ type: "text", text: result.message }], isError: true }
-    }
-    if (name === "get_snapshot") {
-      let { pngBase64, width, height } = result.body
-      return {
-        content: [
-          { type: "image", data: pngBase64, mimeType: "image/png" },
-          { type: "text", text: `Captured node snapshot: ${width}x${height} px` },
-        ],
+async function toContent(name: string, result: ControlResult, args?: any): Promise<CallToolResult> {
+  if (!result.ok) return { content: [{ type: "text", text: result.message }], isError: true }
+  if (name === "get_snapshot" || name === "get_texture") {
+    let { pngBase64, width, height } = result.body
+    let label = name === "get_snapshot" ? "Captured node snapshot" : "Texture contents"
+    let text = `${label}: ${width}x${height} px`
+    // save_to is handled here in the bridge, not by the dev server: this
+    // process runs on the caller's machine, so the path lands where the
+    // agent expects it. The image content block alone is a dead end for
+    // that - the model sees the pixels but never the bytes.
+    if (typeof args?.save_to === "string") {
+      let path = resolve(args.save_to)
+      try {
+        await Bun.write(path, Buffer.from(pngBase64, "base64"))
+        text += `, saved to ${path}`
+      } catch (e) {
+        return { content: [{ type: "text", text: `Captured, but saving to ${path} failed: ${e}` }], isError: true }
       }
     }
-    return { content: [{ type: "text", text: JSON.stringify(result.body, null, 2) }] }
-  })
+    return {
+      content: [
+        { type: "image", data: pngBase64, mimeType: "image/png" },
+        { type: "text", text },
+      ],
+    }
+  }
+  return { content: [{ type: "text", text: JSON.stringify(result.body, null, 2) }] }
+}
+
+export async function runMcpCommand() {
+  let server = new McpServer({ name: "solidrt", version: "0.0.0" })
+
+  for (let tool of TOOLS) {
+    server.registerTool(
+      tool.name,
+      { description: tool.description, inputSchema: tool.inputSchema },
+      async (args: any) => toContent(tool.name, await callTool(tool.name, args ?? {}), args),
+    )
+  }
 
   // The stdin read keeps the process alive; it exits when the agent host
   // closes the pipe.

package/src/commands/server.ts

@@ -1,7 +1,7 @@
 import pkg from "../../package.json"
 import { source, isSource, isPrebuilt, values } from "../args"
 import { state, shutdown } from "../util"
-import { bundle, codeFromOutputs } from "../bundler"
+import { bundle } from "../bundler"
 import { startServer, buildReload, sendReload, showBuildFailure } from "../dev-server"
 import { startRepl } from "../repl"
 import { startWatcher } from "../watcher"
@@ -27,8 +27,9 @@ export async function runServerCommand() {
   if (source && isSource) {
     let initialResult = await bundle()
     if (initialResult) {
-      state.currentCode = await codeFromOutputs(initialResult.outputs)
-      await sendReload(buildReload({ code: state.currentCode }), { latch: true })
+      state.currentCode = initialResult.code
+      state.currentMap = initialResult.map
+      await sendReload(buildReload({ code: state.currentCode }), { latch: true, map: state.currentMap })
     } else {
       await showBuildFailure()
     }

package/src/dev-server.ts

@@ -30,9 +30,14 @@ async function post(path: string, body: object) {
  * Send a client-protocol message through the server: to the given client ids,
  * 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`).
+ * moves the server's file-serving root (repl `load`); `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).
  */
-export async function sendReload(message: object, opts: { clients?: number[]; latch?: boolean; sourceDir?: string } = {}) {
+export async function sendReload(
+  message: object,
+  opts: { clients?: number[]; latch?: boolean; sourceDir?: string; entry?: string; map?: string | null } = {},
+) {
   await post("/reload", { message, ...opts })
 }
 
@@ -125,12 +130,20 @@ export async function startServer() {
   // computes it and passes it down.
   state.serverUrl = `${address}:${DEV_PORT}`
 
+  // How the server rebuilds on an MCP-triggered reload: it cannot call
+  // Bun.build itself (it is a flux process), so it spawns srt's own bun on the
+  // standalone bundle-cli entry. Both paths are known here at spawn time.
+  let bundleCli = fileURLToPath(new URL("./bundle-cli.ts", import.meta.url))
+
   let config = {
     port: DEV_PORT,
     sourceDir: state.sourceDir,
     address,
     proxyFiles: values["proxy-files"],
     proxyHttp: values["proxy-http"],
+    entry: state.source,
+    minify: values.minify,
+    bundlerCmd: [process.execPath, bundleCli],
     cache: values["proxy-http"],
     cacheDir: process.cwd(),
     capture: state.capture,

package/src/main.ts

@@ -3,6 +3,7 @@
 import { values, command, validateArgs, printUsage } from "./args"
 import { runInitCommand } from "./commands/init"
 import { runBundleCommand } from "./commands/bundle"
+import { runCheckCommand } from "./commands/check"
 import { runPackCommand } from "./commands/pack"
 import { runRenderCommand } from "./commands/render"
 import { runServerCommand } from "./commands/server"
@@ -41,6 +42,8 @@ if (command === "init") {
   await runInitCommand()
 } else if (command === "bundle") {
   await runBundleCommand()
+} else if (command === "check") {
+  await runCheckCommand()
 } else if (command === "pack") {
   await runPackCommand()
 } else if (command === "render") {

package/src/prompt.ts

@@ -15,16 +15,24 @@ export function text(message: string, def = ""): Promise<string> {
   })
 }
 
+export interface SelectOption {
+  label: string
+  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. 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: string[]): Promise<string> {
+// 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> {
+  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(options[0]!)
+    if (!input.isTTY) return resolve(items[0]!.value)
 
     let selected = 0
     emitKeypressEvents(input)
@@ -34,13 +42,13 @@ export function select(message: string, options: string[]): Promise<string> {
     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[${options.length + 1}A`)
+      if (!first) output.write(`\x1b[${items.length + 1}A`)
       output.write(`\x1b[K? ${message}\n`)
-      for (let i = 0; i < options.length; i++) {
+      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}${options[i]}${reset}\n`)
+        output.write(`\x1b[K${pointer}${items[i]!.label}${reset}\n`)
       }
     }
 
@@ -53,15 +61,15 @@ export function select(message: string, options: string[]): Promise<string> {
     let onKey = (_str: string, key: { name: string; ctrl: boolean } | undefined) => {
       if (!key) return
       if (key.name === "up") {
-        selected = (selected - 1 + options.length) % options.length
+        selected = (selected - 1 + items.length) % items.length
         render()
       } else if (key.name === "down") {
-        selected = (selected + 1) % options.length
+        selected = (selected + 1) % items.length
         render()
       } else if (key.name === "return" || key.name === "enter") {
         cleanup()
         output.write("\n")
-        resolve(options[selected]!)
+        resolve(items[selected]!.value)
       } else if (key.ctrl && (key.name === "c" || key.name === "d")) {
         cleanup()
         output.write("\n")

package/src/repl.ts

@@ -3,7 +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, showBuildFailure } from "./dev-server"
-import { bundle, codeFromOutputs } from "./bundler"
+import { bundle } from "./bundler"
 import { startWatcher, stopWatcher } from "./watcher"
 
 // Resolve repl client indexes ("0 2") against the server's client list,
@@ -27,6 +27,7 @@ async function cmdStop(args: string) {
   if (!args) {
     stopWatcher()
     state.currentCode = null
+    state.currentMap = null
     state.source = undefined
     await sendStop()
     print("[cli] Sent stop to all clients")
@@ -47,17 +48,18 @@ async function cmdReload(args: string) {
       await showBuildFailure()
       return
     }
-    state.currentCode = await codeFromOutputs(result.outputs)
+    state.currentCode = result.code
+    state.currentMap = result.map
   }
   let msg = buildReload({ code: state.currentCode })
   if (!args) {
-    await sendReload(msg, { latch: true })
+    await sendReload(msg, { latch: true, map: state.currentMap })
     print("[cli] Sent reload to all clients")
     return
   }
   let ids = await indexesToIds(args)
   if (ids.length) {
-    await sendReload(msg, { clients: ids })
+    await sendReload(msg, { clients: ids, map: state.currentMap })
     print(`[cli] Sent reload to client(s) ${ids.join(", ")}`)
   }
 }
@@ -102,9 +104,11 @@ async function cmdLoad(file: string) {
       printErr("[cli] Build failed")
       return
     }
-    state.currentCode = await codeFromOutputs(result.outputs)
+    state.currentCode = result.code
+    state.currentMap = result.map
   } else if (file.endsWith(".srt.js")) {
     state.currentCode = await Bun.file(path).text()
+    state.currentMap = null
   } 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.
@@ -118,8 +122,14 @@ async function cmdLoad(file: string) {
   state.source = path
   state.sourceDir = dirname(path)
   startWatcher()
-  // The load also moves the server's file-serving root to the new source dir.
-  await sendReload(buildReload({ code: state.currentCode }), { latch: true, sourceDir: state.sourceDir })
+  // 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 }), {
+    latch: true,
+    sourceDir: state.sourceDir,
+    entry: file.endsWith(".tsx") ? path : undefined,
+    map: state.currentMap,
+  })
   print(`[cli] Loaded ${file}`)
 }
 

package/src/util.ts

@@ -8,6 +8,9 @@ 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,
   source: undefined as string | undefined,
   sourceDir: process.cwd(),
   child: null as ReturnType<typeof Bun.spawn> | null,

package/src/watcher.ts

@@ -2,7 +2,7 @@ import { watch } from "node:fs"
 import { resolve, dirname } from "path"
 import { state, print, printErr } from "./util"
 import { buildReload, sendReload, showBuildFailure } from "./dev-server"
-import { bundle, codeFromOutputs } from "./bundler"
+import { bundle } from "./bundler"
 
 let currentWatcher: ReturnType<typeof watch> | null = null
 
@@ -31,7 +31,8 @@ export function startWatcher() {
       await showBuildFailure()
       return
     }
-    state.currentCode = await codeFromOutputs(result.outputs)
-    await sendReload(buildReload({ code: state.currentCode }), { latch: true })
+    state.currentCode = result.code
+    state.currentMap = result.map
+    await sendReload(buildReload({ code: state.currentCode }), { latch: true, map: state.currentMap })
   })
 }