@solidrt/cli 0.0.50 → 0.0.51

package/scaffold/package.json

@@ -10,13 +10,13 @@
     "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.50",
-    "@solidrt/components": "0.0.50",
-    "@solidrt/3d": "0.0.50"
+    "@solidrt/core": "0.0.51",
+    "@solidrt/components": "0.0.51",
+    "@solidrt/3d": "0.0.51"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.50",
-    "@solidrt/flux-types": "0.0.50",
+    "@solidrt/cli": "0.0.51",
+    "@solidrt/flux-types": "0.0.51",
     "typescript": "^7"
   }
 }

package/server/control.ts

@@ -34,7 +34,7 @@ function sleep(ms: number): Promise<void> {
 /// A `log` message arrived from a client: buffer it and wake long-polls.
 /// Bundle positions in stack traces are remapped to .tsx sources on the way in.
 export function appendLog(client: number, level: string, text: string) {
-  logs.push({ seq: ++logSeq, at: Date.now(), client, level, text: remapPositions(text, state.currentMap) })
+  logs.push({ seq: ++logSeq, at: Date.now(), client, level, text: remapPositions(text, state.currentMaps) })
   if (logs.length > LOG_CAP) logs.splice(0, logs.length - LOG_CAP)
   let waiters = logWaiters
   logWaiters = []
@@ -138,7 +138,7 @@ async function handleQuery(
     )
   // Error strings may carry stack traces (e.g. a debug command threw); remap
   // bundle positions to .tsx sources like appendLog does for forwarded logs.
-  if (msg.error) return Response.json({ error: remapPositions(String(msg.error), state.currentMap) }, { status: 502 })
+  if (msg.error) return Response.json({ error: remapPositions(String(msg.error), state.currentMaps) }, { status: 502 })
   return Response.json(msg.data)
 }
 
@@ -225,8 +225,12 @@ export async function handleControl(req: Request, path: string, query: Map<strin
       if (query.get("props") === "true") extra.props = true
       return handleQuery(query, "tree", extra)
     }
-    case "/__control__/stats":
-      return handleQuery(query, "stats")
+    case "/__control__/stats": {
+      let extra: Record<string, unknown> = {}
+      let windowMs = parseInt(query.get("window") ?? "", 10)
+      if (Number.isFinite(windowMs)) extra.windowMs = windowMs
+      return handleQuery(query, "stats", extra)
+    }
     case "/__control__/snapshot": {
       let nodeId = parseInt(query.get("node") ?? "", 10)
       if (!Number.isFinite(nodeId)) return Response.json({ error: "Snapshot requires ?node=<id>" }, { status: 400 })
@@ -361,7 +365,13 @@ export async function handleControl(req: Request, path: string, query: Map<strin
       // An entry outside the project root cannot resolve the project's
       // dependencies, so the bundler would fail with misleading "bun install"
       // advice; name the real constraint instead.
-      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(entry).startsWith(root)) {
         return Response.json(

package/server/main.ts

@@ -2,7 +2,7 @@
 // config argument; bundling, file watching, and the repl stay in srt, which
 // drives this process over the loopback-only /__internal__/ routes. The
 // shutdown-when-empty policy also lives in srt (it polls /__internal__/clients);
-// this process runs until srt kills it. See docs/flux-dev-server-plan.md.
+// this process runs until srt kills it.
 
 import { serve } from "flux:http"
 import type { FluxRequest, Server } from "flux:http"
@@ -74,20 +74,20 @@ async function handleInternal(req: FluxRequest, server: Server, path: string): P
 
   switch (path) {
     case "/__internal__/reload": {
-      // { message, clients?, latch?, sourceDir?, map? }: send `message` (a
+      // { message, clients?, latch?, sourceDir?, maps? }: send `message` (a
       // full client-protocol message, built by srt) to the listed client ids,
       // or to all when omitted. `latch` keeps it for late-joining clients
       // (code reloads latch, one-shot bytecode loads do not); `sourceDir`
       // moves the file-serving root (repl `load`; the project root - and with
-      // it the /assets/ root - is fixed for the life of the run); `map` is
-      // the bundle's sourcemap for log remapping, replaced on every reload
-      // (absent means none).
+      // it the /assets/ root - is fixed for the life of the run); `maps` is
+      // the bundle's sourcemaps keyed by module name for log remapping,
+      // replaced on every reload (absent means none).
       let body = await req.json()
       if (typeof body.sourceDir === "string") state.sourceDir = body.sourceDir
       // Keep the rebuild entry in sync when `load` moves it, so a later MCP
       // reload bundles the newly loaded file, not the launch-time one.
       if (typeof body.entry === "string") state.config.entry = body.entry
-      state.currentMap = typeof body.map === "string" ? body.map : null
+      state.currentMaps = body.maps && typeof body.maps === "object" ? body.maps : null
       let text = JSON.stringify(body.message)
       if (body.latch) state.currentReload = text
       sendTo(body.clients, text)
@@ -99,7 +99,7 @@ async function handleInternal(req: FluxRequest, server: Server, path: string): P
       // connects afterwards starts clean.
       if (!body.clients) {
         state.currentReload = null
-        state.currentMap = null
+        state.currentMaps = null
       }
       sendTo(body.clients, JSON.stringify({ type: "stop" }))
       return new Response("", { status: 204 })
@@ -298,7 +298,7 @@ if (!config.tunnel) {
 }
 console.log(`[cli] WebSocket server on ws://${state.serverUrl}`)
 // mDNS advertise is intentionally not implemented here: the p2p ticket is the
-// cross-device connect story (see docs/flux-dev-server-plan.md).
+// cross-device connect story (see okf/backlog/mdns-discovery.md).
 
 // Keepalive
 setInterval(() => {

package/server/rebuild.ts

@@ -47,7 +47,12 @@ export async function rebuildAndBroadcast(): Promise<string | null> {
   }
 
   // bundle-cli writes one JSON object { code, map, manifest, isolates } to stdout.
-  let bundle: { code?: string; map?: string | null; manifest?: string; isolates?: { id: string; code: string }[] }
+  let bundle: {
+    code?: string
+    map?: string | null
+    manifest?: string
+    isolates?: { id: string; code: string; map?: string | null }[]
+  }
   try {
     bundle = JSON.parse(typeof result.stdout === "string" ? result.stdout : "")
   } catch {
@@ -55,12 +60,15 @@ export async function rebuildAndBroadcast(): Promise<string | 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.currentMap = bundle.map ?? null
+  state.currentMaps = Object.keys(maps).length ? maps : null
   let text = JSON.stringify(buildReload(bundle.code ?? "", bundle.manifest))
   state.currentReload = text
   for (let ws of state.clients.keys()) ws.send(text)

package/server/remap.ts

@@ -1,47 +1,60 @@
 import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping"
 
 // Stack-trace remapping for forwarded client logs. The runtime evaluates the
-// bundle as module "main", so QuickJS frames cite bundle positions like
-// "at boom (main:212:9)". With the current reload's sourcemap latched on the
-// server (state.currentMap), those positions are rewritten to the original
-// .tsx sources before a log entry is buffered.
+// 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.
 
-// The parsed map is cached per map text; a reload swaps the text and the next
-// lookup rebuilds the tracer.
-let cachedText: string | null = null
-let tracer: TraceMap | null = null
+// 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(map: string | null): TraceMap | null {
-  if (map !== cachedText) {
-    cachedText = map
-    tracer = null
-    if (map) {
-      try {
-        tracer = new TraceMap(JSON.parse(map))
-      } catch {
-        // A malformed map disables remapping until the next reload.
-      }
+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 tracer
+  return entry.tracer
 }
 
+let REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g
+
 /**
- * Rewrite every "main:LINE:COL" (or "main:LINE") position in `text` to its
- * original source position, e.g. "src/app.tsx:42:7". Positions the map has no
- * entry for, and all text when `map` is null, pass through unchanged.
+ * 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, map: string | null): string {
-  if (!map || !text.includes("main:")) return text
-  let t = tracerFor(map)
-  if (!t) return text
-  return text.replace(/\bmain:(\d+)(?::(\d+))?\b/g, (frame, line, column) => {
-    let pos = originalPositionFor(t, {
-      line: parseInt(line, 10),
-      column: column ? Math.max(parseInt(column, 10) - 1, 0) : 0,
+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}`
     })
-    if (pos.source == null || pos.line == null) return frame
-    return `${pos.source}:${pos.line}:${(pos.column ?? 0) + 1}`
-  })
+  }
+  return text
 }

package/server/state.ts

@@ -66,12 +66,13 @@ export let state = {
    */
   currentReload: null as string | null,
   /**
-   * The running bundle's sourcemap (JSON text, bundle -> .tsx sources), used
-   * to remap stack traces in forwarded client logs (see control.ts). Replaced
-   * on every reload; a reload without a map clears it so frames are never
-   * remapped against a stale map.
+   * 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.
    */
-  currentMap: null as string | null,
+  currentMaps: null as Record<string, string> | null,
   sourceDir: "",
   projectDir: "",
   serverUrl: "",

package/src/args.ts

@@ -35,7 +35,6 @@ export let { values, positionals } = parseArgs({
     port: { type: "string" },
     android: { type: "boolean", default: false },
     device: { type: "string" },
-    with: { type: "string" },
   },
   allowPositionals: true,
 })
@@ -81,9 +80,11 @@ export function clientStorageArgs(): string[] {
 export let command = positionals[0]
 export let source = positionals[1]
 export let isTsx = source?.endsWith(".tsx") || source?.endsWith(".jsx")
-export let isTs = source?.endsWith(".ts") || source?.endsWith(".js")
-export let isSource = isTsx || isTs
 export let isPrebuilt = source?.endsWith(".srt.js") || source?.endsWith(".srt.bin")
+// A .srt.js also ends with .js: prebuilt wins, or the server would re-bundle
+// a prebuilt bundle as source and skip the prebuilt load path.
+export let isTs = (source?.endsWith(".ts") || source?.endsWith(".js")) && !isPrebuilt
+export let isSource = isTsx || isTs
 
 function usage(line: string): never {
   console.error("Usage: " + line)
@@ -158,9 +159,6 @@ Commands:
   pack <file>            Bundle + compile to a standalone executable (experimental)
   mcp                    MCP server (stdio) exposing the running dev server to coding agents
 
-init options:
-      --with <pkg,pkg>   Extensions to include, e.g. @solidrt/components,@solidrt/3d (skips the picker)
-
 run/server options:
   -s, --session <N>      Session number: dev server on port 34884+N, client slot N (default: 0)
       --port <N>         Dev server port (default: 34884 + session)
@@ -191,7 +189,7 @@ bundle options:
   -d, --dev              Use development build of SolidJS (default: production)
   -m, --minify           Minify the output
       --compile          Compile to bytecode
-  -o, --output <name>    Output filename
+  -o, --output <dir>     Output directory (default: <project>/dist/bundle)
       --stdout           Write bundle to stdout
 
 pack options:

package/src/bundler.ts

@@ -4,11 +4,11 @@ import ts from "@babel/preset-typescript"
 import remapping from "@jridgewell/remapping"
 import solid from "babel-preset-solid"
 import { type BunPlugin, type BuildArtifact } from "bun"
-import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
 import { dirname, join, relative, resolve as resolvePath, sep } from "node:path"
 import { values, source } from "./args"
 import { state, print, requireBinary } from "./util"
-import { buildManifest, manifestAssetFor } from "./project"
+import { buildManifest, manifestAssetFor, type ManifestAsset } from "./project"
 
 // Babel plugin: rewrite `import data from "./x" with { type: "binary" }` into an
 // inline Uint8Array of the file's bytes, and `with { type: "text" }` into an
@@ -129,26 +129,39 @@ export function hasIsolateDirective(code: string): boolean {
 
 let SKIP_DIRS = new Set(["node_modules", "dist"])
 
-export type IsolateModule = { id: string; path: string }
-
-/** Every "use isolate" module under `root`, in id order. */
-export function findIsolateModules(root: string): IsolateModule[] {
-  let out: IsolateModule[] = []
+/**
+ * Depth-first files under `root`, visited as (absolute path, forward-slash
+ * path relative to root). Dotfiles and `skipDirs` are skipped; a missing
+ * root visits nothing.
+ */
+export function walkFiles(root: string, visit: (abs: string, rel: string) => void, skipDirs?: Set<string>) {
+  if (!existsSync(root)) return
   let walk = (dir: string) => {
     for (let entry of readdirSync(dir, { withFileTypes: true })) {
-      if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name)) continue
+      if (entry.name.startsWith(".") || skipDirs?.has(entry.name)) continue
       let abs = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        walk(abs)
-      } else if (entry.isFile() && /\.(js|ts)x?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
-        if (hasIsolateDirective(readFileSync(abs, "utf8"))) {
-          let id = relative(root, abs).split(sep).join("/").replace(/\.(js|ts)x?$/, "")
-          out.push({ id, path: abs })
-        }
-      }
+      if (entry.isDirectory()) walk(abs)
+      else if (entry.isFile()) visit(abs, relative(root, abs).split(sep).join("/"))
     }
   }
   walk(root)
+}
+
+export type IsolateModule = { id: string; path: string }
+
+/** Every "use isolate" module under `root`, in id order. */
+export function findIsolateModules(root: string): IsolateModule[] {
+  let out: IsolateModule[] = []
+  walkFiles(
+    root,
+    (abs, rel) => {
+      if (!/\.(js|ts)x?$/.test(rel) || rel.endsWith(".d.ts")) return
+      if (hasIsolateDirective(readFileSync(abs, "utf8"))) {
+        out.push({ id: rel.replace(/\.(js|ts)x?$/, ""), path: abs })
+      }
+    },
+    SKIP_DIRS,
+  )
   out.sort((a, b) => (a.id < b.id ? -1 : 1))
   return out
 }
@@ -166,8 +179,20 @@ export type BundleResult = {
   map: string | null
   /** Version manifest JSON for this bundle; clients install pushes under its hash. */
   manifest: string
-  /** The app's isolate bundles, one per "use isolate" module, in id order. */
-  isolates: { id: string; code: string }[]
+  /** The app's isolate bundles, one per "use isolate" module, in id order; maps dev builds only. */
+  isolates: { id: string; code: string; map: string | null }[]
+}
+
+/**
+ * The bundle's sourcemaps keyed by the module name stack frames cite ("main"
+ * for the app, the isolate id for each isolate), for the server's log remap.
+ * Null when the build carries no maps (production builds).
+ */
+export function bundleMaps(result: BundleResult): Record<string, string> | null {
+  let maps: Record<string, string> = {}
+  if (result.map) maps.main = result.map
+  for (let i of result.isolates) if (i.map) maps[i.id] = i.map
+  return Object.keys(maps).length ? maps : null
 }
 
 // The pure bundle: every input is explicit, so it runs identically in the srt
@@ -189,8 +214,8 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
 
   // One Bun.build per entry: the app, then each isolate module as its own
   // self-contained bundle (splitting is off, so a helper both import gets
-  // duplicated rather than shared). Only the app's build gets a composed
-  // sourcemap for now.
+  // duplicated rather than shared). In dev every build gets a composed
+  // sourcemap, keyed downstream by its module name.
   let build = async (entry: string, babelMaps?: Map<string, object>, isolateEntry?: string) => {
     let result = null
     try {
@@ -221,22 +246,31 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
   if (!main) return null
   let code = await codeFromOutputs(main.outputs)
 
-  let isolates: { id: string; code: string }[] = []
+  let isolates: { id: string; code: string; map: string | null }[] = []
   for (let module of findIsolateModules(dirname(resolvePath(opts.entry)))) {
-    let result = await build(module.path, undefined, module.path)
+    let moduleMaps = opts.dev ? new Map<string, object>() : undefined
+    let result = await build(module.path, moduleMaps, module.path)
     if (!result) return null
-    isolates.push({ id: module.id, code: await codeFromOutputs(result.outputs) })
+    isolates.push({
+      id: module.id,
+      code: await codeFromOutputs(result.outputs),
+      map: await composeMap(result.outputs, moduleMaps),
+    })
   }
 
-  let extra = isolates.map((i) => manifestAssetFor(isolateAssetPath(i.id, "js"), Buffer.from(i.code, "utf8")))
   return {
     code,
     map: await composeMap(main.outputs, babelMaps),
-    manifest: buildManifest(code, opts.entry, extra),
+    manifest: buildManifest(code, opts.entry, isolateManifestAssets(isolates)),
     isolates,
   }
 }
 
+/** The manifest assets for a set of isolate bundles (dev form: isolates/<id>.js). */
+export function isolateManifestAssets(isolates: { id: string; code: string }[]): ManifestAsset[] {
+  return isolates.map((i) => manifestAssetFor(isolateAssetPath(i.id, "js"), Buffer.from(i.code, "utf8")))
+}
+
 // Write dev isolate bundles where the dev server serves /isolates/ from
 // (<project>/.srt-data/isolates/<id>.js), so clients can fetch the manifest
 // assets the bundle lists. Stale files from removed modules stay behind
@@ -287,14 +321,52 @@ export function devIsolatesDir(projectDir: string): string {
   return join(projectDir, ".srt-data", "isolates")
 }
 
-export async function bundleTo(outfile: string) {
-  let result = await bundle()
-  if (!result) {
-    console.error("Build failed")
-    process.exit(1)
-  }
-  await Bun.write(outfile, result.code)
-  return result
+// A flux entry's isolate modules: everything under its isolates/ dir, id =
+// the path relative to that dir without extension. Standalone flux resolves
+// isolates by location, not directive - module <id> is
+// <entry dir>/isolates/<id>.bin or .js - so this is the discovery for
+// bundling and packing flux scripts (which also lets a worker be .ts, unlike
+// running from source).
+export function findFluxIsolates(entryDir: string): IsolateModule[] {
+  let out: IsolateModule[] = []
+  walkFiles(join(entryDir, "isolates"), (abs, rel) => {
+    if (/\.[jt]s$/.test(rel) && !rel.endsWith(".d.ts")) {
+      out.push({ id: rel.replace(/\.[jt]s$/, ""), path: abs })
+    }
+  })
+  out.sort((a, b) => (a.id < b.id ? -1 : 1))
+  return out
+}
+
+// A bundle cannot carry its isolate bundles inside itself, so they travel in
+// the isolates/ dir next to it: `<dir>/isolates/<id>.js` (or `.bin`,
+// compiled) beside the bundle file - the shape the flux runtime and an
+// installed version dir resolve. Writes are confined to bundle-owned output
+// dirs (the ensureOutDir rule in the bundle command); loads read the dir
+// from wherever the bundle sits.
+export function bundleIsolatesDir(bundlePath: string): string {
+  return join(dirname(bundlePath), "isolates")
+}
+
+/** A prebuilt bundle's isolate bundles, read back from its sibling dir; no dir means none. */
+export function readPrebuiltIsolates(bundlePath: string): { id: string; code: string }[] {
+  let out: { id: string; code: string }[] = []
+  walkFiles(bundleIsolatesDir(resolvePath(bundlePath)), (abs, rel) => {
+    if (rel.endsWith(".js")) {
+      out.push({ id: rel.replace(/\.js$/, ""), code: readFileSync(abs, "utf8") })
+    }
+  })
+  out.sort((a, b) => (a.id < b.id ? -1 : 1))
+  return out
+}
+
+// Loading a prebuilt .srt.js re-publishes its sibling isolate bundles through
+// the dev flow - written where the server's /isolates/ route serves from,
+// listed in the manifest - so isolate() works as it does from a source build.
+export function prebuiltManifest(code: string, path: string, projectDir: string): string {
+  let isolates = readPrebuiltIsolates(path)
+  writeIsolates(devIsolatesDir(projectDir), isolates)
+  return buildManifest(code, path, isolateManifestAssets(isolates))
 }
 
 // Bundle for the bare Flux runtime: no Solid plugin, flux: modules stay external.
@@ -314,7 +386,8 @@ export async function bundleFlux(entry: string): Promise<string> {
   return codeFromOutputs(result.outputs)
 }
 
-// Bundle for the SolidRT runtime via the standard Solid-aware bundler.
+// Bundle for the SolidRT runtime via the standard Solid-aware bundler, or
+// exit the command on a failed build.
 export async function bundleSolid(): Promise<BundleResult> {
   let result = await bundle()
   if (!result) {
@@ -324,10 +397,12 @@ export async function bundleSolid(): Promise<BundleResult> {
   return result
 }
 
-// Compile JS source to QuickJS bytecode via the fluxc binary.
-export async function compileToBytecode(jsCode: string): Promise<Buffer> {
+// Compile JS source to QuickJS bytecode via the fluxc binary. `moduleName` is
+// what stack frames cite at runtime: "main" for the entry, the isolate id for
+// an isolate bundle.
+export async function compileToBytecode(jsCode: string, moduleName = "main"): Promise<Buffer> {
   let compiler = requireBinary("fluxc")
-  let proc = Bun.spawn([compiler], {
+  let proc = Bun.spawn([compiler, moduleName], {
     stdin: new Blob([jsCode]),
     stdout: "pipe",
     stderr: "inherit",