@solidrt/cli 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -14,20 +14,20 @@
     "AGENTS.md"
   ],
   "dependencies": {
-    "@babel/core": "^8.0.1",
-    "@babel/plugin-syntax-jsx": "^8.0.1",
-    "@babel/preset-typescript": "^8.0.1",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-syntax-jsx": "^7.0.0",
+    "@babel/preset-typescript": "^7.0.0",
     "babel-preset-solid": "2.0.0-beta.15",
     "bonjour-service": "^1.4.0",
     "qrcode-generator": "^2.0.4"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.17",
-    "@solidrt/linux-x64-gnu": "0.0.17",
-    "@solidrt/win32-x64-msvc": "0.0.17"
+    "@solidrt/darwin-arm64": "0.0.19",
+    "@solidrt/linux-x64-gnu": "0.0.19",
+    "@solidrt/win32-x64-msvc": "0.0.19"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.17",
+    "@solidrt/core": "0.0.19",
     "typescript": "^6"
   },
   "devDependencies": {

package/scaffold/AGENTS.md

@@ -5,58 +5,68 @@ runtime. No DOM, no HTML, no CSS cascade. If you are an AI assistant, read this
 before writing or editing code here.
 
 Authoritative references ship inside the installed packages - read them:
-- node_modules/solid-js/CHEATSHEET.md     - SolidJS 2.0 reactivity/control-flow model
-- node_modules/@solidrt/core/AGENTS.md   - element/prop/reactivity model
-- node_modules/@solidrt/core/examples/   - single-concept usage patterns to copy (see its README.md index)
-- node_modules/@solidrt/cli/AGENTS.md    - running, bundling, headless verify
+- node_modules/solid-js/CHEATSHEET.md          - SolidJS 2.0 reactivity/control-flow model
+- node_modules/@solidrt/components/AGENTS.md   - the component vocabulary; build UI from these
+- node_modules/@solidrt/components/README.md   - full prop tables for every component
+- node_modules/@solidrt/core/AGENTS.md         - the underlying element/prop/reactivity model
+- node_modules/@solidrt/core/examples/         - single-concept usage patterns to copy (see its README.md index)
+- node_modules/@solidrt/cli/AGENTS.md          - running, bundling, headless verify
 - node_modules/@solidrt/core/src/types.d.ts and jsx-runtime.d.ts - source of truth
 
 <!-- Claude Code auto-imports these; other tools read the paths above. -->
 @./node_modules/solid-js/CHEATSHEET.md
+@./node_modules/@solidrt/components/AGENTS.md
 @./node_modules/@solidrt/core/AGENTS.md
 @./node_modules/@solidrt/cli/AGENTS.md
 
 ## The things assistants get wrong (this is not React/DOM)
 
 1. This is SolidJS 2.0 (see CHEATSHEET.md for the reactivity/control-flow
-   model), rendering through a custom Rust runtime instead of the DOM. Import
-   the whole authoring surface from @solidrt/core - it re-exports the
-   substrate so you do not have to know which package a symbol lives in:
-   render plus the window/paint/event APIs alongside the standard reactive
-   primitives and control-flow components.
-2. Host elements are lowercase intrinsics: window, view, text, rect, oval, path,
-   texture, audio (+ d- variants). No div/span/img/button.
-3. render(() => <App/>) once, top level. The root MUST be <window> or it throws.
-4. Containers (window, view) DO NOT PAINT. Background = a draw primitive child
-   placed behind the content, e.g. <d-rect color="..." />.
-5. Paint color is the color prop (a CSS color string). No fill/stroke/background
-   prop. Outline: drawStyle="stroke" + strokeWidth.
-6. No onClick/onPress. A button is a <view>/<rect> with onPointerDown.
-7. d- prefix = detached from layout: a plain element is laid out by Taffy, a
-   d-element you position with x/y (omit to fill the parent = how backgrounds
-   work). A detached node cannot have attached (regular, Taffy-laid-out)
-   children - everything under a d-element must itself be detached. Nesting a
-   plain <view>/<text> inside a d-element is an error.
-8. Per-frame animation: onFrame((tick, frame) => {}) is the native hook
-   (runtime-paced, auto-cleans). requestAnimationFrame(t => {}) exists as a
-   web-standard one-shot but is not the preferred animation driver.
-9. Reactive window state: prefer the accessors windowSize(), safeArea(),
-   displayScale(), windowFocused(), keyboardHeight() from @solidrt/core over the
-   onResize / onLayout callbacks for reading layout and window state.
-10. Device/GPU via subpath imports: @solidrt/core/camera, /microphone, /gpu.
-    Images: createImage(src) from @solidrt/core (reactive load -> texture id);
-    raw decodeImage + createTexture (from /gpu) are the primitives underneath.
-11. tsconfig needs jsx:"preserve" + jsxImportSource:"@solidrt/core". Solid peer
-    deps are pinned betas - do not bump them casually.
-12. Use ASCII characters whenever possible in code and text - for example, no
+   model), rendering through a custom Rust runtime instead of the DOM. Build
+   UI from @solidrt/components (Window, View, Text, Image, TextInput,
+   ScrollView, Pressable, Button, SafeArea, theme/setTheme) - it is the
+   higher-level, batteries-included vocabulary and is where most app code
+   should live.
+2. Most components split their props into two objects: `layout={{...}}` for
+   anything that feeds the layout engine (flex/grid, sizing, padding/margin,
+   position; font fields for Text) and `style={{...}}` for paint-only
+   properties that never relayout (`backgroundColor`, `borderColor`,
+   `borderWidth`, `borderRadius`, `color`, and the transform `x`/`y`/
+   `rotate`/`scale`). Event handlers (`onPointerDown`, `onKeyDown`, ...) are
+   top-level props, not inside `layout`/`style`.
+3. `render(() => <App/>)` once, top level. The root MUST be a `<Window>`
+   (from @solidrt/components) or the core `<window>` - it throws otherwise.
+4. `Window`/`View` do not paint on their own; they only paint when you set
+   `style.backgroundColor`/`borderColor` etc - there is no separate
+   background element to place by hand.
+5. There is no onClick/onPress on host elements. Use `Pressable`/`Button`
+   from components (`onPress`), or `onPointerDown` on a `View` for anything
+   custom.
+6. Reactive window state: prefer the accessors windowSize(), safeArea(),
+   displayScale(), windowFocused(), keyboardHeight() (re-exported from
+   @solidrt/core) over onResize/onLayout callbacks for reading layout and
+   window state. SafeArea (the component) is usually the simpler fix for
+   avoiding notches/system UI.
+7. Per-frame animation: onFrame((tick, frame) => {}) is the native hook
+   (runtime-paced, auto-cleans), re-exported from @solidrt/core.
+   requestAnimationFrame(t => {}) exists as a web-standard one-shot but is
+   not the preferred animation driver.
+8. Reach for @solidrt/core directly only for what components doesn't wrap:
+   raw host intrinsics and the `d-` (detached, non-layout) primitives like
+   `d-rect`/`d-path`/`d-oval` for vector art or perf-sensitive positioned
+   drawing, device/GPU subpath imports (@solidrt/core/camera, /microphone,
+   /gpu), gradients (createLinearGradient/createRadialGradient), and
+   createImage/decodeImage for images below the `Image` component's level.
+   Components and core primitives compose freely in the same tree - a
+   components-based app can drop to a `<d-path>` for one custom shape without
+   giving up `View`/`Text` everywhere else.
+9. tsconfig needs jsx:"preserve" + jsxImportSource:"@solidrt/core" (still
+   true even when you build almost entirely with @solidrt/components -
+   components are plain functions returning core JSX). Solid peer deps are
+   pinned betas - do not bump them casually.
+10. Use ASCII characters whenever possible in code and text - for example, no
     em-dashes (use a hyphen), no smart/curly quotes, no unicode symbols.
