@solidrt/cli 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -16,15 +16,16 @@
     "@babel/core": "^7.28.5",
     "@babel/preset-typescript": "^7.28.5",
     "babel-preset-solid": "2.0.0-beta.14",
+    "bonjour-service": "^1.4.0",
     "qrcode-generator": "^2.0.4"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.8",
-    "@solidrt/linux-x64-gnu": "0.0.8",
-    "@solidrt/win32-x64-msvc": "0.0.8"
+    "@solidrt/darwin-arm64": "0.0.10",
+    "@solidrt/linux-x64-gnu": "0.0.10",
+    "@solidrt/win32-x64-msvc": "0.0.10"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.8",
+    "@solidrt/core": "0.0.10",
     "typescript": "^5"
   },
   "devDependencies": {

package/src/args.ts

@@ -5,6 +5,7 @@ export let { values, positionals } = parseArgs({
     dev: { type: "boolean", short: "d", default: false },
     minify: { type: "boolean", short: "m", default: false },
     compile: { type: "boolean", short: "c", default: false },
+    flux: { type: "boolean", short: "f", default: false },
     stdout: { type: "boolean", default: false },
     output: { type: "string", short: "o" },
     "proxy-files": { type: "boolean", default: false },
@@ -12,6 +13,8 @@ export let { values, positionals } = parseArgs({
     fps: { type: "string" },
     duration: { type: "string" },
     size: { type: "string" },
+    android: { type: "boolean", default: false },
+    device: { type: "string" },
   },
   allowPositionals: true,
 })
@@ -23,6 +26,40 @@ 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")
 
+function usage(line: string): never {
+  console.error("Usage: " + line)
+  process.exit(1)
+}
+
+// Per-command argument requirements. Called once before dispatch.
+export function validateArgs() {
+  switch (command) {
+    case "bundle":
+      if (values.flux) {
+        if (!source || !isTs) usage("srt bundle --flux [options] <entry.[ts|js]>")
+      } else if (!source || (!isSource && !isPrebuilt)) {
+        usage("srt bundle [options] <entry.[tsx|jsx|ts|js|srt.js|srt.bin]>")
+      }
+      break
+    case "record":
+      if (!source || !isTsx) usage("srt record <entry.[tsx|jsx]>")
+      break
+    case "pack":
+      if (values.flux) {
+        if (!source || !isTs) usage("srt pack --flux [options] <entry.[ts|js]>")
+      } else if (!source || !isSource) {
+        usage("srt pack [options] <entry.[tsx|jsx|ts|js]>")
+      }
+      break
+  }
+
+  // --android installs/launches the client on a device; it is a client action,
+  // so it is only valid for `client`.
+  if (values.android && command !== "client") {
+    usage("srt client --android  (--android is only valid with the client command)")
+  }
+}
+
 export function printUsage() {
   console.error(`Usage: srt <command> [options] [file]
 
@@ -32,7 +69,7 @@ Commands:
   client                 Start solidrt-go client only
   bundle <file>          Transpile TS/JS/TSX/JSX to JS or bytecode
   record <file.tsx|jsx>  Capture frames for video generation
-  pack <file.ts|js>      Bundle + compile to a standalone executable (experimental, Flux only)
+  pack <file>            Bundle + compile to a standalone executable (experimental)
 
 run/server options:
       --proxy-files      Route file/dir access through the dev server
@@ -41,13 +78,23 @@ run/server options:
 run/client options:
       --size <WxH>       Window size (default: 1280x720)
 
+client options:
+      --android          Install and launch the client on a connected Android device
+      --device <serial>  Target a specific adb device by serial or unique prefix
+
 bundle options:
+  -f, --flux             Bundle for the bare Flux runtime, without SolidJS (entry must be .ts|.js)
   -d, --dev              Use development build of SolidJS (default: production)
   -m, --minify           Minify the output
   -c, --compile          Compile to bytecode
   -o, --output <name>    Output filename
       --stdout           Write bundle to stdout
 
+pack options:
+  -f, --flux             Pack for the bare Flux runtime instead of SolidRT (entry must be .ts|.js)
+  -m, --minify           Minify the output
+  -o, --output <name>    Output filename
+
 record options:
       --fps <N>          Frames per second (default: 60)
       --duration <N>     Duration in seconds (default: 1)

package/src/{native.ts → artifacts.ts}

@@ -41,5 +41,30 @@ export function resolveBinary(name: string) {
     } catch {}
   }
 
+  return null
+}
+
+// The Android client APK is per-ABI (it bundles native .so for one architecture)
+// and host-independent, so it lives under dist/android/<abi>/ rather than the
+// host triple map. Only arm64-v8a is supported for now.
+let ANDROID_ABI = "arm64-v8a"
+let ANDROID_PKG = "@solidrt/android-arm64-v8a"
+
+export function resolveApk() {
+  // 1. SRT_HOME: contributor checkout, where `make dist-android` stages the APK
+  //    under dist/android/<abi>/.
+  let srtRoot = process.env.SRT_HOME
+  if (srtRoot) {
+    let apk = resolve(srtRoot, "dist/android", ANDROID_ABI, "solidrt-go.apk")
+    if (existsSync(apk)) return apk
+  }
+
+  // 2. Platform npm package
+  try {
+    let pkgDir = dirname(require.resolve(`${ANDROID_PKG}/package.json`))
+    let apk = resolve(pkgDir, "solidrt-go.apk")
+    if (existsSync(apk)) return apk
+  } catch {}
+
   return null
 }

package/src/bundler.ts

@@ -0,0 +1,117 @@
+import { transformAsync } from "@babel/core"
+import ts from "@babel/preset-typescript"
+import solid from "babel-preset-solid"
+import { type BunPlugin } from "bun"
+import { values, source } from "./args"
+import { state, print, requireBinary } from "./util"
+
+// Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
+// generate, targeting @solidrt/core) plus the TS preset.
+function solidPlugin(): BunPlugin {
+  return {
+    name: "bun-plugin-solid",
+    setup: (build) => {
+      build.onLoad({ filter: /\.(js|ts)x$/ }, async (args) => {
+        let file = Bun.file(args.path)
+        let code = await file.text()
+        let transforms = await transformAsync(code, {
+          filename: args.path,
+          presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
+        })
+        return { contents: transforms?.code ?? "", loader: "js" }
+      })
+    },
+  }
+}
+
+export async function bundle(entry = source) {
+  let result = null
+
+  let devBase = state.serverUrl ?? undefined
+  let dev = !!devBase || values.dev
+  print(`[cli] Bundling (${dev ? "development" : "production"})`)
+  let define: Record<string, string> = {
+    "process.env.NODE_ENV": dev ? "development" : "production",
+  }
+  if (devBase) define.__SRT_DEV_BASE__ = devBase
+
+  try {
+    result = await Bun.build({
+      entrypoints: [entry!],
+      target: "browser",
+      format: "esm",
+      minify: values.minify,
+      external: ["flux:*", "srt:*"],
+      define,
+      plugins: [solidPlugin()],
+    })
+  } catch (e) {
+    console.error("[cli] compile error:\n", e)
+    return null
+  }
+
+  if (result?.success) {
+    return result
+  }
+
+  if (result) {
+    for (let msg of result?.logs) console.error(msg)
+  }
+  return null
+}
+
+export async function bundleTo(outfile: string) {
+  let result = await bundle()
+  if (!result) {
+    console.error("Build failed")
+    process.exit(1)
+  }
+  for (let output of result.outputs) {
+    await Bun.write(outfile, output)
+  }
+  return result
+}
+
+// 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({
+    entrypoints: [entry],
+    target: "browser",
+    format: "esm",
+    minify: values.minify,
+    external: ["flux:*"],
+  })
+  if (!result.success) {
+    for (let msg of result.logs) console.error(msg)
+    console.error("Build failed")
+    process.exit(1)
+  }
+  let jsCode = ""
+  for (let output of result.outputs) jsCode += await output.text()
+  return jsCode
+}
+
+// Bundle for the SolidRT runtime via the standard Solid-aware bundler.
+export async function bundleSolid(): Promise<string> {
+  let result = await bundle()
+  if (!result) {
+    console.error("Build failed")
+    process.exit(1)
+  }
+  let jsCode = ""
+  for (let output of result.outputs) jsCode += await output.text()
+  return jsCode
+}
+
+// Compile JS source to QuickJS bytecode via the fluxc binary.
+export async function compileToBytecode(jsCode: string): Promise<Buffer> {
+  let compiler = requireBinary("fluxc")
+  let proc = Bun.spawn([compiler], {
+    stdin: new Blob([jsCode]),
+    stdout: "pipe",
+    stderr: "inherit",
+  })
+  let [bytecode, code] = await Promise.all([new Response(proc.stdout).arrayBuffer(), proc.exited])
+  if (code !== 0) process.exit(code)
+  return Buffer.from(bytecode)
+}

package/src/cache.ts

@@ -46,6 +46,21 @@ export function isEnabled(): boolean {
   return enabled
 }
 
+// Strings returned by bun:sqlite carry an internal representation that
+// Headers.set() rejects, even when value-identical to an acceptable string
+// (Bun bug, present through 1.3.14). Rebuilding each char yields a clean string.
+function reflatten(s: string): string {
+  return Array.from(s, (c) => String.fromCharCode(c.charCodeAt(0))).join("")
+}
+
+function reflattenHeaders(obj: Record<string, string>): Record<string, string> {
+  let out: Record<string, string> = {}
+  for (let key in obj) {
+    out[reflatten(key)] = reflatten(obj[key]!)
+  }
+  return out
+}
+
 function keyFor(method: string, url: string): string {
   let h = createHash("sha256")
   h.update(method)
@@ -101,7 +116,7 @@ export function get(method: string, url: string): Entry | null {
     method: row.method,
     url: row.url,
     status: row.status,
-    headers: JSON.parse(row.headers),
+    headers: reflattenHeaders(JSON.parse(row.headers)),
     body: row.body,
     cachedAt: row.cached_at,
   }

package/src/commands/bundle.ts

@@ -0,0 +1,84 @@
+import { values, source, isPrebuilt } from "../args"
+import { bundle, bundleTo, bundleFlux, compileToBytecode } from "../bundler"
+import { resolve } from "path"
+
+// Write to stdout and resolve only once the whole payload is flushed.
+// process.stdout.write to a pipe is async and applies backpressure; the
+// callback fires after every byte is drained, so it is safe to exit after.
+function writeStdout(data: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    process.stdout.write(data, (err) => (err ? reject(err) : resolve()))
+  })
+}
+
+// Compile JS to a .srt.bin file and report its size.
+async function writeBytecode(jsCode: string, outfile: string) {
+  let bytecode = await compileToBytecode(jsCode)
+  await Bun.write(outfile, bytecode)
+  let binSize = (await Bun.file(outfile).stat()).size
+  console.log(`>> wrote ${binSize} bytes to ${outfile}`)
+}
+
+export async function runBundleCommand() {
+  if (values.flux) {
+    let baseName = values.output ?? source!.replace(/\.[jt]s$/, "")
+    let jsCode = await bundleFlux(source!)
+
+    if (values.stdout) {
+      await writeStdout(jsCode)
+    } else if (values.compile) {
+      await writeBytecode(jsCode, baseName + ".flux.bin")
+    } else {
+      let outfile = baseName + ".flux.js"
+      await Bun.write(outfile, jsCode)
+      console.log(`>> wrote ${jsCode.length} bytes to ${outfile}`)
+    }
+    process.exit()
+  }
+
+  if (isPrebuilt) {
+    if (!source!.endsWith(".srt.js")) {
+      console.error("Can only compile .srt.js files. .srt.bin is already compiled.")
+      process.exit(1)
+    }
+    let jsFile = resolve(source!)
+    let binOut = jsFile.replace(/\.srt\.js$/, ".srt.bin").replace(/\.js$/, ".bin")
+    await writeBytecode(await Bun.file(jsFile).text(), binOut)
+    process.exit()
+  }
+
+  let baseName = values.output ?? source!.replace(/\.[jt]sx?$/, "")
+
+  if (values.stdout) {
+    let result = await bundle()
+    if (!result) {
+      console.error("Build failed")
+      process.exit(1)
+    }
+    for (let output of result.outputs) {
+      await writeStdout(await output.text())
+    }
+    process.exit()
+  }
+
+  if (values.compile) {
+    let result = await bundle()
+    if (!result) {
+      console.error("Build failed")
+      process.exit(1)
+    }
+    let jsCode = ""
+    for (let output of result.outputs) {
+      jsCode += await output.text()
+    }
+    await writeBytecode(jsCode, baseName + ".srt.bin")
+    process.exit()
+  }
+
+  let jsOutfile = baseName + ".srt.js"
+  let result = await bundleTo(jsOutfile)
+  for (let output of result.outputs) {
+    console.log(`>> wrote ${output.size} bytes to ${jsOutfile}`)
+  }
+  process.exit()
+}

package/src/commands/client.ts

@@ -0,0 +1,22 @@
+import { values } from "../args"
+import { requireBinary, run } from "../util"
+import { spawnAndroidClient } from "../dev-android"
+
+// Standalone solidrt-go client (no dev server). The `run` command instead uses
+// spawnClient() to launch a client tied to the dev-server lifecycle. Either way
+// the client discovers a dev server over the LAN; with --android it is installed
+// and launched on a connected Android device instead of run locally.
+export async function runClientCommand() {
+  if (values.android) {
+    await spawnAndroidClient()
+    return
+  }
+
+  let runner = requireBinary("solidrt-go")
+  let args: string[] = []
+  if (values.size) args.push("--size", values.size)
+  //TODO add dev server connection
+  // if (source) args.push("--dev-server", source)
+  let exit = await run(runner, args)
+  process.exit(exit)
+}

package/src/commands/pack.ts

@@ -0,0 +1,25 @@
+import { values, source } from "../args"
+import { bundleFlux, bundleSolid } from "../bundler"
+import { packRunner } from "../packer"
+
+// Write the packed executable, mark it runnable, and report its size.
+async function writeExecutable(packed: Buffer, outfile: string) {
+  await Bun.write(outfile, packed)
+  if (process.platform !== "win32") {
+    Bun.spawnSync(["chmod", "+x", outfile])
+  }
+  console.log(`>> wrote ${packed.length} bytes to ${outfile}`)
+}
+
+export async function runPackCommand() {
+  let outfile = values.output ?? source!.replace(/\.[jt]sx?$/, "")
+  // On Windows the packed image is a PE executable; it needs a .exe name to run.
+  if (process.platform === "win32" && !outfile.toLowerCase().endsWith(".exe")) {
+    outfile += ".exe"
+  }
+  let packed = values.flux
+    ? await packRunner("fluxrt", await bundleFlux(source!))
+    : await packRunner("solidrt", await bundleSolid())
+  await writeExecutable(packed, outfile)
+  process.exit()
+}

package/src/commands/record.ts

@@ -0,0 +1,16 @@
+import { source, values } from "../args"
+import { requireBinary, run } from "../util"
+import { bundleTo } from "../bundler"
+import { resolve } from "path"
+
+export async function runRecordCommand() {
+  let jsOutfile = source!.replace(/\.[jt]sx$/, "") + ".srt.js"
+  await bundleTo(jsOutfile)
+  let runner = requireBinary("solidrt-go")
+  let recordArgs = ["--record", resolve(jsOutfile)]
+  if (values.fps) recordArgs.push("--fps", values.fps)
+  if (values.duration) recordArgs.push("--duration", values.duration)
+  if (values.size) recordArgs.push("--size", values.size)
+  let exit = await run(runner, recordArgs)
+  process.exit(exit)
+}

package/src/commands/server.ts

@@ -0,0 +1,45 @@
+import pkg from "../../package.json"
+import { source, isSource, isPrebuilt, values } from "../args"
+import { state, shutdown } from "../util"
+import { bundle } from "../bundler"
+import { startServer } from "../dev-server"
+import { startRepl } from "../repl"
+import { startWatcher } from "../watcher"
+import * as cache from "../cache"
+import { resolve, dirname } from "path"
+
+// Brings up the dev server (HTTP/WS + initial bundle + repl + watcher). The
+// `run` command spawns a local client on top of this from main.ts.
+export async function runServerCommand() {
+  // Initialize state from args
+  state.source = source
+  state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
+
+  if (values["proxy-http"]) {
+    cache.initCache({ dir: process.cwd() })
+    console.log("[cli] HTTP cache enabled")
+  }
+
+  startServer()
+
+  // Bundle initial code if source file given (after server start so the
+  // dev base URL is available to the bundler).
+  if (source && isSource) {
+    let initialResult = await bundle()
+    if (initialResult) {
+      for (let output of initialResult.outputs) {
+        state.currentCode = await output.text()
+      }
+    }
+  } else if (source && isPrebuilt && source.endsWith(".srt.js")) {
+    state.currentCode = await Bun.file(resolve(source)).text()
+  }
+
+  process.on("SIGINT", shutdown)
+  process.on("SIGTERM", shutdown)
+
+  let version = pkg.version === "0.0.0" ? "" : " version " + pkg.version
+  console.log(`[cli] Welcome to SolidRT${version}!`)
+  startRepl()
+  startWatcher()
+}

package/src/dev-android.ts

@@ -0,0 +1,108 @@
+import { print, requireAdb } from "./util"
+import { resolveApk } from "./artifacts"
+import { values } from "./args"
+import { DEV_PORT } from "./dev-server"
+
+// Launch component of the "go" dev-client flavor (see lattice/Makefile.android).
+let PACKAGE_ACTIVITY = "com.solidrt.go/com.solidrt.app.MainActivity"
+
+// Forward the device's loopback DEV_PORT to the host dev server, so the client
+// reaches it at 127.0.0.1:DEV_PORT (see lattice/src/go/connection.rs). This is
+// the adb-reverse path: it works for the emulator (behind NAT, cannot reach the
+// host via LAN mDNS discovery) and for USB-tethered devices alike, and is
+// harmless on any adb connection. (Android only uses this path; the client's
+// mDNS discovery is desktop-only -- see lattice/src/go/connection.rs.)
+function setupAdbReverse(adb: string, target: string) {
+  print(`[cli] Forwarding 127.0.0.1:${DEV_PORT} on ${target} to host dev server`)
+  let res = Bun.spawnSync([adb, "-s", target, "reverse", `tcp:${DEV_PORT}`, `tcp:${DEV_PORT}`], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  if (res.exitCode !== 0) {
+    print(`[cli] adb reverse failed (client will fall back to discovery):\n${res.stderr.toString()}`)
+  }
+}
+
+// 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))
+}
+
+// Resolve the target device serial. 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): string {
+  let devices = listDevices(adb)
+
+  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}". Connected: ${devices.join(", ") || "none"}`)
+      process.exit(1)
+    }
+    return match
+  }
+
+  if (devices.length > 1) {
+    console.error(`Multiple devices connected (${devices.join(", ")}); 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 only
+}
+
+// Install + launch the Android client on a connected device over adb, forwarding
+// its loopback to the host dev server so the client connects at 127.0.0.1 (see
+// setupAdbReverse). Fire-and-forget: the client's lifecycle is tracked via WS
+// connect/disconnect in dev-server.ts, not as a child process here.
+export async function spawnAndroidClient() {
+  let adb = requireAdb()
+
+  let apk = resolveApk()
+  if (!apk) {
+    console.error("Could not find the SolidRT-Go APK.")
+    console.error("Add it with: bun add -d @solidrt/android-arm64-v8a")
+    process.exit(1)
+  }
+
+  let target = resolveTarget(adb)
+
+  print(`[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)
+  }
+
+  setupAdbReverse(adb, target)
+
+  let start = Bun.spawn([adb, "-s", target, "shell", "am", "start", "-n", PACKAGE_ACTIVITY], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  if ((await start.exited) !== 0) {
+    console.error("adb start failed:\n" + (await new Response(start.stderr).text()))
+    process.exit(1)
+  }
+
+  print(`[cli] Launched SolidRT-Go on ${target}; waiting for it to connect to the dev server...`)
+}

package/src/{client.ts → dev-client.ts}

@@ -1,4 +1,5 @@
-import { DEV_HOST, DEV_PORT, state, print, requireBinary } from "./util"
+import { state, print, requireBinary } from "./util"
+import { DEV_HOST, DEV_PORT } from "./dev-server"
 import { values } from "./args"
 
 function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteStream) {

package/src/{server.ts → dev-server.ts}

@@ -1,11 +1,26 @@
 import { resolve } from "path"
 import { stat as fsStat, readdir } from "node:fs/promises"
 import { networkInterfaces } from "node:os"
-import { createSocket } from "node:dgram"
+import { Bonjour } from "bonjour-service"
 import qrcode from "qrcode-generator"
-import { DEV_HOST, DEV_PORT, state, print, buildReload } from "./util"
+import { state, print } from "./util"
+import { values } from "./args"
 import * as cache from "./cache"
 
+export const DEV_HOST = "127.0.0.1"
+export const DEV_PORT = 15194
+
+// Dev-server WS protocol helpers: the reload message shape and the stop broadcast.
+export function buildReload(payload: { code?: string | null; bytecode?: string }) {
+  return JSON.stringify({ type: "reload", proxyFiles: values["proxy-files"], proxyHttp: values["proxy-http"], ...payload })
+}
+
+export function broadcastStop() {
+  for (let ws of state.clients.keys()) {
+    ws.send(JSON.stringify({ type: "stop" }))
+  }
+}
+
 function headersToObject(h: Headers): Record<string, string> {
   let out: Record<string, string> = {}
   h.forEach((v, k) => {
@@ -13,7 +28,6 @@ function headersToObject(h: Headers): Record<string, string> {
   })
   return out
 }
-
 async function handleProxy(req: Request): Promise<Response> {
   let target = req.headers.get("x-srt-proxy-url")
   if (!target) {
@@ -141,6 +155,9 @@ export function startServer() {
       open(ws) {
         state.clients.set(ws, { platform: "unknown", version: "unknown" })
         print(`[cli] Client connected ${ws.remoteAddress}`)
+        // Advertise our real LAN address so clients dialed over the adb loopback
+        // can show/remember the directly reachable address (see connection.rs).
+        ws.send(JSON.stringify({ type: "welcome", address: state.serverUrl }))
         if (state.currentCode) {
           ws.send(buildReload({ code: state.currentCode }))
         }
@@ -184,31 +201,43 @@ export function startServer() {
   qr.addData(serverUrl)
   qr.make()
   let modCount = qr.getModuleCount()
-  for (let y = 0; y < modCount; y += 2) {
-    let row = "  "
-    for (let x = 0; x < modCount; x++) {
-      let top = qr.isDark(y, x)
-      let bot = y + 1 < modCount && qr.isDark(y + 1, x)
+  // Render as a white tile with black modules (explicit ANSI colors) plus the
+  // 4-module quiet zone the QR spec requires. Drawing with the terminal's
+  // default foreground inverts the code on dark themes, which standard
+  // decoders reject.
+  const QR_INK = "\x1b[30;107m" // black modules on bright-white tile (tile = background)
+  const QR_TILE_FG = "\x1b[97m" // bright-white as foreground over the default background
+  const QR_RESET = "\x1b[0m"
+  const QUIET_ZONE = 2 // modules (spec says 4, but scanners cope and it reads tighter)
+  let qrWidth = modCount + 2 * QUIET_ZONE
+  let dark = (y: number, x: number) => y >= 0 && y < modCount && x >= 0 && x < modCount && qr.isDark(y, x)
+  // modCount is always odd, so the tile is a half-line taller than an even row
+  // count. The loop packs two module-rows per line via half-blocks and stops on
+  // the last content row, leaving the bottom quiet zone half a line short of the
+  // full-line top quiet zone.
+  for (let y = -QUIET_ZONE; y < modCount + QUIET_ZONE - 1; y += 2) {
+    let row = "  " + QR_INK
+    for (let x = -QUIET_ZONE; x < modCount + QUIET_ZONE; x++) {
+      let top = dark(y, x)
+      let bot = dark(y + 1, x)
       row += top && bot ? "\u2588" : top ? "\u2580" : bot ? "\u2584" : " "
     }
-    console.log(row)
+    console.log(row + QR_RESET)
   }
+  // Close that gap with a half-height tile line: upper half painted in the tile
+  // color (foreground), lower half the terminal background. The 0.5 here plus
+  // the 0.5 already under the last content row equal the full-line top margin.
+  console.log("  " + QR_TILE_FG + "\u2580".repeat(qrWidth) + QR_RESET)
 
   console.log("")
   console.log(`[cli] WebSocket server on ws://${serverUrl}`)
 
-  // UDP discovery
-  let udp = createSocket("udp4")
-  udp.on("message", (msg, rinfo) => {
-    if (msg.toString() === "SRT_DISCOVER") {
-      print(`[cli] Discovery request from ${rinfo.address}:${rinfo.port}`)
-      udp.send("SRT_SERVER", rinfo.port, rinfo.address)
-    }
-  })
-  udp.bind(DEV_PORT, () => {
-    udp.setBroadcast(true)
-    print("[cli] UDP discovery listener on port " + DEV_PORT)
-  })
+  // LAN discovery: advertise the dev server as a DNS-SD service so go clients on
+  // the same network can find it (see lattice/src/go/connection.rs). Stored on
+  // state so shutdown() can send the mDNS goodbye.
+  state.bonjour = new Bonjour()
+  state.bonjour.publish({ name: "SolidRT Dev Server", type: "solidrt", protocol: "tcp", port: DEV_PORT })
+  print(`[cli] Advertising _solidrt._tcp on port ${DEV_PORT} via mDNS`)
 
   // Keepalive
   setInterval(() => {

package/src/main.ts

@@ -1,52 +1,16 @@
 #!/usr/bin/env bun
 
-// Build/run script that bundles/runs a Solid-RT app for the QuickJS runtime.
-//
-// Usage:
-//   srt run                             - start dev server + client
-//   srt run examples/hello.tsx          - start dev server + client, bundle + push via WS
-//   srt server examples/hello.tsx       - start dev server only, no client
-//   srt client                          - start dev client only (connects to WS server)
-//   srt bundle examples/hello.tsx       - bundle TSX to .srt.js
-//   srt bundle -c examples/hello.tsx    - bundle TSX to .srt.js + compile to .srt.bin
-//   srt bundle examples/hello.srt.js   - compile .srt.js to .srt.bin
-//   srt record examples/hello.tsx       - bundle TSX and run with frame capture
-
-import pkg from "../package.json"
-import { values, command, source, isTsx, isTs, isSource, isPrebuilt, printUsage } from "./args"
-import { state, requireBinary, run, shutdown } from "./util"
-import { bundle, bundleTo, runBundleCommand } from "./bundle"
-import { runPackCommand } from "./pack"
-import { startServer } from "./server"
-import { spawnClient } from "./client"
-import { startRepl } from "./repl"
-import { startWatcher } from "./watcher"
-import * as cache from "./cache"
-import { resolve, dirname } from "path"
+import { values, command, validateArgs, printUsage } from "./args"
+import { runBundleCommand } from "./commands/bundle"
+import { runPackCommand } from "./commands/pack"
+import { runRecordCommand } from "./commands/record"
+import { runServerCommand } from "./commands/server"
+import { runClientCommand } from "./commands/client"
+import { spawnClient } from "./dev-client"
 
 // -- Validate args --
 
-let COMMANDS = ["run", "server", "client", "bundle", "record", "pack"]
-
-if (!command || !COMMANDS.includes(command)) {
-  printUsage()
-  process.exit(1)
-}
-
-if (command === "bundle" && (!source || (!isSource && !isPrebuilt))) {
-  console.error("Usage: srt bundle [options] <entry.[tsx|jsx|ts|js|srt.js|srt.bin]>")
-  process.exit(1)
-}
-
-if (command === "record" && (!source || !isTsx)) {
-  console.error("Usage: srt record <entry.[tsx|jsx]>")
-  process.exit(1)
-}
-
-if (command === "pack" && (!source || !isTs)) {
-  console.error("Usage: srt pack [options] <entry.[ts|js]>")
-  process.exit(1)
-}
+validateArgs()
 
 // Force the production export condition for prod bundles. Bun auto-activates the
 // "development" condition whenever NODE_ENV != "production" (read once at startup),
@@ -69,76 +33,22 @@ if (isProdBuild && process.env.NODE_ENV !== "production") {
   process.exit(proc.exitCode ?? 0)
 }
 
-// -- Bundle command --
+// -- Dispatch --
 
 if (command === "bundle") {
   await runBundleCommand()
-}
-
-if (command === "pack") {
+} else if (command === "pack") {
   await runPackCommand()
-}
-
-// -- Record command --
-
-if (command === "record") {
-  let jsOutfile = source!.replace(/\.[jt]sx$/, "") + ".srt.js"
-  await bundleTo(jsOutfile)
-  let runner = requireBinary("solidrt-go")
-  let recordArgs = ["--record", resolve(jsOutfile)]
-  if (values.fps) recordArgs.push("--fps", values.fps)
-  if (values.duration) recordArgs.push("--duration", values.duration)
-  if (values.size) recordArgs.push("--size", values.size)
-  let exit = await run(runner, recordArgs)
-  process.exit(exit)
-}
-
-// -- Client command --
-
-if (command === "client") {
-  let runner = requireBinary("solidrt-go")
-  let args: string[] = []
-  if (values.size) args.push("--size", values.size)
-  //TODO add dev server connection
-  // if (source) args.push("--dev-server", source)
-  let exit = await run(runner, args)
-  process.exit(exit)
-}
-
-// -- Server / Run command --
-
-// Initialize state from args
-state.source = source
-state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
-
-if (values["proxy-http"]) {
-  cache.initCache({ dir: process.cwd() })
-  console.log("[cli] HTTP cache enabled")
-}
-
-startServer()
-
-// Bundle initial code if source file given (after server start so the
-// dev base URL is available to the bundler).
-if (source && isSource) {
-  let initialResult = await bundle()
-  if (initialResult) {
-    for (let output of initialResult.outputs) {
-      state.currentCode = await output.text()
-    }
-  }
-} else if (source && isPrebuilt && source.endsWith(".srt.js")) {
-  state.currentCode = await Bun.file(resolve(source)).text()
-}
-
-if (command === "run") {
+} else if (command === "record") {
+  await runRecordCommand()
+} else if (command === "client") {
+  await runClientCommand()
+} else if (command === "server") {
+  await runServerCommand()
+} else if (command === "run") {
+  await runServerCommand()
   spawnClient()
-}
-
-process.on("SIGINT", shutdown)
-process.on("SIGTERM", shutdown)
-
-let version = pkg.version === "0.0.0" ? "" : " version " + pkg.version
-console.log(`[cli] Welcome to SolidRT${version}!`)
-startRepl()
-startWatcher()
+} else {
+  printUsage()
+  process.exit(1)
+}

package/src/packer.ts

@@ -0,0 +1,27 @@
+import { requireBinary } from "./util"
+import { compileToBytecode } from "./bundler"
+
+// Trailer magic identifying the runner an embedded payload belongs to. Must match
+// the runner-side checks: fluxrt -> flux/src/bin/fluxrt.rs, solidrt ->
+// lattice/src/main.rs (load_embedded_bytecode).
+const MAGIC = {
+  fluxrt: Buffer.from([0x46, 0x4c, 0x55, 0x58, 0x52, 0x54, 0x88, 0x44]), // "FLUXRT\x88\x44"
+  solidrt: Buffer.from([0x53, 0x4f, 0x4c, 0x49, 0x44, 0x52, 0x54, 0x88, 0x44]), // "SOLIDRT\x88\x44"
+}
+
+export type Runner = keyof typeof MAGIC
+
+// Compile JS to bytecode and append it to the runner binary, followed by a
+// trailer of [u64 offset LE][8-byte magic]. The runner reads its own image at
+// startup, validates the magic, and slices the bytecode back out.
+export async function packRunner(runner: Runner, jsCode: string): Promise<Buffer> {
+  let bytecode = await compileToBytecode(jsCode)
+
+  let runnerPath = requireBinary(runner)
+  let runnerBytes = Buffer.from(await Bun.file(runnerPath).arrayBuffer())
+
+  let offsetBuf = Buffer.allocUnsafe(8)
+  offsetBuf.writeBigUInt64LE(BigInt(runnerBytes.length))
+
+  return Buffer.concat([runnerBytes, bytecode, offsetBuf, MAGIC[runner]])
+}

package/src/repl.ts

@@ -1,8 +1,9 @@
 import { createInterface } from "node:readline"
 import { resolve, dirname } from "path"
 import { readdirSync } from "node:fs"
-import { state, print, printErr, broadcastStop, buildReload, shutdown } from "./util"
-import { bundle } from "./bundle"
+import { state, print, printErr, shutdown } from "./util"
+import { buildReload, broadcastStop } from "./dev-server"
+import { bundle } from "./bundler"
 import { startWatcher, stopWatcher } from "./watcher"
 
 function cmdStop(args: string) {

package/src/util.ts

@@ -1,10 +1,9 @@
-import { resolveBinary } from "./native"
-import { values } from "./args"
+import { resolveBinary } from "./artifacts"
+import { existsSync } from "node:fs"
+import { resolve } from "node:path"
 import type { Interface as ReadlineInterface } from "node:readline"
 import type { Server as BunServer } from "bun"
-
-export const DEV_HOST = "127.0.0.1"
-export const DEV_PORT = 15194
+import type { Bonjour } from "bonjour-service"
 
 export let state = {
   clients: new Map<any, { platform: string; version: string }>(),
@@ -15,13 +14,53 @@ export let state = {
   server: null as BunServer<undefined> | null,
   serverUrl: null as string | null,
   rl: null as ReadlineInterface | null,
+  bonjour: null as Bonjour | null,
+}
+
+// Build target per binary, for the "not found" hint. Run from the repo root.
+let BUILD_HINTS: Record<string, string> = {
+  "solidrt-go": "make client",
+  solidrt: "make runtime",
+  flux: "make -C flux flux",
+  fluxc: "make -C flux fluxc",
+  fluxrt: "make -C flux fluxrt PROFILE=release-opt",
 }
 
 export function requireBinary(name: string) {
   let path = resolveBinary(name)
   if (path) return path
+  let hint = BUILD_HINTS[name]
   console.error(`Could not find ${name} binary.`)
-  console.error("Build from source: run make solidrt-go, then set SRT_HOME=<SolidRT project home>")
+  if (hint) {
+    console.error(`Build it from source: run ${hint}, with SRT_HOME pointing at your SolidRT checkout.`)
+  } else {
+    console.error("Build it from source, with SRT_HOME pointing at your SolidRT checkout.")
+  }
+  process.exit(1)
+}
+
+// adb is a system tool (Android Platform Tools), never bundled. Look on PATH
+// first, then the standard SDK location.
+export 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
+}
+
+export 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)
 }
 
@@ -42,18 +81,9 @@ export function printErr(...args: any[]) {
   state.rl?.prompt(true)
 }
 
-export function buildReload(payload: { code?: string | null; bytecode?: string }) {
-  return JSON.stringify({ type: "reload", proxyFiles: values["proxy-files"], proxyHttp: values["proxy-http"], ...payload })
-}
-
-export function broadcastStop() {
-  for (let ws of state.clients.keys()) {
-    ws.send(JSON.stringify({ type: "stop" }))
-  }
-}
-
 export function shutdown() {
   if (state.child) state.child.kill()
   if (state.server) state.server.stop()
+  if (state.bonjour) state.bonjour.destroy()
   process.exit(0)
 }

package/src/watcher.ts

@@ -1,7 +1,8 @@
 import { watch } from "node:fs"
 import { resolve, dirname } from "path"
-import { state, print, printErr, buildReload } from "./util"
-import { bundle } from "./bundle"
+import { state, print, printErr } from "./util"
+import { buildReload } from "./dev-server"
+import { bundle } from "./bundler"
 
 let currentWatcher: ReturnType<typeof watch> | null = null
 

package/src/bun-plugin-solid.ts

@@ -1,21 +0,0 @@
-import { transformAsync } from "@babel/core"
-import ts from "@babel/preset-typescript"
-import solid from "babel-preset-solid"
-import { type BunPlugin } from "bun"
-
-export function solidPlugin(): BunPlugin {
-  return {
-    name: "bun-plugin-solid",
-    setup: (build) => {
-      build.onLoad({ filter: /\.(js|ts)x$/ }, async (args) => {
-        let file = Bun.file(args.path)
-        let code = await file.text()
-        let transforms = await transformAsync(code, {
-          filename: args.path,
-          presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
-        })
-        return { contents: transforms?.code ?? "", loader: "js" }
-      })
-    },
-  }
-}

package/src/bundle.ts

@@ -1,126 +0,0 @@
-import { solidPlugin } from "./bun-plugin-solid"
-import { values, source, isPrebuilt } from "./args"
-import { requireBinary, state, print } from "./util"
-import { resolve } from "path"
-
-export async function bundle(entry = source) {
-  let result = null
-
-  let devBase = state.serverUrl ?? undefined
-  let dev = !!devBase || values.dev
-  print(`[cli] Bundling (${dev ? "development" : "production"})`)
-  let define: Record<string, string> = {
-    "process.env.NODE_ENV": dev ? "development" : "production",
-  }
-  if (devBase) define.__SRT_DEV_BASE__ = devBase
-
-  try {
-    result = await Bun.build({
-      entrypoints: [entry!],
-      target: "browser",
-      format: "esm",
-      minify: values.minify,
-      external: ["flux:*"],
-      define,
-      plugins: [solidPlugin()],
-    })
-  } catch (e) {
-    console.error("[cli] compile error:\n", e)
-    return null
-  }
-
-  if (result?.success) {
-    return result
-  }
-
-  if (result) {
-    for (let msg of result?.logs) console.error(msg)
-  }
-  return null
-}
-
-export async function bundleTo(outfile: string) {
-  let result = await bundle()
-  if (!result) {
-    console.error("Build failed")
-    process.exit(1)
-  }
-  for (let output of result.outputs) {
-    await Bun.write(outfile, output)
-  }
-  return result
-}
-
-async function compileJs(jsCode: string, outfile: string) {
-  let compiler = requireBinary("fluxc")
-  let proc = Bun.spawn([compiler], {
-    stdin: new Blob([jsCode]),
-    stdout: "pipe",
-    stderr: "inherit",
-  })
-  let [bytecode, code] = await Promise.all([new Response(proc.stdout).arrayBuffer(), proc.exited])
-  if (code !== 0) process.exit(code)
-  await Bun.write(outfile, bytecode)
-  return outfile
-}
-
-async function compileToBytecode(jsFile: string, outFile?: string) {
-  let jsCode = await Bun.file(jsFile).text()
-  let dest = outFile ?? jsFile.replace(/\.srt\.js$/, ".srt.bin").replace(/\.js$/, ".bin")
-  return compileJs(jsCode, dest)
-}
-
-async function compileFromStdin(jsCode: string, outfile: string) {
-  return compileJs(jsCode, outfile)
-}
-
-export async function runBundleCommand() {
-  if (isPrebuilt) {
-    if (!source!.endsWith(".srt.js")) {
-      console.error("Can only compile .srt.js files. .srt.bin is already compiled.")
-      process.exit(1)
-    }
-    let binOut = await compileToBytecode(resolve(source!))
-    let binSize = (await Bun.file(binOut).stat()).size
-    console.log(`>> wrote ${binSize} bytes to ${binOut}`)
-    process.exit()
-  }
-
-  let baseName = values.output ?? source!.replace(/\.[jt]sx?$/, "")
-
-  if (values.stdout) {
-    let result = await bundle()
-    if (!result) {
-      console.error("Build failed")
-      process.exit(1)
-    }
-    for (let output of result.outputs) {
-      process.stdout.write(await output.text())
-    }
-    process.exit()
-  }
-
-  if (values.compile) {
-    let result = await bundle()
-    if (!result) {
-      console.error("Build failed")
-      process.exit(1)
-    }
-    let jsCode = ""
-    for (let output of result.outputs) {
-      jsCode += await output.text()
-    }
-    let binOutfile = baseName + ".srt.bin"
-    await compileFromStdin(jsCode, binOutfile)
-    let binSize = (await Bun.file(binOutfile).stat()).size
-    console.log(`>> wrote ${binSize} bytes to ${binOutfile}`)
-    process.exit()
-  }
-
-  let jsOutfile = baseName + ".srt.js"
-  let result = await bundleTo(jsOutfile)
-  for (let output of result.outputs) {
-    console.log(`>> wrote ${output.size} bytes to ${jsOutfile}`)
-  }
-  process.exit()
-}

package/src/pack.ts

@@ -1,58 +0,0 @@
-import { values, source } from "./args"
-import { requireBinary } from "./util"
-
-const MAGIC = Buffer.from([0x46, 0x4c, 0x55, 0x58, 0x52, 0x54, 0x00, 0x01]) // "FLUXRT\x00\x01"
-
-async function bundleFlux(entry: string): Promise<string> {
-  let result = await Bun.build({
-    entrypoints: [entry],
-    target: "browser",
-    format: "esm",
-    minify: values.minify,
-    external: ["flux:*"],
-  })
-  if (!result.success) {
-    for (let msg of result.logs) console.error(msg)
-    console.error("Build failed")
-    process.exit(1)
-  }
-  let jsCode = ""
-  for (let output of result.outputs) jsCode += await output.text()
-  return jsCode
-}
-
-async function compileToBytecode(jsCode: string): Promise<Buffer> {
-  let compiler = requireBinary("fluxc")
-  let proc = Bun.spawn([compiler], {
-    stdin: new Blob([jsCode]),
-    stdout: "pipe",
-    stderr: "inherit",
-  })
-  let [bytecode, code] = await Promise.all([new Response(proc.stdout).arrayBuffer(), proc.exited])
-  if (code !== 0) process.exit(code)
-  return Buffer.from(bytecode)
-}
-
-export async function runPackCommand() {
-  let outfile = values.output ?? source!.replace(/\.[jt]s$/, "")
-
-  let jsCode = await bundleFlux(source!)
-
-  let bytecode = await compileToBytecode(jsCode)
-
-  let runner = requireBinary("fluxrt")
-  let runnerBytes = Buffer.from(await Bun.file(runner).arrayBuffer())
-
-  let offsetBuf = Buffer.allocUnsafe(8)
-  offsetBuf.writeBigUInt64LE(BigInt(runnerBytes.length))
-
-  let packed = Buffer.concat([runnerBytes, bytecode, offsetBuf, MAGIC])
-  await Bun.write(outfile, packed)
-
-  if (process.platform !== "win32") {
-    Bun.spawnSync(["chmod", "+x", outfile])
-  }
-
-  console.log(`>> wrote ${packed.length} bytes to ${outfile}`)
-  process.exit()
-}