@solidrt/cli 0.0.51 → 0.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -11,11 +11,10 @@
   "files": [
     "bin/",
     "src/",
-    "server/",
-    "scaffold/",
+    "dist/",
     "fonts/",
-    "agents/",
-    "AGENTS.md"
+    "AGENTS.md",
+    "agents/"
   ],
   "dependencies": {
     "@babel/core": "^7.0.0",
@@ -25,22 +24,22 @@
     "@jridgewell/remapping": "^2.3.0",
     "@jridgewell/trace-mapping": "^0.3.25",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "babel-preset-solid": "2.0.0-rc.0",
+    "@solidjs/babel-plugin": "2.0.0-rc.3",
     "bonjour-service": "^1.4.0",
     "qrcode-generator": "^2.0.4",
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.51",
-    "@solidrt/linux-arm64-gnu": "0.0.51",
-    "@solidrt/linux-x64-gnu": "0.0.51",
-    "@solidrt/win32-x64-msvc": "0.0.51"
+    "@solidrt/darwin-arm64": "0.0.53",
+    "@solidrt/linux-arm64-gnu": "0.0.53",
+    "@solidrt/linux-x64-gnu": "0.0.53",
+    "@solidrt/win32-x64-msvc": "0.0.53"
   },
   "peerDependencies": {
     "typescript": "^7"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.51",
+    "@solidrt/flux-types": "0.0.53",
     "@types/babel__core": "^7.20.5",
     "@types/bun": "latest"
   }

package/src/android/docs.md

@@ -0,0 +1,21 @@
+# srt android
+
+{{ usage android }}
+
+Launches the SolidRT client installed on a connected Android device (or
+emulator) over adb against the dev server: the one serving the project (or
+file) in the current directory, or `--port`. A running instance is restarted
+so it picks the server up. The command then waits a few seconds for the
+client to appear on the server and reports its client id. The server must
+run with `--lan` so the device can reach it; an emulator reaches a loopback
+server through its host alias. `--device` picks one of several connected
+devices by serial or unique prefix.
+
+`--install` installs (or updates) the client first, from the
+`@solidrt/android-<abi>` dev dependency matching the device's ABI; the
+command says which package to add when it is missing. Without `--install`
+the installed client is left as it is, and a note says when its version is
+not the one that package carries - a client you built and installed
+yourself is never replaced unless you ask.
+
+adb is a system tool (Android Platform Tools) and is never bundled.

package/src/android/main.ts