-13. Mind the safe area. safeArea() from @solidrt/core is a reactive accessor
-    returning { top, left, right, bottom } insets (like CSS
-    env(safe-area-inset-*)). It is fine to place content outside the safe-area
-    zone (e.g. full-bleed backgrounds), just be aware it may not be visible and
-    cannot be interacted with (touch gestures). Keep interactive or essential
-    content inside the safe area by padding the edges.
-14. Prefer let over const. Use const only for real constants - a single fixed
+11. Prefer let over const. Use const only for real constants - a single fixed
     string or number value - and name those in ALL_CAPS.
 
 ## Run / verify
@@ -65,4 +75,4 @@ Authoritative references ship inside the installed packages - read them:
 - bunx srt bundle src/index.tsx  - exit 0 means it compiles
 - bunx srt record src/index.tsx --size 480x640 --duration 1 --fps 2 - headless
   render to PNG frames (proves it renders; see the cli AGENTS.md for where the
-  frames land)
+  frames land)

package/scaffold/package.json

@@ -4,14 +4,17 @@
   "private": true,
   "scripts": {
     "dev": "srt run src/index.tsx",
-    "bundle": "srt bundle src/index.tsx"
+    "server": "srt server",
+    "client": "srt client",
+    "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "latest"
+    "@solidrt/core": "0.0.19",
+    "@solidrt/components": "0.0.19"
   },
   "devDependencies": {
-    "@solidrt/cli": "latest",
-    "@solidrt/flux-types": "latest",
+    "@solidrt/cli": "0.0.0",
+    "@solidrt/flux-types": "0.0.0",
     "typescript": "^6"
   }
 }

