@solidrt/cli 0.0.17 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "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.18",
+    "@solidrt/linux-x64-gnu": "0.0.18",
+    "@solidrt/win32-x64-msvc": "0.0.18"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.17",
+    "@solidrt/core": "0.0.18",
     "typescript": "^6"
   },
   "devDependencies": {

package/scaffold/package.json

@@ -7,11 +7,11 @@
     "bundle": "srt bundle src/index.tsx"
   },
   "dependencies": {
-    "@solidrt/core": "latest"
+    "@solidrt/core": "0.0.18"
   },
   "devDependencies": {
-    "@solidrt/cli": "latest",
-    "@solidrt/flux-types": "latest",
+    "@solidrt/cli": "0.0.0",
+    "@solidrt/flux-types": "0.0.0",
     "typescript": "^6"
   }
 }

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/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-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)