@solidrt/cli 0.0.37 → 0.0.39

package/package.json

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

package/scaffold/AGENTS.md

@@ -117,6 +117,12 @@ Authoritative references ship inside the installed packages - read them:
     mounted. To inspect children (a typeof probe, counting), resolve them
     first with the children() helper (re-exported from @solidrt/core) and
     probe the resolved memo - never `typeof props.children` on the raw prop.
+18. Cover/contain images: give `Image` a `fit` prop ("fill" | "cover" |
+    "contain" | "none" | "scale-down", CSS object-fit semantics, centered)
+    plus a box via `layout` in any form - numbers, pct(), flex. Without
+    `fit`, only NUMERIC layout sizes reach the image; `width: pct(100)`
+    alone draws at intrinsic size. `fit="cover"` is the answer for the
+    ported-web hero-image/thumbnail pattern.
 
 ## Performance model (JS is the slow lane)
 

package/scaffold/icon.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#5b7cfa"/>
+      <stop offset="1" stop-color="#8a5cf6"/>
+    </linearGradient>
+  </defs>
+  <rect width="96" height="96" rx="22" fill="url(#bg)"/>
+  <circle cx="48" cy="48" r="21" fill="none" stroke="#ffffff" stroke-opacity="0.9" stroke-width="6"/>
+  <circle cx="48" cy="48" r="7" fill="#ffffff"/>
+</svg>

package/scaffold/package.json

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

package/server/tsconfig.json

@@ -4,6 +4,7 @@
     "lib": ["ESNext"],
     "moduleResolution": "bundler",
     "strict": true,
+    "skipLibCheck": true,
     "noUncheckedIndexedAccess": true,
     "types": ["@solidrt/flux-types"]
   },

package/src/bundler.ts

