@solidrt/cli 0.0.44 → 0.0.46

package/AGENTS.md

@@ -34,7 +34,8 @@ Two reliable checks that need no GUI:
 2. `bunx srt render src/index.tsx --size 480x640 --duration 1 --fps 2` -
    renders offscreen via EGL and writes `frame-NNNNNN.png`. This actually
    proves the app renders. Combine with `--fps`/`--duration` (defaults
-   1280x720, 60fps, 1s).
+   1280x720, 60fps, 1s). No display needed: rendering uses SDL's offscreen
+   driver (falling back to a hidden window where EGL cannot go headless).
 
 Also headless: the bundled flux runtime runs a plain `.js` file directly -
 `node_modules/@solidrt/<platform>/flux script.js` (e.g.
@@ -43,9 +44,10 @@ access. The right tool for micro-benchmarks and for probing flux module
 behavior in isolation.
 
 `render` gotchas:
-- Frames are written to the RUNTIME's working dir (`~/.local/share/SolidRT/go/`),
-  NOT the directory you ran the command from. Look there for the PNGs.
-- The recording includes a debug overlay (FPS/REQ/MiB/CPU) in a corner.
+- Frames land in the directory you ran the command from; `-o <path>` picks a
+  different directory (or a path prefix for the `-NNNNNN.png` names).
+- `--size` is physical output pixels: layout runs at exactly that size
+  (display scale is pinned to 1), so frames are identical on every machine.
 - Run from the project directory. There is no `bunx --cwd` flag.
 
 ## Dev server proxies (when clients on other devices need your machine's data)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -22,22 +22,22 @@
     "@jridgewell/remapping": "^2.3.0",
     "@jridgewell/trace-mapping": "^0.3.25",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "babel-preset-solid": "2.0.0-beta.26",
+    "babel-preset-solid": "2.0.0-beta.31",
     "bonjour-service": "^1.4.0",
     "qrcode-generator": "^2.0.4",
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.44",
-    "@solidrt/linux-arm64-gnu": "0.0.44",
-    "@solidrt/linux-x64-gnu": "0.0.44",
-    "@solidrt/win32-x64-msvc": "0.0.44"
+    "@solidrt/darwin-arm64": "0.0.46",
+    "@solidrt/linux-arm64-gnu": "0.0.46",
+    "@solidrt/linux-x64-gnu": "0.0.46",
+    "@solidrt/win32-x64-msvc": "0.0.46"
   },
   "peerDependencies": {
     "typescript": "^7"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.44",
+    "@solidrt/flux-types": "0.0.46",
     "@types/babel__core": "^7.20.5",
     "@types/bun": "latest"
   }

package/scaffold/AGENTS.md

@@ -279,6 +279,10 @@ up to the frame period, because work outside the frame call is not in them.
 
 ## Run / verify
 
+- FIRST check whether a dev server and a client are already running (MCP
+  list_clients, see below) and build/test against those: `reload` pushes your
+  edits to the live app, get_logs and get_snapshot verify them. Do not start a
+  second `srt run` when one is already up.
 - bunx srt run src/index.tsx     - dev server + window (needs a display)
 - bunx srt check src/index.tsx   - exit 0 means it compiles and the app's
   types hold (dependency-internal type errors are hidden). Builds in memory:

package/scaffold/package.json

@@ -10,12 +10,12 @@
     "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.44",
-    "@solidrt/components": "0.0.44"
+    "@solidrt/core": "0.0.46",
+    "@solidrt/components": "0.0.46"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.44",
-    "@solidrt/flux-types": "0.0.44",
+    "@solidrt/cli": "0.0.46",
+    "@solidrt/flux-types": "0.0.46",
     "typescript": "^7"
   }
 }

package/scaffold/tsconfig.json

@@ -5,6 +5,8 @@
     "jsx": "preserve",
     "jsxImportSource": "@solidrt/core",
     "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
     "strict": true,
     "skipLibCheck": true,
     "types": ["@solidrt/flux-types"]

package/server/main.ts

@@ -16,8 +16,7 @@ import { appendLog, clientList, handleControl, resolveQuery } from "./control"
 import { printQr } from "./qr"
 import { createTunnelEndpoint, TUNNEL_PROTOCOL } from "./tunnel"
 
-// argv layout differs between hosts; the config JSON is always the last argument.
-let config: Config = JSON.parse(argv[argv.length - 1]!)
+let config: Config = JSON.parse(argv[0]!)
 state.config = config
 state.sourceDir = config.sourceDir
 state.projectDir = config.projectDir

package/server/rebuild.ts

