@solidrt/cli 0.0.36 → 0.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -28,17 +28,18 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.36",
-    "@solidrt/linux-arm64-gnu": "0.0.36",
-    "@solidrt/linux-x64-gnu": "0.0.36",
-    "@solidrt/win32-x64-msvc": "0.0.36"
+    "@solidrt/darwin-arm64": "0.0.38",
+    "@solidrt/linux-arm64-gnu": "0.0.38",
+    "@solidrt/linux-x64-gnu": "0.0.38",
+    "@solidrt/win32-x64-msvc": "0.0.38"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.36",
+    "@solidrt/core": "0.0.38",
     "typescript": "^7"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.36",
+    "@solidrt/flux-types": "0.0.38",
+    "@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/package.json

@@ -9,12 +9,12 @@
     "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.36",
-    "@solidrt/components": "0.0.36"
+    "@solidrt/core": "0.0.38",
+    "@solidrt/components": "0.0.38"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.36",
-    "@solidrt/flux-types": "0.0.36",
+    "@solidrt/cli": "0.0.38",
+    "@solidrt/flux-types": "0.0.38",
     "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/args.ts

@@ -28,13 +28,23 @@ export let { values, positionals } = parseArgs({
   allowPositionals: true,
 })
 
-// Storage flags for a locally spawned client. The data root defaults to the
-// project-local .srt-data so dev state stays with the project; it is passed
-// absolute because the client chdirs into its app sandbox at startup. Remote
-// clients resolve their own local root instead (see lattice/src/storage.rs).
+// Storage flags for a locally spawned client, forwarded only when given: with
+// no --data-root the client resolves its platform pref path (see
+// lattice/src/storage.rs); --client <N> selects the client<N>/ tree under
+// either root. An explicit root is passed absolute because the client chdirs
+// into its app sandbox at startup.
 export function clientStorageArgs(): string[] {
-  let args = ["--data-root", resolve(values["data-root"] ?? ".srt-data")]
-  if (values.client) args.push("--client", values.client)
+  let args: string[] = []
+  let root = values["data-root"]
+  if (root) args.push("--data-root", resolve(root))
+  let client = values.client
+  if (client !== undefined) {
+    if (!/^\d+$/.test(client)) {
+      console.error(`Invalid --client value "${client}": expected a non-negative integer`)
+      process.exit(1)
+    }
+    args.push("--client", client)
+  }
   return args
 }
 
@@ -112,8 +122,8 @@ run/server options:
 run/client options:
       --size <WxH>       Window size (default: 1280x720)
       --stats            Show the debug stats overlay (FPS, memory, frame timings)
-      --data-root <dir>  Client data root (default: ./.srt-data)
-      --client <name>    Client name: its own data dir under the data root (default: "default")
+      --data-root <dir>  Client data root (default: the platform pref path)
+      --client <N>       Client number: its own data tree under the data root (default: 0)
 
 client options:
       --server <host[:port]>  Connect to a dev server at this address (default port: 34884)

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

@@ -6,6 +6,7 @@ import {
   loadAppIdentity,
   projectDirFor,
   RUNTIME_VERSION,
+  SOLIDRT_VERSION,
   type ManifestFont,
 } from "./project"
 import { resolvePackFonts } from "./fonts"
@@ -70,6 +71,7 @@ export function buildPackFolder(entry: string, bytecode: Buffer): PackFolder {
     org: identity.org,
     displayName: identity.displayName,
     runtimeVersion: RUNTIME_VERSION,
+    solidrtVersion: SOLIDRT_VERSION,
     bundle: { path: "bundle.bin", sha256: hashHex(bytecode), size: bytecode.length },
     ...(assets.length ? { assets } : {}),
     ...(fonts.length ? { fonts } : {}),

package/src/project.ts

@@ -61,6 +61,13 @@ function checkField(value: string, what: string) {
 // derivation question is settled (see plan).
 export const RUNTIME_VERSION = 1
 
+// The manifest's solidrtVersion: provenance, not a compat gate like
+// runtimeVersion - the CLI release that built the version. Published CLIs
+// carry the real version in their package.json; the in-repo 0.0.0
+// placeholder stamps "unknown".
+let pkgVersion = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")).version
+export const SOLIDRT_VERSION: string = pkgVersion === "0.0.0" ? "unknown" : pkgVersion
+
 export function buildManifest(code: string, entry: string): string {
   let identity = loadAppIdentity(entry)
   let sha256 = new Bun.CryptoHasher("sha256").update(code).digest("hex")
@@ -68,6 +75,7 @@ export function buildManifest(code: string, entry: string): string {
   return JSON.stringify({
     appId: identity.appId,
     runtimeVersion: RUNTIME_VERSION,
+    solidrtVersion: SOLIDRT_VERSION,
     bundle: { path: "bundle.js", sha256, size: Buffer.byteLength(code, "utf8") },
     ...(assets.length ? { assets } : {}),
     ...(fonts.length ? { fonts } : {}),
@@ -146,7 +154,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`)
@@ -162,7 +172,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
+}