@@ -0,0 +1,286 @@
+import { existsSync } from "node:fs"
+import { networkInterfaces } from "node:os"
+import { resolve } from "node:path"
+import { androidPackageVersion, resolveApk, ANDROID_PKG_MAP } from "../lib/artifacts"
+import { values, port } from "../lib/args"
+import { resolveByPort, resolveFromCwd } from "../lib/registry"
+import type { LiveRecord } from "../types/registry"
+
+// `srt android`: the Android client flow, decoupled from `srt client` (a
+// local process) because a device is a different thing: find it over adb and
+// launch the client installed there pointed at the dev server, which is
+// resolved like `srt client` does (the project at the cwd, or --port). The
+// APK is only touched on --install (from the @solidrt/android-<abi> package
+// matching the device's ABI), so a client built and installed by hand stays;
+// without --install the command just notes when the installed version is not
+// the one the project's package carries.
+
+// Launch component of the "go" dev-client flavor (see lattice/Makefile.android).
+let PACKAGE_ACTIVITY = "com.solidrt.go/com.solidrt.app.MainActivity"
+let PACKAGE = "com.solidrt.go"
+
+let sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+// adb is a system tool (Android Platform Tools), never bundled. Look on PATH
+// first, then the standard SDK location.
+function resolveAdb() {
+  let exe = process.platform === "win32" ? "adb.exe" : "adb"
+  let onPath = Bun.which(exe)
+  if (onPath) return onPath
+  for (let root of [process.env.ANDROID_HOME, process.env.ANDROID_SDK_ROOT]) {
+    if (!root) continue
+    let candidate = resolve(root, "platform-tools", exe)
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+function requireAdb() {
+  let path = resolveAdb()
+  if (path) return path
+  console.error("Could not find adb (Android Platform Tools).")
+  console.error("Install it:")
+  console.error("  Windows: winget install Google.PlatformTools")
+  console.error("  macOS:   brew install android-platform-tools")
+  console.error("  Linux:   install your distro's android-tools / adb package")
+  process.exit(1)
+}
+
+let ipToInt = (ip: string) => ip.split(".").reduce((acc, o) => (acc << 8) + (parseInt(o, 10) & 255), 0) >>> 0
+
+// This host's IPv4 on the same subnet as `deviceIp`: the interface whose
+// (address & netmask) matches the device's. Pure computation over what the OS
+// reports (cross-platform, no routing socket, no hardcoded ranges).
+function hostIpFor(deviceIp: string): string | null {
+  let d = ipToInt(deviceIp)
+  for (let addrs of Object.values(networkInterfaces())) {
+    for (let a of addrs ?? []) {
+      if (a.family === "IPv4" && !a.internal && (ipToInt(a.address) & ipToInt(a.netmask)) === (d & ipToInt(a.netmask))) {
+        return a.address
+      }
+    }
+  }
+  return null
+}
+
+// The device's own IPv4 on its primary network: from the serial for wireless adb
+// (ip:port), else queried over adb. `ip route get` reports the source IP of the
+// route to a public address, i.e. the device's main interface IP.
+function deviceIp(adb: string, target: string): string | null {
+  let m = target.match(/^(\d+\.\d+\.\d+\.\d+):\d+$/)
+  if (m) return m[1] ?? null
+  let res = Bun.spawnSync([adb, "-s", target, "shell", "ip", "route", "get", "1.1.1.1"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  return res.stdout.toString().match(/src (\d+\.\d+\.\d+\.\d+)/)?.[1] ?? null
+}
+
+// The host:port the client on `target` should dial to reach this machine's dev
+// server, by adb transport: the emulator reaches the host through its NAT alias
+// 10.0.2.2; every other transport shares a LAN with the host, so match the
+// device's IP to the host interface on its subnet. Replaces the old adb-reverse
+// loopback tunnel, which never worked over wireless adb. Returns null when the
+// address cannot be resolved (the client then falls back to QR/recents).
+function devServerAddress(adb: string, target: string, server: LiveRecord): string | null {
+  // The emulator's host alias reaches the host's loopback, so a loopback-only
+  // server is fine there; a real device needs a server started with --lan.
+  if (target.startsWith("emulator-")) return `10.0.2.2:${server.port}`
+  if (server.address === "127.0.0.1") {
+    console.log("[cli] The dev server is loopback-only; restart it with --lan so the device can reach it")
+    return null
+  }
+  let dip = deviceIp(adb, target)
+  if (!dip) return null
+  let host = hostIpFor(dip)
+  return host ? `${host}:${server.port}` : null
+}
+
+// The dev server the device should dial: --port picks a local server by
+// port, otherwise the project (or file) in the current directory.
+async function resolveServer(): Promise<LiveRecord> {
+  let resolved = port !== undefined ? await resolveByPort(port) : await resolveFromCwd(process.cwd())
+  if (!resolved.ok) {
+    console.error(resolved.message)
+    process.exit(1)
+  }
+  return resolved.record
+}
+
+// Serials of connected, authorized devices (excludes offline/unauthorized).
+function listDevices(adb: string): string[] {
+  let listed = Bun.spawnSync([adb, "devices"], { stdout: "pipe", stderr: "pipe" })
+  return listed.stdout
+    .toString()
+    .split("\n")
+    .slice(1)
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .filter((l) => l.endsWith("\tdevice"))
+    .map((l) => l.split("\t")[0])
+    .filter((s): s is string => Boolean(s))
+}
+
+// Primary ABI of the connected device (e.g. "arm64-v8a", "armeabi-v7a"), used
+// to pick the matching APK -- a fat (multi-ABI) APK reports its 64-bit ABI
+// here and still installs fine, so this only matters for single-ABI builds.
+function deviceAbi(adb: string, target: string): string {
+  let res = Bun.spawnSync([adb, "-s", target, "shell", "getprop", "ro.product.cpu.abi"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  return res.stdout.toString().trim()
+}
+
+// Always shown up front, regardless of how many devices are connected or
+// whether --device narrows it down: one line per device with the ABI its APK
+// build would target, then (with --install) a dev-dependency hint for each
+// ABI that isn't resolvable locally yet. Returns the device->abi map so
+// callers don't have to re-query it.
+function printDeviceStatus(adb: string, devices: string[]): Map<string, string> {
+  let abiByDevice = new Map<string, string>()
+  let missingAbis = new Set<string>()
+  for (let d of devices) {
+    let abi = deviceAbi(adb, d)
+    abiByDevice.set(d, abi)
+    console.log(`${d} - ${abi}`)
+    if (!resolveApk(abi)) missingAbis.add(abi)
+  }
+  let missingPkgs = [...missingAbis].map((abi) => ANDROID_PKG_MAP[abi]).filter((pkg): pkg is string => Boolean(pkg))
+  if (values.install && missingPkgs.length > 0) {
+    console.log(`Add dev dependencies with: bun add -d ${missingPkgs.join(" ")}`)
+  }
+  return abiByDevice
+}
+
+// The versionName of the client installed on `target`, null when none is.
+function installedVersion(adb: string, target: string): string | null {
+  let res = Bun.spawnSync([adb, "-s", target, "shell", "dumpsys", "package", PACKAGE], { stdout: "pipe", stderr: "pipe" })
+  return res.stdout.toString().match(/versionName=(\S+)/)?.[1] ?? null
+}
+
+type Client = { id: number; platform: string; version: string }
+
+// The clients the dev server currently lists (empty when it cannot be asked).
+async function connectedClients(server: LiveRecord): Promise<Client[]> {
+  try {
+    let resp = await fetch(`http://127.0.0.1:${server.port}/__control__/clients`, { signal: AbortSignal.timeout(1000) })
+    return ((await resp.json()) as { clients?: Client[] }).clients ?? []
+  } catch {
+    return []
+  }
+}
+
+// The first Android client that appears beyond `before`, or null after ~10 s.
+async function waitForClient(server: LiveRecord, before: Set<number>): Promise<Client | null> {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    await sleep(500)
+    let fresh = (await connectedClients(server)).find((c) => c.platform === "android" && !before.has(c.id))
+    if (fresh) return fresh
+  }
+  return null
+}
+
+// Resolve the target device serial (and its ABI). With --device, treat the
+// value as a serial prefix and require it to match exactly one connected
+// device; without it, use the sole connected device. Exits with a clear
+// message on any ambiguity.
+function resolveTarget(adb: string): { target: string; abi: string } {
+  let devices = listDevices(adb)
+  let abiByDevice = printDeviceStatus(adb, devices)
+
+  if (values.device) {
+    let prefix = values.device
+    let matches = devices.filter((d) => d.startsWith(prefix))
+    if (matches.length > 1) {
+      console.error(`--device "${prefix}" is ambiguous; matches: ${matches.join(", ")}`)
+      process.exit(1)
+    }
+    let [match] = matches
+    if (!match) {
+      console.error(`No connected device matches --device "${prefix}".`)
+      process.exit(1)
+    }
+    return { target: match, abi: abiByDevice.get(match)! }
+  }
+
+  if (devices.length > 1) {
+    console.error("Pick one with --device <serial or prefix>.")
+    process.exit(1)
+  }
+  let [only] = devices
+  if (!only) {
+    console.error("No authorized Android device found. Enable USB debugging and check `adb devices`.")
+    process.exit(1)
+  }
+  return { target: only, abi: abiByDevice.get(only)! }
+}
+
+// Launch the Android client on a connected device over adb (installing it
+// first on --install), passing it the dev-server address to dial as a
+// launch-intent extra (see devServerAddress), then wait briefly for it to show
+// up on the dev server. The client is not a child process here: its lifecycle
+// is the WS connect/disconnect the server sees.
+export async function main() {
+  let server = await resolveServer()
+  let adb = requireAdb()
+
+  let { target, abi } = resolveTarget(adb)
+
+  if (values.install) {
+    let apk = resolveApk(abi)
+    if (!apk) {
+      console.error(`Could not find a SolidRT-Go APK for ABI "${abi}".`)
+      let pkg = ANDROID_PKG_MAP[abi]
+      if (pkg) console.error(`Add it with: bun add -d ${pkg}`)
+      process.exit(1)
+    }
+    console.log(`[cli] Installing SolidRT-Go on ${target}`)
+    let install = Bun.spawn([adb, "-s", target, "install", "-r", apk], { stdout: "pipe", stderr: "pipe" })
+    if ((await install.exited) !== 0) {
+      console.error("adb install failed:\n" + (await new Response(install.stderr).text()))
+      process.exit(1)
+    }
+  } else {
+    let installed = installedVersion(adb, target)
+    if (installed === null) {
+      console.error(`No SolidRT-Go client on ${target}; install one with srt android --install`)
+      process.exit(1)
+    }
+    let expected = androidPackageVersion(abi)
+    if (expected !== null && expected !== installed) {
+      console.log(
+        `[cli] Installed client is ${installed}; the project's ${ANDROID_PKG_MAP[abi]} is ${expected} (srt android --install updates it)`,
+      )
+    }
+  }
+
+  // Hand the client the dev-server address to dial, as a launch-intent extra that
+  // MainActivity forwards to native argv (--dev-server); the client auto-connects
+  // to it. Replaces adb reverse, which never worked over wireless adb. -S stops
+  // a running instance first: a delivered intent does not reach one, so without
+  // it the client would keep whatever server it had.
+  let before = new Set((await connectedClients(server)).map((c) => c.id))
+  let devServer = devServerAddress(adb, target, server)
+  let launchArgs = [adb, "-s", target, "shell", "am", "start", "-S", "-n", PACKAGE_ACTIVITY]
+  if (devServer) {
+    console.log(`[cli] Client will dial dev server at ${devServer}`)
+    launchArgs.push("--es", "srt_dev_server", devServer)
+  } else {
+    console.log("[cli] Could not resolve a host address for the device; client will need a manual/QR connect")
+  }
+
+  let start = Bun.spawn(launchArgs, { stdout: "pipe", stderr: "pipe" })
+  if ((await start.exited) !== 0) {
+    console.error("adb start failed:\n" + (await new Response(start.stderr).text()))
+    process.exit(1)
+  }
+
+  console.log(`[cli] Launched SolidRT-Go on ${target}; waiting for it to connect to the dev server...`)
+  let client = await waitForClient(server, before)
+  if (client) {
+    console.log(`[cli] Client ${client.id} connected (${client.platform}, ${client.version})`)
+  } else {
+    console.log(`[cli] No connection after 10 s. The server must run with --lan and the device must reach this machine.`)
+  }
+}

package/src/{bundler.ts → bundle/bundler.ts}

@@ -2,15 +2,17 @@ import { transformAsync } from "@babel/core"
 import jsx from "@babel/plugin-syntax-jsx"
 import ts from "@babel/preset-typescript"
 import remapping from "@jridgewell/remapping"
-import solid from "babel-preset-solid"
+import solid from "@solidjs/babel-plugin"
 import { type BunPlugin, type BuildArtifact } from "bun"
 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, type ManifestAsset } from "./project"
+import { values } from "../lib/args"
+import type { Mode } from "../lib/mode"
+import { requireBinary } from "../lib/util"
+import type { BundleOutput } from "../types/bundle"
+import { buildManifest, manifestAssetFor, type ManifestAsset } from "../lib/project"
 
-// Babel plugin: rewrite `import data from "./x" with { type: "binary" }` into an
+// 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
 // inline string of its UTF-8 contents. The import attribute is invisible to
 // Bun's bundler and its plugins in this Bun version, so we handle it here in the
@@ -21,8 +23,10 @@ import { buildManifest, manifestAssetFor, type ManifestAsset } from "./project"
 // attribute-free path later. Both attributes work on any extension, so shader
 // and other text sources inline by attribute the same way bytes do; `.svg` is
 // additionally text-loaded without an attribute (see Bun's `loader` below).
-function inlineImport({ types: t }: { types: any }) {
-  return {
+// Inlined files leave no trace in the module graph, so the plugin records
+// each one in `inputs` (see `BundleOutput.inputs`).
+function inlineImport(inputs: Set<string>) {
+  return ({ types: t }: { types: any }) => ({
     visitor: {
       ImportDeclaration(path: any, pluginState: any) {
         let attrs = path.node.attributes ?? path.node.assertions
@@ -32,12 +36,13 @@ function inlineImport({ types: t }: { types: any }) {
         let def = path.node.specifiers.find((s: any) => s.type === "ImportDefaultSpecifier")
         if (!def) {
           throw path.buildCodeFrameError(
-            `A ${kind} import needs a default import: import data from "./file" with { type: "${kind}" }`,
+            `A ${kind} import needs a default import: import data from "../file" with { type: "${kind}" }`,
           )
         }
 
         let importer = pluginState.file.opts.filename as string
         let abs = resolvePath(dirname(importer), path.node.source.value)
+        inputs.add(abs)
 
         // text: var <local> = "<contents>"
         // binary: var <local> = Uint8Array.from(atob("<b64>"), c => c.charCodeAt(0))
@@ -56,7 +61,7 @@ function inlineImport({ types: t }: { types: any }) {
         path.replaceWith(t.variableDeclaration("var", [t.variableDeclarator(t.identifier(def.local.name), expr)]))
       },
     },
-  }
+  })
 }
 
 // Concatenate only the JS outputs (entry point plus any code-split chunks) of a
@@ -71,7 +76,7 @@ async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
   return code
 }
 
-// Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
+// Bun build plugin that runs JSX/TSX through @solidjs/babel-plugin (universal
 // generate, targeting @solidrt/core) plus the TS preset. `moduleName` only ends
 // up as an import specifier in the emitted code, resolved from the app's tree at
 // bundle time; the CLI itself never loads core, so core is deliberately neither
@@ -84,25 +89,27 @@ async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
 // collected there, keyed by absolute path, for sourcemap composition later.
 // `isolateEntry` is the one "use isolate" module this build may load (its own
 // entry); loading any other one means a by-value import of an isolate module,
-// which is a build error (see isolate modules below).
-function solidPlugin(babelMaps?: Map<string, object>, isolateEntry?: string): BunPlugin {
+// which is a build error (see isolate modules below). Every file the plugin
+// loads or inlines is recorded in `inputs`.
+function solidPlugin(inputs: Set<string>, babelMaps?: Map<string, object>, isolateEntry?: string): BunPlugin {
   return {
     name: "bun-plugin-solid",
     setup: (build) => {
       build.onLoad({ filter: /\.(js|ts)x?$/ }, async (args) => {
         if (!/\.(js|ts)x$/.test(args.path) && args.path.includes("node_modules")) return
+        inputs.add(args.path)
         let file = Bun.file(args.path)
         let code = await file.text()
         if (args.path !== isolateEntry && hasIsolateDirective(code)) {
           throw new Error(
-            `${args.path} is a "use isolate" module: import its types only (import type * as W from "./...") and call it through isolate() from flux:isolate`,
+            `${args.path} is a "use isolate" module: import its types only (import type * as W from "../...") and call it through isolate() from flux:isolate`,
           )
         }
         let transforms = await transformAsync(code, {
           filename: args.path,
           sourceMaps: !!babelMaps,
-          presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
-          plugins: [jsx, inlineImport],
+          presets: [[ts]],
+          plugins: [jsx, [solid, { moduleName: "@solidrt/core", generate: "universal" }], inlineImport(inputs)],
         })
         if (babelMaps && transforms?.map) babelMaps.set(args.path, transforms.map)
         return { contents: transforms?.code ?? "", loader: "js" }
@@ -171,17 +178,13 @@ export function isolateAssetPath(id: string, ext: "js" | "bin"): string {
   return `isolates/${id}.${ext}`
 }
 
-export type BundleOptions = { entry: string; devBase?: string; dev: boolean; minify: boolean }
+// `project` is the project root (mode.ts decides it, never a search), or
+// null for a file on its own: no assets in the manifest and no isolate
+// modules (isolates are a project feature).
+export type BundleOptions = { entry: string; dev: boolean; minify: boolean; project: string | null }
 
-export type BundleResult = {
-  code: string
-  /** Composed sourcemap JSON (bundle -> original .tsx sources), dev builds only. */
-  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; maps dev builds only. */
-  isolates: { id: string; code: string; map: string | null }[]
-}
+// The `srt bundle --json` stdout contract doubles as the in-process result.
+export type BundleResult = BundleOutput
 
 /**
  * The bundle's sourcemaps keyed by the module name stack frames cite ("main"
@@ -196,7 +199,7 @@ export function bundleMaps(result: BundleResult): Record<string, string> | null
 }
 
 // The pure bundle: every input is explicit, so it runs identically in the srt
-// (Bun) process and in the standalone bundle-cli subprocess the dev server
+// (Bun) process and in the `srt bundle --json` subprocess the dev server
 // spawns. It never touches the ambient args/state singletons and never prints
 // progress (callers own that), so its stdout stays clean for subprocess use.
 export async function bundleWith(opts: BundleOptions): Promise<BundleResult | null> {
@@ -210,12 +213,15 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
     "import.meta.env.DEV": opts.dev ? "true" : "false",
     "process.env.NODE_ENV": opts.dev ? '"development"' : '"production"',
   }
-  if (opts.devBase) define.__SRT_DEV_BASE__ = opts.devBase
 
   // 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). In dev every build gets a composed
   // sourcemap, keyed downstream by its module name.
+  // Every file the bundle depends on (BundleOutput.inputs): what the plugin
+  // loaded or inlined, plus every module in the build's sourcemap, which is
+  // where dependency code (node_modules, workspace packages) shows up.
+  let inputs = new Set<string>()
   let build = async (entry: string, babelMaps?: Map<string, object>, isolateEntry?: string) => {
     let result = null
     try {
@@ -228,7 +234,7 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
         define,
         loader: { ".svg": "text" },
         sourcemap: babelMaps ? "external" : "none",
-        plugins: [solidPlugin(babelMaps, isolateEntry)],
+        plugins: [solidPlugin(inputs, babelMaps, isolateEntry)],
       })
     } catch (e) {
       console.error("[cli] compile error:\n", e)
@@ -238,6 +244,7 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
       for (let msg of result.logs) console.error(msg)
       return null
     }
+    for (let source of await mapSources(result.outputs)) inputs.add(source)
     return result
   }
 
@@ -247,7 +254,8 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
   let code = await codeFromOutputs(main.outputs)
 
   let isolates: { id: string; code: string; map: string | null }[] = []
-  for (let module of findIsolateModules(dirname(resolvePath(opts.entry)))) {
+  let modules = opts.project === null ? [] : findIsolateModules(dirname(resolvePath(opts.entry)))
+  for (let module of modules) {
     let moduleMaps = opts.dev ? new Map<string, object>() : undefined
     let result = await build(module.path, moduleMaps, module.path)
     if (!result) return null
@@ -258,23 +266,43 @@ export async function bundleWith(opts: BundleOptions): Promise<BundleResult | nu
     })
   }
 
+  // The project files the manifest and the build read: package.json (app
+  // identity, icon, fonts) and tsconfig.json (resolution, JSX).
+  if (opts.project !== null) {
+    for (let name of ["package.json", "tsconfig.json"]) {
+      let abs = join(opts.project, name)
+      if (existsSync(abs)) inputs.add(abs)
+    }
+  }
+
   return {
     code,
     map: await composeMap(main.outputs, babelMaps),
-    manifest: buildManifest(code, opts.entry, isolateManifestAssets(isolates)),
+    manifest: buildManifest(code, opts.entry, isolateManifestAssets(isolates), opts.project),
     isolates,
+    inputs: [...inputs].sort(),
   }
 }
 
+// The source files a build's sourcemap cites, as absolute paths (Bun writes
+// them cwd-relative). Empty for a build without a map.
+async function mapSources(outputs: BuildArtifact[]): Promise<string[]> {
+  let out: string[] = []
+  for (let o of outputs) {
+    if ((o.kind !== "entry-point" && o.kind !== "chunk") || !o.sourcemap) continue
+    let map = JSON.parse(await o.sourcemap.text())
+    for (let source of map.sources ?? []) out.push(resolvePath(source))
+  }
+  return out
+}
+
 /** 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
-// unlisted, which is harmless.
+// Write isolate bundles as `<dir>/<id>.js`, the shape the manifest lists and
+// a prebuilt bundle's sibling isolates/ dir carries.
 export function writeIsolates(dir: string, isolates: { id: string; code: string }[]) {
   for (let i of isolates) {
     let file = join(dir, `${i.id}.js`)
@@ -305,20 +333,13 @@ async function composeMap(outputs: BuildArtifact[], babelMaps?: Map<string, obje
   return composed.toString()
 }
 
-export async function bundle(entry = source) {
-  let devBase = state.serverUrl ?? undefined
-  let dev = !!devBase || values.dev
+// The one-shot commands' bundle (bundle, pack, render): production unless
+// --dev, on what the cwd and the argument decide (mode.ts).
+export async function bundle(mode: Mode) {
+  let dev = values.dev
   // Keep stdout clean when the bundle itself is written to stdout.
-  if (!values.stdout) print(`[cli] Bundling (${dev ? "development" : "production"})`)
-  let result = await bundleWith({ entry: entry!, devBase, dev, minify: values.minify })
-  // With a server running, its /isolates/ route serves what we write here.
-  if (result && devBase) writeIsolates(devIsolatesDir(state.projectDir), result.isolates)
-  return result
-}
-
-/** Where a project's dev isolate bundles are written and served from. */
-export function devIsolatesDir(projectDir: string): string {
-  return join(projectDir, ".srt-data", "isolates")
+  if (!values.stdout) console.log(`[cli] Bundling (${dev ? "development" : "production"})`)
+  return bundleWith({ entry: mode.entry, dev, minify: values.minify, project: mode.projectDir })
 }
 
 // A flux entry's isolate modules: everything under its isolates/ dir, id =
@@ -360,15 +381,6 @@ export function readPrebuiltIsolates(bundlePath: string): { id: string; code: st
   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.
 export async function bundleFlux(entry: string): Promise<string> {
   let result = await Bun.build({
@@ -388,8 +400,8 @@ export async function bundleFlux(entry: string): Promise<string> {
 
 // 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()
+export async function bundleSolid(mode: Mode): Promise<BundleResult> {
+  let result = await bundle(mode)
   if (!result) {
     console.error("Build failed")
     process.exit(1)

package/src/bundle/docs.md

@@ -0,0 +1,12 @@
+# srt bundle
+
+{{ usage bundle }}
+
+Writes `dist/bundle/` (or `--output <dir>`): `<name>.srt.js` plus the app's
+isolate modules as `isolates/<id>.js`, or bytecode with `--compile`. Move
+the dir, not the bare file: a bundle loaded without its isolates/ dir loses
+them.
+
+`--flux` targets the bare [Flux runtime](/runtime/) instead of a SolidRT
+app, for scripts and servers with no UI. `--json` is the dev server's
+rebuild contract, one JSON object on stdout.