@@ -108,7 +108,12 @@ export type BundleResult = {
 export async function bundleWith(opts: BundleOptions): Promise<BundleResult | null> {
   // Define values are parsed as expressions, so string values need embedded
   // quotes - a bare word substitutes as an identifier and crashes at runtime.
+  // import.meta.env.DEV is the solidrt build-mode constant (used by core's
+  // leak sentinel; typed in core's types.d.ts). NODE_ENV stays defined as
+  // ecosystem compat only: third-party libraries bundled into apps commonly
+  // read it, and an unresolved `process` crashes at import time.
   let define: Record<string, string> = {
+    "import.meta.env.DEV": opts.dev ? "true" : "false",
     "process.env.NODE_ENV": opts.dev ? '"development"' : '"production"',
   }
   if (opts.devBase) define.__SRT_DEV_BASE__ = opts.devBase

package/src/commands/check.ts

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs"
+import { existsSync, mkdirSync, rmSync } from "node:fs"
 import { dirname, join, resolve } from "node:path"
 import { source } from "../args"
 import { bundleWith } from "../bundler"
@@ -12,7 +12,7 @@ import { bundleWith } from "../bundler"
 
 // Walk up from the entry to the enclosing project (tsconfig.json or, failing
 // that, package.json).
-function findProjectRoot(entry: string): string | null {
+export function findProjectRoot(entry: string): string | null {
   let dir = dirname(resolve(entry))
   let byConfig: string | null = null
   let byPackage: string | null = null
@@ -45,18 +45,77 @@ function parseDiagnostics(output: string): Diagnostic[] {
   return diagnostics
 }
 
-async function typecheck(root: string): Promise<{ app: Diagnostic[]; hidden: number } | null> {
-  let tsc = join(root, "node_modules", ".bin", process.platform === "win32" ? "tsc.exe" : "tsc")
-  if (!existsSync(tsc)) {
+// The project's tsc, found by walking up from the project root: an example
+// app can carry a tsconfig without its own node_modules (monorepo case).
+function findTsc(fromDir: string): string | null {
+  let dir = fromDir
+  while (true) {
+    let tsc = join(dir, "node_modules", ".bin", process.platform === "win32" ? "tsc.exe" : "tsc")
+    if (existsSync(tsc)) return tsc
+    let parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+// Typecheck the entry's program, not the enclosing project: a transient
+// config extends the project's tsconfig and roots the program at the entry
+// alone, so tsc checks exactly the entry's import closure - unrelated files
+// are excluded by construction. The config lives in the project-local
+// .srt-data (the dev-artifact dir; absolute paths inside, so its location
+// only matters for type-package resolution, which walks up to the project's
+// node_modules from there).
+export async function typecheck(root: string, entry: string): Promise<{ app: Diagnostic[]; hidden: number } | null> {
+  let tsconfig = join(root, "tsconfig.json")
+  if (!existsSync(tsconfig)) {
+    console.warn("Typecheck skipped: no tsconfig.json above the entry")
+    return null
+  }
+  let tsc = findTsc(root)
+  if (!tsc) {
     console.warn("Typecheck skipped: no tsc in the project (add the typescript devDependency)")
     return null
   }
-  let proc = Bun.spawn([tsc, "--noEmit", "--pretty", "false"], { cwd: root, stdout: "pipe", stderr: "pipe" })
-  let [out, err] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()])
-  await proc.exited
-  let diagnostics = parseDiagnostics(out + err)
-  let app = diagnostics.filter((d) => !d.inDependencies)
-  return { app, hidden: diagnostics.length - app.length }
+  let dataDir = join(root, ".srt-data")
+  mkdirSync(dataDir, { recursive: true })
+  let config = join(dataDir, `typecheck-${process.pid}.tsconfig.json`)
+  // include: [] overrides any include inherited from the extended config -
+  // files and include are unioned, so without this a base config's include
+  // would drag the whole project back into the program.
+  await Bun.write(config, JSON.stringify({ extends: tsconfig, include: [], files: [resolve(entry)] }))
+  try {
+    let proc = Bun.spawn([tsc, "-p", config, "--noEmit", "--pretty", "false"], {
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+    let [out, err] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()])
+    await proc.exited
+    let diagnostics = parseDiagnostics(out + err)
+    let app = diagnostics.filter((d) => !d.inDependencies)
+    return { app, hidden: diagnostics.length - app.length }
+  } finally {
+    rmSync(config, { force: true })
+  }
+}
+
+// Print a typecheck result (diagnostics, then the one-line verdict) and return
+// whether app-code errors were found. Callers pass repl-aware printers when
+// the output lands over a live prompt (the dev-server startup check).
+export function reportTypes(
+  types: { app: Diagnostic[]; hidden: number },
+  log: (...args: any[]) => void = console.log,
+  error: (...args: any[]) => void = console.error,
+): boolean {
+  for (let d of types.app) error(d.lines.join("\n"))
+  if (types.app.length > 0) {
+    let hidden = types.hidden > 0 ? ` (${types.hidden} in dependencies hidden)` : ""
+    error(`${types.app.length} type error${types.app.length === 1 ? "" : "s"} in app code${hidden}`)
+    return true
+  }
+  if (types.hidden > 0) log(`Types OK (${types.hidden} dependency-internal errors hidden)`)
+  else log("Types OK")
+  return false
 }
 
 export async function runCheckCommand() {
@@ -73,19 +132,8 @@ export async function runCheckCommand() {
   if (!root) {
     console.warn("Typecheck skipped: no tsconfig.json or package.json above the entry")
   } else {
-    let types = await typecheck(root)
-    if (types) {
-      for (let d of types.app) console.error(d.lines.join("\n"))
-      if (types.app.length > 0) {
-        failed = true
-        let hidden = types.hidden > 0 ? ` (${types.hidden} in dependencies hidden)` : ""
-        console.error(`${types.app.length} type error${types.app.length === 1 ? "" : "s"} in app code${hidden}`)
-      } else if (types.hidden > 0) {
-        console.log(`Types OK (${types.hidden} dependency-internal errors hidden)`)
-      } else {
-        console.log("Types OK")
-      }
-    }
+    let types = await typecheck(root, entry)
+    if (types && reportTypes(types)) failed = true
   }
 
   if (failed) process.exit(1)

package/src/commands/init.ts

@@ -141,9 +141,11 @@ export async function runInitCommand() {
 
   // The assets/ convention folder, created up front: everything in it ships
   // with the app, and the dev watcher only picks up an assets/ folder that
-  // exists when it starts.
+  // exists when it starts. It starts with a placeholder app icon (picked up
+  // through the assets/icon.svg convention) for the author to replace.
   await mkdir(join(dir, "assets"), { recursive: true })
-  console.log("   Write assets/")
+  await writeFile(join(dir, "assets", "icon.svg"), await readFile(join(SCAFFOLD_DIR, "icon.svg")))
+  console.log("   Write assets/icon.svg")
 
   // The scaffold package.json carries a placeholder name; set it from the
   // target folder. A core-level app gets no component framework dependency.

package/src/commands/mcp.ts

@@ -103,7 +103,7 @@ let TOOLS: {
     name: "get_stats",
     readOnly: true,
     description:
-      "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count. Layout-activity counters cover the last full rebuild, raw: nodes (live node count, mounted AND detached), mountedNodes/orphanNodes (live at query time: nodes reachable from the root vs not - orphans growing at a stable tree shape mean an unmount leak; absent when no engine is running), measureCalls (text measures; mostly cache hits, cheap), paraShapes (paragraphs actually shaped; the expensive signal - high layoutMs with near-zero paraShapes means the cost is not text shaping), dirtiedNodes (layout caches cleared by property writes since the previous rebuild; how much of the tree a write burst invalidated), cacheGets/cacheHits (layout-cache lookups during the rebuild; a hit on a container skips its whole subtree, so a healthy incremental rebuild shows a near-100% hit rate - a low rate at scale means the layout cache is being defeated).",
+      "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count. Layout-activity counters cover the last full rebuild, raw: nodes (live node count, mounted AND detached), mountedNodes/orphanNodes (live at query time: nodes reachable from the root vs not - orphans growing at a stable tree shape mean an unmount leak; absent when no engine is running), measureCalls (text measures; mostly cache hits, cheap), paraShapes (paragraphs actually shaped; the expensive signal - high layoutMs with near-zero paraShapes means the cost is not text shaping), dirtiedNodes (layout caches cleared by property writes since the previous rebuild; how much of the tree a write burst invalidated), cacheGets/cacheHits (layout-cache lookups during the rebuild; a hit on a container skips its whole subtree, so a healthy incremental rebuild shows a near-100% hit rate - a low rate at scale means the layout cache is being defeated). GPU-side health, read live at query time (absent when no engine is running): rasterQueue (raster commands sent but not yet executed; stuck nonzero means the raster thread is backlogged - the state where fps and frameMs go blind because no frames complete), idleTicks (cumulative idle frame signals emitted while the GPU had nothing queued; idleTicks racing while rasterQueue sits nonzero would mean the idle-tick gate is broken), fenceTimeouts (cumulative present-fence waits that expired instead of signaling - each one is a frame where the GPU was over budget for 100ms+ and one-frame-in-flight pacing was lost; zero on a healthy machine, climbing means the GPU is the bottleneck right now).",
     inputSchema: { client: CLIENT_ARG },
   },
   {
@@ -137,9 +137,12 @@ let TOOLS: {
     name: "get_snapshot",
     readOnly: true,
     description:
-      "Capture a PNG image of any node in a running app client's render tree, by node id (get ids from get_render_tree). Returns the rendered pixels of that node's subtree, so you can see what the app actually drew. The node must be currently mounted and have a non-zero layout box. Works on an idle client (the capture requests its own frame); a timeout means the client's JS thread is busy or wedged, not that the app is idle.",
+      "Capture a PNG image of any node in a running app client's render tree, by node id (get ids from get_render_tree). Returns the rendered pixels of that node's subtree, so you can see what the app actually drew. Capture the smallest node that contains what you are checking (e.g. the <texture> leaf itself) - that is exactly the content at its own pixel size; the window root is mostly empty layout around it and orders of magnitude more pixels. Reserve root captures for when layout/positioning itself is the question. The node must be currently mounted and have a non-zero layout box. Works on an idle client (the capture requests its own frame); a timeout means the client's JS thread is busy or wedged, not that the app is idle.",
     inputSchema: {
-      nodeId: z.number().int().describe("Id of the node to capture, from get_render_tree"),
+      nodeId: z
+        .number()
+        .int()
+        .describe("Id of the node to capture, from get_render_tree; prefer the smallest relevant node over the root"),
       save_to: SAVE_TO_ARG,
       client: CLIENT_ARG,
     },

package/src/commands/server.ts

@@ -1,6 +1,7 @@
 import pkg from "../../package.json"
 import { source, isSource, isPrebuilt, values } from "../args"
-import { state, shutdown } from "../util"
+import { state, shutdown, print, printErr } from "../util"
+import { findProjectRoot, typecheck, reportTypes } from "./check"
 import { bundle } from "../bundler"
 import { buildManifest, projectDirFor } from "../project"
 import { startServer, buildReload, sendReload, showBuildFailure } from "../dev-server"
@@ -53,4 +54,17 @@ export async function runServerCommand() {
   console.log(`[cli] Welcome to SolidRT${version}!`)
   startRepl()
   startWatcher()
+
+  // Startup typecheck, deliberately not awaited: diagnostics print over the
+  // repl when tsc finishes, and a type error never gates the boot (srt check
+  // is the hard gate). Once per server lifetime; hot reloads never typecheck.
+  // Source builds only: a prebuilt .srt.js has no checkable project here.
+  if (source && isSource) startupTypecheck(source)
+}
+
+async function startupTypecheck(entry: string) {
+  let root = findProjectRoot(entry)
+  if (!root) return
+  let types = await typecheck(root, entry)
+  if (types) reportTypes(types, print, printErr)
 }

package/src/dev-server.ts

@@ -82,7 +82,8 @@ export async function watchAllowed(): Promise<boolean> {
   try {
     let resp = await fetch(`${INTERNAL_BASE}/watch`)
     if (!resp.ok) return true
-    return (await resp.json()).enabled !== false
+    let data = (await resp.json()) as { enabled?: boolean }
+    return data.enabled !== false
   } catch {
     return true
   }
@@ -100,7 +101,7 @@ export type ClientEntry = {
 export async function getClients(): Promise<ClientEntry[]> {
   let resp = await fetch(`${INTERNAL_BASE}/clients`)
   if (!resp.ok) throw new Error(`Dev server /clients failed: ${resp.status}`)
-  return resp.json()
+  return resp.json() as Promise<ClientEntry[]>
 }
 
 // Reload code that fails to start the engine on purpose. The runtime treats a

package/src/pack-folder.ts

@@ -37,7 +37,7 @@ export type PackFolder = {
 export function buildPackFolder(entry: string, bytecode: Buffer): PackFolder {
   let identity = loadAppIdentity(entry)
   let projectDir = projectDirFor(resolve(entry))
-  let { assets } = collectAssets(entry)
+  let { assets, icon } = collectAssets(entry)
   let copies = assets.map((a) => ({ from: join(projectDir, a.path), to: a.path }))
 
   // The full resolved font set: custom fonts are already collected assets;
@@ -70,6 +70,7 @@ export function buildPackFolder(entry: string, bytecode: Buffer): PackFolder {
     appId: identity.appId,
     org: identity.org,
     displayName: identity.displayName,
+    ...(icon ? { icon } : {}),
     runtimeVersion: RUNTIME_VERSION,
     solidrtVersion: SOLIDRT_VERSION,
     bundle: { path: "bundle.bin", sha256: hashHex(bytecode), size: bytecode.length },

package/src/project.ts

@@ -8,7 +8,10 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "nod
 //     "appId": "com.example.app",   // stable identity: storage dir, Android package id
 //     "org": "Example",             // optional display metadata (publisher)
 //     "displayName": "Example App", // optional display metadata (launcher/window)
-//     "fonts": { ... }              // see fonts.ts
+//     "fonts": { ... },             // see fonts.ts
+//     "icon": "./assets/icon.svg"   // optional app icon (SVG, under assets/);
+//                                   // an undeclared assets/icon.svg is picked
+//                                   // up by convention
 //   }
 //
 // Everything defaults from the package name (or the entry filename when there
@@ -71,11 +74,13 @@ export const SOLIDRT_VERSION: string = pkgVersion === "0.0.0" ? "unknown" : pkgV
 export function buildManifest(code: string, entry: string): string {
   let identity = loadAppIdentity(entry)
   let sha256 = new Bun.CryptoHasher("sha256").update(code).digest("hex")
-  let { assets, fonts } = collectAssets(entry)
+  let { assets, fonts, icon } = collectAssets(entry)
   return JSON.stringify({
     appId: identity.appId,
+    displayName: identity.displayName,
     runtimeVersion: RUNTIME_VERSION,
     solidrtVersion: SOLIDRT_VERSION,
+    ...(icon ? { icon } : {}),
     bundle: { path: "bundle.js", sha256, size: Buffer.byteLength(code, "utf8") },
     ...(assets.length ? { assets } : {}),
     ...(fonts.length ? { fonts } : {}),
@@ -116,11 +121,19 @@ function walkAssets(assetsDir: string, dir: string, out: ManifestAsset[]) {
 
 // The convention-first asset set: everything under the project's assets/
 // folder (next to package.json), collected wholesale in sorted order so the
-// manifest bytes are deterministic. Fonts are annotations pointing into that
-// set: `solidrt.fonts` path entries must live under assets/ so they reach dev
-// clients and the version store (`false` entries only drop pack defaults and
-// have no manifest presence).
-export function collectAssets(entry: string): { assets: ManifestAsset[]; fonts: ManifestFont[] } {
+// manifest bytes are deterministic. Fonts and the icon are annotations
+// pointing into that set: `solidrt.fonts` path entries and `solidrt.icon`
+// must live under assets/ so they reach dev clients and the version store
+// (`false` font entries only drop pack defaults and have no manifest
+// presence). The icon is SVG-only for now: the launcher renders SVG natively,
+// and the raster surfaces (window icon, OS embedding) come with later stages
+// (okf/backlog/app-icons.md). An undeclared assets/icon.svg is picked up by
+// convention.
+export function collectAssets(entry: string): {
+  assets: ManifestAsset[]
+  fonts: ManifestFont[]
+  icon: string | null
+} {
   let project = findProjectPackage(entry)
   let projectDir = projectDirFor(entry)
   let assetsDir = resolve(projectDir, "assets")
@@ -146,7 +159,27 @@ export function collectAssets(entry: string): { assets: ManifestAsset[]; fonts:
       fonts.push({ path, alias })
     }
   }
-  return { assets, fonts }
+
+  let icon: string | null = null
+  let declared = project?.pkg.solidrt?.icon
+  if (declared !== undefined) {
+    if (typeof declared !== "string") fail('"solidrt": "icon" must be a string path')
+    let path = assetPathFor(projectDir, resolve(projectDir, declared))
+    if (!path) {
+      fail(`"solidrt.icon": ${declared} must live under assets/ (the icon ships as a version asset)`)
+    }
+    if (!path.toLowerCase().endsWith(".svg")) {
+      fail(`"solidrt.icon": ${declared} must be an .svg file`)
+    }
+    if (!assets.some((a) => a.path === path)) {
+      fail(`"solidrt.icon": no such file: ${resolve(projectDir, declared)}`)
+    }
+    icon = path
+  } else if (assets.some((a) => a.path === "assets/icon.svg")) {
+    icon = "assets/icon.svg"
+  }
+
+  return { assets, fonts, icon }
 }
 
 // Resolve the app identity for a pack. All three fields are guaranteed
@@ -154,7 +187,9 @@ export function collectAssets(entry: string): { assets: ManifestAsset[]; fonts:
 export function loadAppIdentity(sourcePath: string): AppIdentity {
   let project = findProjectPackage(sourcePath)
   let config = project?.pkg.solidrt ?? {}
-  let fallbackName = project?.pkg.name ?? basename(sourcePath).replace(/\.[jt]sx?$/, "")
+  // A scoped package name (@org/name) defaults to its last segment: identity
+  // fields reject path separators, and derived defaults must never fail that.
+  let fallbackName = (project?.pkg.name ?? basename(sourcePath).replace(/\.[jt]sx?$/, "")).split("/").pop()!
 
   for (let key of ["appId", "org", "displayName"]) {
     if (key in config && typeof config[key] !== "string") fail(`"solidrt": "${key}" must be a string`)
@@ -170,7 +205,7 @@ export function loadAppIdentity(sourcePath: string): AppIdentity {
       fail(`"solidrt": "appId" must match ${APP_ID_PATTERN} (reverse-DNS recommended, e.g. "com.example.app")`)
     }
   }
-  let displayName = config.displayName ?? (project?.pkg.name || fallbackName)
+  let displayName = config.displayName ?? fallbackName
   let org = config.org ?? displayName
   checkField(appId, '"appId"')
   checkField(displayName, '"displayName"')

package/src/untyped-deps.d.ts

@@ -0,0 +1,18 @@
+// Packages with no bundled or DefinitelyTyped declarations. @babel/core is
+// covered by @types/babel__core; plugins and presets have no dedicated types
+// by convention - they are consumed as opaque PluginItem values.
+declare module "@babel/plugin-syntax-jsx" {
+  import { type PluginItem } from "@babel/core"
+  let plugin: PluginItem
+  export default plugin
+}
+declare module "@babel/preset-typescript" {
+  import { type PluginItem } from "@babel/core"
+  let preset: PluginItem
+  export default preset
+}
+declare module "babel-preset-solid" {
+  import { type PluginItem } from "@babel/core"
+  let preset: PluginItem
+  export default preset
+}