@@ -16,6 +16,7 @@ function buildReload(code: string, manifest?: string) {
   return {
     type: "reload",
     proxyHttp: config.proxyHttp,
+    args: config.args,
     ...(manifest ? { manifest } : {}),
     code,
   }

package/server/state.ts

@@ -17,6 +17,9 @@ export type Config = {
    * MCP-triggered reload, or undefined when srt was started without a source.
    * Moved by the repl `load` command via /__internal__/reload. */
   entry?: string
+  /** The session's app arguments (the srt command-line tail after a bare
+   * "--"), included in every reload push as flux:process argv. */
+  args: string[]
   /** Minify the rebuild output, mirroring the srt --minify flag. */
   minify: boolean
   /** How the server invokes the external bundler: [bunPath, bundleCliPath],

package/src/args.ts

@@ -1,7 +1,16 @@
 import { parseArgs } from "node:util"
 import { resolve } from "node:path"
 
+// Everything after a bare "--" is the app's argument vector, kept out of
+// parseArgs (which would fold it into positionals) and forwarded verbatim to
+// the runner, where it becomes flux:process argv. srt's own flags may follow
+// the source file, so the separator is required.
+let rawArgs = process.argv.slice(2)
+let appArgsSep = rawArgs.indexOf("--")
+export let appArgs = appArgsSep === -1 ? [] : rawArgs.slice(appArgsSep + 1)
+
 export let { values, positionals } = parseArgs({
+  args: appArgsSep === -1 ? rawArgs : rawArgs.slice(0, appArgsSep),
   options: {
     dev: { type: "boolean", short: "d", default: false },
     minify: { type: "boolean", short: "m", default: false },
@@ -126,6 +135,7 @@ run/server options:
       --proxy-http       Route fetch calls through the dev server (HTTP cache enabled)
       --capture <file>   Record connected clients' key events to a script file
       --tunnel           Accept ticket-paired clients through the p2p tunnel
+      -- <args...>       Everything after -- reaches the app on every client (flux:process argv)
 
 run/client options:
       --size <WxH>       Window size (default: 1280x720)
@@ -160,5 +170,8 @@ render options:
       --script <file>    Script file to replay (default: no scripted input)
       --fps <N>          Frames per second (default: 60)
       --duration <N>     Duration in seconds (default: 1)
-      --size <WxH>       Frame size (default: 1280x720)`)
+      --size <WxH>       Frame size in physical pixels (default: 1280x720)
+  -o, --output <path>    Where frames land: a directory (frame-NNNNNN.png inside it)
+                         or a path prefix (default: the current directory)
+      -- <args...>       Everything after -- is passed to the app (flux:process argv)`)
 }

package/src/commands/render.ts

@@ -1,4 +1,4 @@
-import { source, values } from "../args"
+import { appArgs, source, values } from "../args"
 import { requireBinary, run } from "../util"
 import { bundleTo } from "../bundler"
 import { resolve } from "path"
@@ -12,7 +12,13 @@ export async function runRenderCommand() {
   if (values.duration) playbackArgs.push("--duration", values.duration)
   if (values.size) playbackArgs.push("--size", values.size)
   if (values.script) playbackArgs.push("--script", resolve(values.script))
+  // Always absolute: the runtime chdirs into the app's data sandbox before
+  // frames are written, so a bare prefix would land the PNGs there.
+  playbackArgs.push("--out", resolve(values.output ?? "."))
   playbackArgs.push(resolve(jsOutfile))
+  // The runner takes everything after the source path verbatim as the app's
+  // argument vector (flux:process argv).
+  playbackArgs.push(...appArgs)
   let exit = await run(runner, playbackArgs)
   process.exit(exit)
 }

package/src/dev-server.ts

@@ -2,7 +2,7 @@ import { resolve } from "path"
 import { tmpdir, networkInterfaces } from "node:os"
 import { fileURLToPath } from "node:url"
 import { state, print, printErr, requireBinary, pipeAbovePrompt, shutdown } from "./util"
-import { values } from "./args"
+import { appArgs, values } from "./args"
 
 export const DEV_HOST = "127.0.0.1"
 export const DEFAULT_DEV_PORT = 0x8844
@@ -41,6 +41,9 @@ export function buildReload(payload: { code?: string | null; bytecode?: string;
   return {
     type: "reload",
     proxyHttp: values["proxy-http"],
+    // The session's app arguments ride every push (flux:process argv), so
+    // remote clients see the same vector as the local one.
+    args: appArgs,
     ...(manifest ? { manifest } : {}),
     ...rest,
   }
@@ -213,6 +216,7 @@ export async function startServer() {
     address,
     proxyHttp: values["proxy-http"],
     entry: state.source,
+    args: appArgs,
     minify: values.minify,
     bundlerCmd: [process.execPath, bundleCli],
     cache: values["proxy-http"],