package/scaffold/src/index.tsx

@@ -1,25 +1,66 @@
-import { render } from "@solidrt/core"
+import { render, For, onFrame, createSignal, createLinearGradient } from "@solidrt/core"
+import { View, Window } from "@solidrt/components"
+
+const FADE = 360 
+
+let SEGMENTS = [
+  { base: 0, light: "#3f5494", dark: "#162b6c", d: "M50.000 50.000 L28.330 50.000 C28.330 48.810 27.695 47.711 26.665 47.116 C25.635 46.521 24.365 46.521 23.335 47.116 C22.305 47.711 21.670 48.810 21.670 50.000 L0.000 50.000 L50.000 0.000 L50.000 9.170 C48.810 9.170 47.711 9.805 47.116 10.835 C46.521 11.865 46.521 13.135 47.116 14.165 C47.711 15.195 48.810 15.830 50.000 15.830 L50.000 25.000 L50.000 34.170 C48.810 34.170 47.711 34.805 47.116 35.835 C46.521 36.865 46.521 38.135 47.116 39.165 C47.711 40.195 48.810 40.830 50.000 40.830 L50.000 50.000 Z" },
+  { base: 90, light: "#547ebf", dark: "#2b5696", d: "M50.000 50.000 L50.000 59.170 C48.810 59.170 47.711 59.805 47.116 60.835 C46.521 61.865 46.521 63.135 47.116 64.165 C47.711 65.195 48.810 65.830 50.000 65.830 L50.000 75.000 L50.000 84.170 C48.810 84.170 47.711 84.805 47.116 85.835 C46.521 86.865 46.521 88.135 47.116 89.165 C47.711 90.195 48.810 90.830 50.000 90.830 L50.000 100.000 L0.000 50.000 L21.670 50.000 C21.670 48.810 22.305 47.711 23.335 47.116 C24.365 46.521 25.635 46.521 26.665 47.116 C27.695 47.711 28.330 48.810 28.330 50.000 L50.000 50.000 Z" },
+  { base: 180, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 25.000 L50.000 15.830 C48.810 15.830 47.711 15.195 47.116 14.165 C46.521 13.135 46.521 11.865 47.116 10.835 C47.711 9.805 48.810 9.170 50.000 9.170 L50.000 0.000 L75.000 25.000 L65.830 25.000 C65.830 26.190 65.195 27.289 64.165 27.884 C63.135 28.479 61.865 28.479 60.835 27.884 C59.805 27.289 59.170 26.190 59.170 25.000 L50.000 25.000 Z" },
+  { base: 270, light: "#547ebf", dark: "#2b5696", d: "M50.000 25.000 L59.170 25.000 C59.170 26.190 59.805 27.289 60.835 27.884 C61.865 28.479 63.135 28.479 64.165 27.884 C65.195 27.289 65.830 26.190 65.830 25.000 L75.000 25.000 L75.000 34.170 C73.810 34.170 72.711 34.805 72.116 35.835 C71.521 36.865 71.521 38.135 72.116 39.165 C72.711 40.195 73.810 40.830 75.000 40.830 L75.000 50.000 L65.830 50.000 C65.830 48.810 65.195 47.711 64.165 47.116 C63.135 46.521 61.865 46.521 60.835 47.116 C59.805 47.711 59.170 48.810 59.170 50.000 L50.000 50.000 L50.000 40.830 C48.810 40.830 47.711 40.195 47.116 39.165 C46.521 38.135 46.521 36.865 47.116 35.835 C47.711 34.805 48.810 34.170 50.000 34.170 L50.000 25.000 Z" },
+  { base: 360, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 50.000 L59.170 50.000 C59.170 48.810 59.805 47.711 60.835 47.116 C61.865 46.521 63.135 46.521 64.165 47.116 C65.195 47.711 65.830 48.810 65.830 50.000 L75.000 50.000 L64.855 60.145 C64.013 59.304 62.787 58.976 61.638 59.283 C60.489 59.591 59.591 60.489 59.283 61.638 C58.976 62.787 59.304 64.013 60.145 64.855 L50.000 75.000 L50.000 65.830 C48.810 65.830 47.711 65.195 47.116 64.165 C46.521 63.135 46.521 61.865 47.116 60.835 C47.711 59.805 48.810 59.170 50.000 59.170 L50.000 50.000 Z" },
+  { base: 450, light: "#3f5494", dark: "#162b6c", d: "M75.000 50.000 L75.000 59.170 C73.810 59.170 72.711 59.805 72.116 60.835 C71.521 61.865 71.521 63.135 72.116 64.165 C72.711 65.195 73.810 65.830 75.000 65.830 L75.000 75.000 L50.000 100.000 L50.000 90.830 C48.810 90.830 47.711 90.195 47.116 89.165 C46.521 88.135 46.521 86.865 47.116 85.835 C47.711 84.805 48.810 84.170 50.000 84.170 L50.000 75.000 L60.145 64.855 C59.304 64.013 58.976 62.787 59.283 61.638 C59.591 60.489 60.489 59.591 61.638 59.283 C62.787 58.976 64.013 59.304 64.855 60.145 L75.000 50.000 Z" },
+  { base: 540, light: "#7ea9ea", dark: "#5681c1", d: "M100.000 50.000 L75.000 75.000 L75.000 65.830 C73.810 65.830 72.711 65.195 72.116 64.165 C71.521 63.135 71.521 61.865 72.116 60.835 C72.711 59.805 73.810 59.170 75.000 59.170 L75.000 50.000 L75.000 40.830 C73.810 40.830 72.711 40.195 72.116 39.165 C71.521 38.135 71.521 36.865 72.116 35.835 C72.711 34.805 73.810 34.170 75.000 34.170 L75.000 25.000 L100.000 50.000 Z" },
+]
+
+let LAST = SEGMENTS[SEGMENTS.length - 1].base
+let IN_DONE = LAST + FADE
+let CYCLE = IN_DONE + LAST + FADE
+
+let clamp = (x: number) => (x < 0 ? 0 : x > 1 ? 1 : x)
+let ease = (t: number) => 1 - (1 - t) * (1 - t)
+let byte = (x: number) => Math.round(Math.max(0, Math.min(255, x))).toString(16).padStart(2, "0")
+
+let fill = (seg: (typeof SEGMENTS)[number], a: number) =>
+  createLinearGradient(0, 0, 1, 1, [
+    { offset: 0, color: seg.light + byte(a * 255) },
+    { offset: 1, color: seg.dark + byte(a * 255) },
+  ])
 
 function Icon() {
+  let [clock, setClock] = createSignal(0)
+  let start = -1
+  onFrame((t) => (start < 0 && (start = t), setClock((t - start) % CYCLE)))
   return (
-    <view width={100} height={100} scale={3}>
-      <d-path d="M50 50L0 50L50 0Z" color="#1a3380" />
-      <d-path d="M50 50L50 100L0 50Z" color="#3366b3" />
-      <d-path d="M50 25L50 0L75 25Z" color="#6699e6" />
-      <d-path d="M50 25L75 25L75 50L50 50Z" color="#3366b3" />
-      <d-path d="M50 50L75 50L50 75Z" color="#6699e6" />
-      <d-path d="M75 50L75 75L50 100L50 75Z" color="#1a3380" />
-      <d-path d="M100 50L75 75L75 25Z" color="#6699e6" />
-    </view>
+    <View layout={{ width: 100, height: 100 }} style={{ scale: 3 }}>
+      <For each={SEGMENTS}>
+        {(seg) => {
+          let a = () => {
+            let t = clock(), end = IN_DONE + seg.base + FADE
+            if (t < seg.base || t >= end) return 0
+            return ease(Math.min(clamp((t - seg.base) / FADE), clamp((end - t) / FADE)))
+          }
+          return <d-path d={seg.d} color={fill(seg, a())} />
+        }}
+      </For>
+    </View>
   )
 }
 
 function App() {
+  let backgroundColor = createLinearGradient(0, 0, 1, 1, [
+    { offset: 0, color: "#080b16" },
+    { offset: 1, color: "#1d2a52" },
+  ])
+
   return (
-    <window alignItems="center" justifyContent="center">
+    <Window
+      layout={{ alignItems: "center", justifyContent: "center" }}
+      style={{ backgroundColor }}
+    >
       <Icon />
-    </window>
+    </Window>
   )
 }
 
-render(() => <App />)
+render(() => <App />)

package/scaffold/tsconfig.json

@@ -1,5 +1,7 @@
 {
   "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["ESNext"],
     "jsx": "preserve",
     "jsxImportSource": "@solidrt/core",
     "moduleResolution": "bundler",

package/src/bundler.ts

@@ -2,10 +2,65 @@ import { transformAsync } from "@babel/core"
 import jsx from "@babel/plugin-syntax-jsx"
 import ts from "@babel/preset-typescript"
 import solid from "babel-preset-solid"
-import { type BunPlugin } from "bun"
+import { type BunPlugin, type BuildArtifact } from "bun"
+import { readFileSync } from "node:fs"
+import { dirname, resolve as resolvePath } from "node:path"
 import { values, source } from "./args"
 import { state, print, requireBinary } from "./util"
 
+// Babel plugin: rewrite `import data from "./x" with { type: "binary" }` into an
+// inline Uint8Array of the file's bytes. The import attribute is invisible to
+// Bun's bundler and its plugins in this Bun version, so we handle it here in the
+// transform where the AST still carries it. Inlining (rather than emitting a
+// separate asset) keeps a single bundle output and hands JS a Uint8Array, which
+// is what createImage and friends expect. Decoded at runtime via the global
+// atob; for ASCII-extension files (.jpg/.png/...) we may add an attribute-free
+// path later.
+function binaryImport({ types: t }: { types: any }) {
+  return {
+    visitor: {
+      ImportDeclaration(path: any, pluginState: any) {
+        let attrs = path.node.attributes ?? path.node.assertions
+        let isBinary = attrs?.some((a: any) => a.key.name === "type" && a.value.value === "binary")
+        if (!isBinary) return
+
+        let def = path.node.specifiers.find((s: any) => s.type === "ImportDefaultSpecifier")
+        if (!def) {
+          throw path.buildCodeFrameError(
+            'A binary import needs a default import: import data from "./file" with { type: "binary" }',
+          )
+        }
+
+        let importer = pluginState.file.opts.filename as string
+        let abs = resolvePath(dirname(importer), path.node.source.value)
+        let b64 = readFileSync(abs).toString("base64")
+
+        // var <local> = Uint8Array.from(atob("<b64>"), c => c.charCodeAt(0))
+        let expr = t.callExpression(t.memberExpression(t.identifier("Uint8Array"), t.identifier("from")), [
+          t.callExpression(t.identifier("atob"), [t.stringLiteral(b64)]),
+          t.arrowFunctionExpression(
+            [t.identifier("c")],
+            t.callExpression(t.memberExpression(t.identifier("c"), t.identifier("charCodeAt")), [t.numericLiteral(0)]),
+          ),
+        ])
+        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
+// build, skipping emitted asset outputs. Bun's file loader emits binary assets
+// as extra outputs; the callers that flatten outputs into a single code string
+// must not glue those raw bytes onto the program.
+export async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
+  let code = ""
+  for (let o of outputs) {
+    if (o.kind === "entry-point" || o.kind === "chunk") code += await o.text()
+  }
+  return code
+}
+
 // Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
 // generate, targeting @solidrt/core) plus the TS preset.
 function solidPlugin(): BunPlugin {
@@ -18,7 +73,7 @@ function solidPlugin(): BunPlugin {
         let transforms = await transformAsync(code, {
           filename: args.path,
           presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
-          plugins: [jsx],
+          plugins: [jsx, binaryImport],
         })
         return { contents: transforms?.code ?? "", loader: "js" }
       })
@@ -31,7 +86,8 @@ export async function bundle(entry = source) {
 
   let devBase = state.serverUrl ?? undefined
   let dev = !!devBase || values.dev
-  print(`[cli] Bundling (${dev ? "development" : "production"})`)
+  // Keep stdout clean when the bundle itself is written to stdout.
+  if (!values.stdout) print(`[cli] Bundling (${dev ? "development" : "production"})`)
   let define: Record<string, string> = {
     "process.env.NODE_ENV": dev ? "development" : "production",
   }
@@ -45,6 +101,7 @@ export async function bundle(entry = source) {
       minify: values.minify,
       external: ["flux:*", "srt:*"],
       define,
+      loader: { ".svg": "text" },
       plugins: [solidPlugin()],
     })
   } catch (e) {
@@ -68,9 +125,7 @@ export async function bundleTo(outfile: string) {
     console.error("Build failed")
     process.exit(1)
   }
-  for (let output of result.outputs) {
-    await Bun.write(outfile, output)
-  }
+  await Bun.write(outfile, await codeFromOutputs(result.outputs))
   return result
 }
 
@@ -88,9 +143,7 @@ export async function bundleFlux(entry: string): Promise<string> {
     console.error("Build failed")
     process.exit(1)
   }
-  let jsCode = ""
-  for (let output of result.outputs) jsCode += await output.text()
-  return jsCode
+  return codeFromOutputs(result.outputs)
 }
 
 // Bundle for the SolidRT runtime via the standard Solid-aware bundler.
@@ -100,9 +153,7 @@ export async function bundleSolid(): Promise<string> {
     console.error("Build failed")
     process.exit(1)
   }
-  let jsCode = ""
-  for (let output of result.outputs) jsCode += await output.text()
-  return jsCode
+  return codeFromOutputs(result.outputs)
 }
 
 // Compile JS source to QuickJS bytecode via the fluxc binary.

package/src/commands/bundle.ts

@@ -1,5 +1,5 @@
 import { values, source, isPrebuilt } from "../args"
-import { bundle, bundleTo, bundleFlux, compileToBytecode } from "../bundler"
+import { bundle, bundleTo, bundleFlux, compileToBytecode, codeFromOutputs } from "../bundler"
 import { resolve } from "path"
 
 // Write to stdout and resolve only once the whole payload is flushed.
@@ -55,9 +55,7 @@ export async function runBundleCommand() {
       console.error("Build failed")
       process.exit(1)
     }
-    for (let output of result.outputs) {
-      await writeStdout(await output.text())
-    }
+    await writeStdout(await codeFromOutputs(result.outputs))
     process.exit()
   }
 
@@ -67,10 +65,7 @@ export async function runBundleCommand() {
       console.error("Build failed")
       process.exit(1)
     }
-    let jsCode = ""
-    for (let output of result.outputs) {
-      jsCode += await output.text()
-    }
+    let jsCode = await codeFromOutputs(result.outputs)
     await writeBytecode(jsCode, baseName + ".srt.bin")
     process.exit()
   }

package/src/commands/init.ts

@@ -33,12 +33,12 @@ export async function runInitCommand() {
     process.exit(1)
   }
 
-  console.log(`>> scaffolding SolidRT project in ${resolve(dir)}`)
+  console.log(`>> Scaffolding SolidRT project in ${resolve(dir)}`)
   for (let { from, to } of TEMPLATE_FILES) {
     let dest = join(dir, to)
     await mkdir(dirname(dest), { recursive: true })
     await writeFile(dest, await readFile(join(SCAFFOLD_DIR, from)))
-    console.log(`   write ${to}`)
+    console.log(`   Write ${to}`)
   }
 
   // The scaffold package.json carries a placeholder name; set it from the
@@ -50,18 +50,18 @@ export async function runInitCommand() {
 
   // Deps are declared in scaffold/package.json (Solid peers resolve via
   // @solidrt/core's peerDependencies), so a plain install is enough.
-  console.log("\n>> installing dependencies")
+  console.log("\n>> Installing dependencies")
   let install = Bun.spawnSync(["bun", "install"], {
     cwd: dir,
     stdout: "inherit",
     stderr: "inherit",
   })
   if (install.exitCode !== 0) {
-    console.error("\n!! dependency install failed; retry with `bun install` in the project")
+    console.error("\n!! Dependency install failed; retry with `bun install` in the project")
     process.exit(1)
   }
 
   let prefix = dir === "." ? "" : `cd ${dir} && `
-  console.log(`\n>> done. next:\n   ${prefix}bunx srt run src/index.tsx\n`)
+  console.log(`\n>> Done. Next:\n   ${prefix}bun run dev\n`)
   process.exit()
 }

package/src/commands/server.ts

@@ -1,8 +1,8 @@
 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 { bundle, codeFromOutputs } from "../bundler"
+import { startServer, showBuildFailure } from "../dev-server"
 import { startRepl } from "../repl"
 import { startWatcher } from "../watcher"
 import * as cache from "../cache"
@@ -28,9 +28,9 @@ export async function runServerCommand() {
   if (source && isSource) {
     let initialResult = await bundle()
     if (initialResult) {
-      for (let output of initialResult.outputs) {
-        state.currentCode = await output.text()
-      }
+      state.currentCode = await codeFromOutputs(initialResult.outputs)
+    } else {
+      showBuildFailure()
     }
   } else if (source && isPrebuilt && source.endsWith(".srt.js")) {
     state.currentCode = await Bun.file(resolve(source)).text()

package/src/dev-android.ts

@@ -65,11 +65,43 @@ function listDevices(adb: string): string[] {
     .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 {
+// 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 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)
+    print(`${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 (missingPkgs.length > 0) print(`Add dev dependencies with: bun add -d ${missingPkgs.join(" ")}`)
+  return abiByDevice
+}
+
+// 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
@@ -80,14 +112,14 @@ function resolveTarget(adb: string): string {
     }
     let [match] = matches
     if (!match) {
-      console.error(`No connected device matches --device "${prefix}". Connected: ${devices.join(", ") || "none"}`)
+      console.error(`No connected device matches --device "${prefix}".`)
       process.exit(1)
     }
-    return match
+    return { target: match, abi: abiByDevice.get(match)! }
   }
 
   if (devices.length > 1) {
-    console.error(`Multiple devices connected (${devices.join(", ")}); pick one with --device <serial or prefix>.`)
+    console.error("Pick one with --device <serial or prefix>.")
     process.exit(1)
   }
   let [only] = devices
@@ -95,18 +127,7 @@ function resolveTarget(adb: string): string {
     console.error("No authorized Android device found. Enable USB debugging and check `adb devices`.")
     process.exit(1)
   }
-  return only
-}
-
-// 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()
+  return { target: only, abi: abiByDevice.get(only)! }
 }
 
 // Install + launch the Android client on a connected device over adb, passing it
@@ -116,16 +137,13 @@ function deviceAbi(adb: string, target: string): string {
 export async function spawnAndroidClient() {
   let adb = requireAdb()
 
-  let target = resolveTarget(adb)
-  let abi = deviceAbi(adb, target)
+  let { target, abi } = resolveTarget(adb)
 
   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}`)
-    let target = abi === "armeabi-v7a" ? "make dist-android-armeabi-v7a" : "make dist-android"
-    console.error(`Or build one locally (from lattice/): ${target}`)
     process.exit(1)
   }
 

package/src/dev-client.ts

@@ -17,11 +17,11 @@ function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteSt
 
 export function spawnClient() {
   let runner = requireBinary("solidrt-go")
-  let args: string[] = []
+  // The local client and dev server share this machine, so connect straight to
+  // the loopback server: no mDNS discovery or recents lookup is needed for `run`.
+  let args: string[] = ["--dev-server", `${DEV_HOST}:${DEV_PORT}`]
   if (values.size) args.push("--size", values.size)
   state.child = Bun.spawn([runner, ...args], {
-  //TODO implement dev server connection
-  // state.child = Bun.spawn([runner, "--dev-server", `${DEV_HOST}:${DEV_PORT}`], {
     stdio: ["ignore", "pipe", "pipe"],
   })
 

package/src/dev-server.ts

@@ -22,6 +22,23 @@ export function broadcast(msg: object) {
   }
 }
 
+// Reload code that fails to start the engine on purpose. The runtime treats a
+// startup error like any app that never called render() and falls back to its
+// baked-in BSOD screen, so a build that doesn't compile shows the BSOD instead
+// of leaving the previous app frozen on screen.
+const BSOD_TRIGGER = `throw new Error("SolidRT: build failed")`
+
+// Called when a bundle fails to compile. Latches the BSOD trigger as the
+// current code (so a client connecting after the failure gets it too) and
+// pushes it to every connected client.
+export function showBuildFailure() {
+  state.currentCode = BSOD_TRIGGER
+  let msg = buildReload({ code: BSOD_TRIGGER })
+  for (let ws of state.clients.keys()) {
+    ws.send(msg)
+  }
+}
+
 function headersToObject(h: Headers): Record<string, string> {
   let out: Record<string, string> = {}
   h.forEach((v, k) => {
@@ -51,6 +68,7 @@ async function handleProxy(req: Request): Promise<Response> {
       print("[cli] proxy %s %s [cache hit]", req.method, target)
       let respHeaders = new Headers(hit.headers)
       respHeaders.set("x-srt-cache", "hit")
+      // await new Promise(resolve => setTimeout(resolve, 1000))
       return new Response(hit.body, { status: hit.status, headers: respHeaders })
     }
   }

package/src/repl.ts

@@ -2,8 +2,8 @@ import { createInterface } from "node:readline"
 import { resolve, dirname } from "path"
 import { readdirSync } from "node:fs"
 import { state, print, printErr, shutdown } from "./util"
-import { buildReload, broadcast } from "./dev-server"
-import { bundle } from "./bundler"
+import { buildReload, broadcast, showBuildFailure } from "./dev-server"
+import { bundle, codeFromOutputs } from "./bundler"
 import { startWatcher, stopWatcher } from "./watcher"
 
 function cmdStop(args: string) {
@@ -32,11 +32,10 @@ async function cmdReload(args: string) {
     let result = await bundle(state.source)
     if (!result) {
       printErr("[cli] Build failed, reload aborted")
+      showBuildFailure()
       return
     }
-    for (let output of result.outputs) {
-      state.currentCode = await output.text()
-    }
+    state.currentCode = await codeFromOutputs(result.outputs)
   }
   let msg = buildReload({ code: state.currentCode })
   if (!args) {
@@ -95,9 +94,7 @@ async function cmdLoad(file: string) {
       printErr("[cli] Build failed")
       return
     }
-    for (let output of result.outputs) {
-      state.currentCode = await output.text()
-    }
+    state.currentCode = await codeFromOutputs(result.outputs)
   } else if (file.endsWith(".srt.js")) {
     state.currentCode = await Bun.file(path).text()
   } else if (file.endsWith(".srt.bin")) {

package/src/watcher.ts

@@ -1,8 +1,8 @@
 import { watch } from "node:fs"
 import { resolve, dirname } from "path"
 import { state, print, printErr } from "./util"
-import { buildReload } from "./dev-server"
-import { bundle } from "./bundler"
+import { buildReload, showBuildFailure } from "./dev-server"
+import { bundle, codeFromOutputs } from "./bundler"
 
 let currentWatcher: ReturnType<typeof watch> | null = null
 
@@ -28,11 +28,10 @@ export function startWatcher() {
     let result = await bundle(state.source)
     if (!result) {
       printErr("[cli] Build failed, waiting for changes...")
+      showBuildFailure()
       return
     }
-    for (let output of result.outputs) {
-      state.currentCode = await output.text()
-    }
+    state.currentCode = await codeFromOutputs(result.outputs)
     let msg = buildReload({ code: state.currentCode })
     for (let ws of state.clients.keys()) {
       ws.send(msg)