@solidrt/cli 0.0.50 → 0.0.52

package/src/check/main.ts

@@ -0,0 +1,85 @@
+import { existsSync, statSync } from "node:fs"
+import { Glob } from "bun"
+import { join, resolve } from "node:path"
+import { source } from "../lib/args"
+import { bundleWith } from "../bundle/bundler"
+import { findProject } from "../lib/project"
+import { findProjectRoot, reportTypes, typecheck } from "./typecheck"
+
+// srt check: verify the app without side effects. Bundles in memory (nothing
+// written, so no dev-server reload fires and no build outputs land in the
+// project) and typechecks with the project's own tsc (typecheck.ts).
+
+// Check one entry: bundle in memory, then typecheck. Returns whether it passed.
+async function checkEntry(entry: string): Promise<boolean> {
+  let failed = false
+  // check verifies trees of entries from one cwd, so it is the one command
+  // that walks up from each entry to its project.
+  let result = await bundleWith({ entry, dev: true, minify: false, project: findProject(entry)?.dir ?? null })
+  if (!result) {
+    // bundleWith already printed the compile errors.
+    failed = true
+  }
+  let root = findProjectRoot(entry)
+  if (!root) {
+    console.warn("Typecheck skipped: no tsconfig.json or package.json above the entry")
+  } else {
+    let types = await typecheck(root, entry)
+    if (types && reportTypes(types)) failed = true
+  }
+  return !failed
+}
+
+// The entries `srt check <folder>` covers, relative to the folder (a bare
+// `srt check` is `srt check .`): the app itself, its own examples, and in
+// a monorepo every example app, package example and package demo. The same
+// set CI gates, so one call at the repo root answers "did I break any
+// example" before pushing. Entries, not files: a source no entry imports is
+// not checked.
+const CHECK_ALL_GLOBS = [
+  "src/index.tsx",
+  "examples/*.tsx",
+  "examples/*/src/index.tsx",
+  "packages/*/examples/*.tsx",
+  "packages/*/demos/src/*.tsx",
+]
+function discoverEntries(root: string): string[] {
+  let entries: string[] = []
+  for (let pattern of CHECK_ALL_GLOBS) {
+    entries.push(...[...new Glob(pattern).scanSync({ cwd: root })].map((e) => join(root, e)))
+  }
+  return entries.sort()
+}
+
+export async function main() {
+  let target = source ?? "."
+  if (!existsSync(target)) {
+    // Without this, the missing file surfaces later as an internal ENOENT
+    // stack trace (scandir/Bun.build), which reads as a CLI bug - the common
+    // cause is just running from the wrong directory.
+    console.error(`No such entry: ${target} (resolved from ${process.cwd()})`)
+    process.exit(1)
+  }
+  if (!statSync(target).isDirectory()) {
+    if (!(await checkEntry(target))) process.exit(1)
+    console.log("Check passed")
+    process.exit(0)
+  }
+
+  let entries = discoverEntries(target)
+  if (entries.length === 0) {
+    console.error(`No entries found under ${resolve(target)} (looked for ${CHECK_ALL_GLOBS.join(", ")})`)
+    process.exit(1)
+  }
+  let failures: string[] = []
+  for (let entry of entries) {
+    console.log(`== ${entry}`)
+    if (!(await checkEntry(entry))) failures.push(entry)
+  }
+  if (failures.length > 0) {
+    console.error(`${failures.length} of ${entries.length} entries failed:\n  ${failures.join("\n  ")}`)
+    process.exit(1)
+  }
+  console.log(`Check passed (${entries.length} entries)`)
+  process.exit(0)
+}

package/src/{commands/check.ts → check/typecheck.ts}

@@ -1,14 +1,12 @@
 import { existsSync, mkdirSync, rmSync } from "node:fs"
 import { dirname, join, resolve } from "node:path"
-import { source } from "../args"
-import { bundleWith, findIsolateModules } from "../bundler"
+import { findIsolateModules } from "../bundle/bundler"
 
-// srt check: verify the app without side effects. Bundles in memory (nothing
-// written, so no dev-server reload fires and no build outputs land in the
-// project) and typechecks with the project's own tsc, reporting only
-// diagnostics in app code. @solidrt packages ship raw .ts sources, so a strict
-// consumer config surfaces their internal errors too; those are counted and
-// hidden, not the caller's problem to wade through.
+// Typechecking an app entry with the project's own tsc, reporting only
+// diagnostics in app code. Used by `srt check` (the hard gate) and by the dev
+// server's startup check (it spawns `srt check <entry>`). @solidrt packages ship
+// raw .ts sources, so a strict consumer config surfaces their internal errors
+// too; those are counted and hidden, not the caller's problem to wade through.
 
 // Walk up from the entry to the enclosing project (tsconfig.json or, failing
 // that, package.json).
@@ -27,7 +25,7 @@ export function findProjectRoot(entry: string): string | null {
 
 // One tsc --pretty false diagnostic: the "path(line,col): error TS...: ..."
 // head line plus any indented continuation lines.
-type Diagnostic = { head: string; lines: string[]; inDependencies: boolean }
+export type Diagnostic = { head: string; lines: string[]; inDependencies: boolean }
 
 function parseDiagnostics(output: string): Diagnostic[] {
   let diagnostics: Diagnostic[] = []
@@ -58,6 +56,8 @@ function findTsc(fromDir: string): string | null {
   }
 }
 
+export type TypecheckResult = { app: Diagnostic[]; hidden: number }
+
 // 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 (plus the project's ambient declarations), so tsc checks exactly the
@@ -65,7 +65,7 @@ function findTsc(fromDir: string): string | null {
 // 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> {
+export async function typecheck(root: string, entry: string): Promise<TypecheckResult | null> {
   let tsconfig = join(root, "tsconfig.json")
   if (!existsSync(tsconfig)) {
     console.warn("Typecheck skipped: no tsconfig.json above the entry")
@@ -111,7 +111,7 @@ export async function typecheck(root: string, entry: string): Promise<{ app: Dia
 // 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 },
+  types: TypecheckResult,
   log: (...args: any[]) => void = console.log,
   error: (...args: any[]) => void = console.error,
 ): boolean {
@@ -125,26 +125,3 @@ export function reportTypes(
   else log("Types OK")
   return false
 }
-
-export async function runCheckCommand() {
-  let entry = source!
-  let failed = false
-
-  let result = await bundleWith({ entry, dev: true, minify: false })
-  if (!result) {
-    // bundleWith already printed the compile errors.
-    failed = true
-  }
-
-  let root = findProjectRoot(entry)
-  if (!root) {
-    console.warn("Typecheck skipped: no tsconfig.json or package.json above the entry")
-  } else {
-    let types = await typecheck(root, entry)
-    if (types && reportTypes(types)) failed = true
-  }
-
-  if (failed) process.exit(1)
-  console.log("Check passed")
-  process.exit(0)
-}

package/src/client/docs.md

@@ -0,0 +1,9 @@
+# srt client
+
+{{ usage client }}
+
+The client half of [srt run](../server/docs.md), on its own. Without flags
+it attaches to the dev server of the project (or file) in the current
+directory; `--port` picks a local server by port and `--server` names any
+address, which is how a second machine joins a server started with `--lan`.
+A phone or tablet is [srt android](../android/docs.md).

package/src/client/main.ts

@@ -0,0 +1,33 @@
+import { values, port, clientStorageArgs } from "../lib/args"
+import { requireBinary, run } from "../lib/util"
+import { resolveFromCwd } from "../lib/registry"
+
+// Standalone solidrt-go client (no dev server of its own). Without flags it
+// attaches to the dev server of the project (or file) in the current
+// directory, resolved from the registry; --port picks a local server by port
+// and --server names any address. A device is `srt android`.
+export async function main() {
+  let runner = requireBinary("solidrt-go")
+  let args: string[] = [...clientStorageArgs()]
+  if (values.size) args.push("--size", values.size)
+  let address: string
+  if (values.server) {
+    if (!values.server.includes(":")) {
+      console.error(`--server needs host:port (got "${values.server}"); dev servers have no fixed port`)
+      process.exit(1)
+    }
+    address = values.server
+  } else if (port !== undefined) {
+    address = `127.0.0.1:${port}`
+  } else {
+    let resolved = await resolveFromCwd(process.cwd())
+    if (!resolved.ok) {
+      console.error(resolved.message)
+      process.exit(1)
+    }
+    address = `127.0.0.1:${resolved.record.port}`
+  }
+  args.push("--dev-server", address)
+  let exit = await run(runner, args)
+  process.exit(exit)
+}

package/src/console/docs.md

@@ -0,0 +1,14 @@
+# srt console
+
+{{ usage console }}
+
+The dev console: the dev servers running on this machine, the clients
+attached to each, and a button to start a local client for one. It is not
+served by a dev server: the CLI ships the console pre-compiled
+(`dist/console.srtapp`, see [srt pack --app](../pack/docs.md)) and this
+command starts the `solidrt` runner on that file, so it opens at once and
+runs the same whether a project is open or not.
+
+In a checkout the file is built with `make -C packages/cli
+dist/console.srtapp`; rerun it after editing `apps/console`. Everything
+after `--` reaches the console as its arguments.

package/src/console/main.ts

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { appArgs } from "../lib/args"
+import { requireBinary, run } from "../lib/util"
+
+// srt console: the dev console (apps/console) as a packed app on the plain
+// runner. The console is pre-compiled: dist/console.srtapp (manifest +
+// bytecode + assets, `srt pack --app`), built by `make -C packages/cli
+// dist/console.srtapp` - the release workflow before publishing, a checkout
+// after editing the console. This command builds nothing: it points the
+// runner at the file, and the runner is used in place, so a signed runner
+// stays signed.
+export async function main() {
+  let app = fileURLToPath(new URL("../../dist/console.srtapp", import.meta.url))
+  if (!existsSync(app)) {
+    console.error("Console not built: run make -C packages/cli dist/console.srtapp")
+    process.exit(1)
+  }
+  let exit = await run(requireBinary("solidrt"), [app, ...appArgs])
+  process.exit(exit)
+}

package/src/demo/docs.md

@@ -0,0 +1,27 @@
+# srt demo
+
+{{ usage demo }}
+
+The demos that come with the packages this project installs. Without an
+argument it lists them, numbered:
+
+```
+  1  3d/the-third-dimension
+```
+
+`srt demo 1` runs that one, exactly as [srt run](../server/docs.md) runs any
+project: a dev server, a local client window, reload on save, and the same
+server options (`--lan` to reach it from a device, `--port`, `--tunnel`). The qualified
+name works too (`srt demo 3d/the-third-dimension`), which is the stable way to
+name one in a script - the numbers follow the list, and the list follows what
+is installed.
+
+A package keeps its demos in `demos/`, and that folder is one project: its own
+package.json, one `assets/` folder, and `src/<name>.tsx` per demo. So the
+demos of one package share a dev server and a port - start a second one while
+the first is up and it says so. Demos from different packages run side by
+side.
+
+The demos ship inside the packages, so `node_modules` is where they are found:
+`srt demo` looks in the current directory and nowhere above it. Run it from
+the project root.

package/src/demo/main.ts

@@ -0,0 +1,67 @@
+import { readdirSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { source } from "../lib/args"
+
+// srt demo: the demos the installed @solidrt packages ship. A package's
+// demos are ONE project (`<package>/demos/`: package.json, one assets/, and
+// src/<name>.tsx per demo), so a demo runs as the project it lives in - this
+// file only lists and resolves, and main.ts starts the ordinary dev server
+// with its cwd set to that project. Nothing downstream knows about demos.
+
+export type Demo = { name: string; cwd: string; entry: string }
+
+const SCOPE = join("node_modules", "@solidrt")
+
+/** Every demo installed here, sorted so the printed numbers are stable.
+ * The cwd and nothing above it - the same rule the server's mode resolution
+ * follows (server/mode.ts), so this lists what THIS project installed. */
+function discover(): Demo[] {
+  let demos: Demo[] = []
+  for (let pkg of names(SCOPE)) {
+    let dir = join(SCOPE, pkg, "demos")
+    for (let file of names(join(dir, "src"))) {
+      if (!file.endsWith(".tsx")) continue
+      demos.push({ name: `${pkg}/${file.slice(0, -".tsx".length)}`, cwd: resolve(dir), entry: join("src", file) })
+    }
+  }
+  return demos
+}
+
+// A missing folder is the normal case (most packages ship no demos), so it
+// reads as an empty one rather than an error.
+function names(dir: string): string[] {
+  try {
+    return readdirSync(dir).sort()
+  } catch {
+    return []
+  }
+}
+
+function list(demos: Demo[]) {
+  for (let [i, demo] of demos.entries()) console.log(`  ${String(i + 1).padStart(2)}  ${demo.name}`)
+}
+
+/** Lists (no argument) or resolves one demo for the dev server to serve. */
+export async function main(): Promise<{ cwd: string; entry: string } | undefined> {
+  let demos = discover()
+  if (demos.length === 0) {
+    console.error(`No demos installed in ${process.cwd()} (looked in ${SCOPE}/*/demos/src/)`)
+    process.exit(1)
+  }
+
+  if (source === undefined) {
+    list(demos)
+    console.log("\nRun one with: srt demo <number>")
+    return undefined
+  }
+
+  // A number picks from the printed list; the qualified name it printed
+  // works too, so a demo can be named in a script without a fixed index.
+  let picked = /^\d+$/.test(source) ? demos[Number(source) - 1] : demos.find((d) => d.name === source)
+  if (!picked) {
+    console.error(`No such demo: ${source}`)
+    list(demos)
+    process.exit(1)
+  }
+  return { cwd: picked.cwd, entry: picked.entry }
+}

package/src/init/docs.md

@@ -0,0 +1,11 @@
+# srt init
+
+{{ usage init }}
+
+Scaffolds a new SolidRT project into a new (empty) folder: package.json,
+tsconfig.json, AGENTS.md, a starter src/index.tsx, an empty assets/
+(everything in it ships with the app) and an `.mcp.json`, then installs the
+dependencies. The picker offers extensions on an interactive terminal.
+
+The public entry point is `bun create solidrt <dir>`, which forwards here and
+needs nothing installed first.

package/src/{commands/init.ts → init/main.ts}

@@ -1,15 +1,15 @@
 import { cp, mkdir, readFile, readdir, writeFile } from "node:fs/promises"
 import { basename, dirname, join, resolve } from "node:path"
-import { source, values } from "../args"
-import { multiselect, note, text } from "../prompt"
+import { source, values } from "../lib/args"
+import { multiselect, note, text } from "./prompt"
 
 const DEFAULT_NAME = "solidrt-app"
 
-const SCAFFOLD_DIR = join(import.meta.dir, "../../scaffold")
+const SCAFFOLD_DIR = join(import.meta.dir, "scaffold")
 const TEMPLATES_DIR = join(SCAFFOLD_DIR, "templates")
 
 // Shared project files written for every template. Sources live in
-// cli/scaffold/. The .gitignore is stored there as `gitignore` because npm
+// cli/src/init/scaffold/. The .gitignore is stored there as `gitignore` because npm
 // strips files literally named `.gitignore` from published packages, so it is
 // renamed on the way out. The per-template src/ comes from scaffold/templates/.
 const TEMPLATE_FILES: Array<{ from: string; to: string }> = [
@@ -30,11 +30,27 @@ function packageName(dir: string): string {
 
 const DEFAULT_TEMPLATE = "default"
 
+// One AGENTS.md serves every template, so the lines that point an agent at
+// an extension's docs are fenced between `<!-- <key>:begin/end -->` markers:
+// with the extension selected only the markers go, without it the block goes
+// too, so an app never ships references to files that are not installed.
+function resolveMarkers(text: string, extensions: Extension[]): string {
+  for (let ext of EXTENSIONS) {
+    let selected = extensions.includes(ext)
+    let block = new RegExp(`^<!-- ${ext.key}:begin -->\\n[\\s\\S]*?^<!-- ${ext.key}:end -->\\n`, "gm")
+    let marker = new RegExp(`^<!-- ${ext.key}:(?:begin|end) -->\\n`, "gm")
+    text = selected ? text.replace(marker, "") : text.replace(block, "")
+  }
+  return text
+}
+
 // Optional packages an app can opt into on top of core. Each maps to a
 // dependency in the scaffold package.json (kept when selected, removed
-// otherwise) and optionally to a starter under scaffold/templates/.
+// otherwise), to a marker key fencing its lines in scaffold/AGENTS.md, and
+// optionally to a starter under scaffold/templates/.
 interface Extension {
   pkg: string
+  key: string
   template?: string
   description: string
 }
@@ -42,30 +58,18 @@ interface Extension {
 const EXTENSIONS: Extension[] = [
   {
     pkg: "@solidrt/components",
+    key: "components",
     template: "components",
     description: "component framework: widgets, theming, navigation",
   },
-  { pkg: "@solidrt/3d", description: "general purpose 3D library" },
+  { pkg: "@solidrt/2d", key: "2d", description: "general purpose 2D library" },
+  { pkg: "@solidrt/3d", key: "3d", description: "general purpose 3D library" },
 ]
 
-// Resolve which extensions the app takes: an explicit --with list if valid,
-// an interactive picker on a TTY, else none (core only).
+// Resolve which extensions the app takes: an interactive picker on a TTY,
+// else none (core only). Extensions are ordinary dependencies, so a script
+// adds them afterwards with `bun add`.
 async function resolveExtensions(): Promise<Extension[]> {
-  let raw = values.with
-  if (raw !== undefined) {
-    let names = raw.split(",").map((n) => n.trim()).filter(Boolean)
-    let chosen: Extension[] = []
-    for (let name of names) {
-      let found = EXTENSIONS.find((e) => e.pkg === name)
-      if (!found) {
-        let all = EXTENSIONS.map((e) => e.pkg).join(", ")
-        console.error(`!! Unknown extension "${name}"; choose from: ${all}`)
-        process.exit(1)
-      }
-      if (!chosen.includes(found)) chosen.push(found)
-    }
-    return chosen
-  }
   if (!process.stdin.isTTY) return []
   // Core is the runtime every app has, so it is not a choice.
   note("@solidrt/core is always included", "Packages")
@@ -82,7 +86,7 @@ function resolveTemplate(extensions: Extension[]): string {
   return extensions.find((e) => e.template)?.template ?? DEFAULT_TEMPLATE
 }
 
-export async function runInitCommand() {
+export async function main() {
   // The target folder comes from the positional arg, or an interactive prompt
   // (defaulting to a suggested name) when omitted.
   let dir = source
@@ -109,7 +113,9 @@ export async function runInitCommand() {
   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)))
+    let body: string | Buffer = await readFile(join(SCAFFOLD_DIR, from))
+    if (to === "AGENTS.md") body = resolveMarkers(body.toString("utf8"), extensions)
+    await writeFile(dest, body)
     console.log(`   Write ${to}`)
   }
 

package/src/init/scaffold/AGENTS.md

@@ -0,0 +1,98 @@
+# SolidRT app - agent notes
+
+This project uses SolidRT: a custom SolidJS renderer that paints through a Rust
+runtime. No DOM, no HTML, no CSS cascade. If you are an AI assistant, read this
+whole file before writing or editing code here - it is short on purpose. The
+depth lives in the topic files listed under "Read before you", one of which you
+should open whenever the work matches its trigger.
+
+## Levels: core, and extensions on top
+
+- @solidrt/core is the low-level foundation: host intrinsics (`<window>`,
+  `<view>`, `<text>`, the detached `d-*` drawing primitives) with flat props
+  that feed the layout and paint engine directly. An app can be written
+  entirely at this level.
+- Extensions build on core. The first-party ones are @solidrt/components
+  (UI components), @solidrt/2d (2D graphics) and @solidrt/3d (3D graphics).
+  None is privileged - an extension is just functions returning core JSX,
+  and an app can use a third-party one or grow its own.
+
+Match the level the code you are editing already uses. package.json shows
+the choice this app made: only the extensions listed there are installed -
+do not add one for a change core covers.
+
+Convention: every @solidrt package describes itself in
+node_modules/@solidrt/<name>/AGENTS.md, carries its prose in docs/, and
+ships working code in examples/. AGENTS.md is the reference for the package;
+open it before using anything from the package, and read the extensions'
+files only when they are installed.
+
+## Read before you
+
+The authoritative references ship inside the installed packages. Open the one
+that matches the work; do not work from memory of what a web framework does.
+
+- write any reactive code (signals, effects, control flow) ->
+  node_modules/solid-js/CHEATSHEET.md - the SolidJS 2.0 model
+- touch elements, props, events, gestures or text ->
+  node_modules/@solidrt/core/AGENTS.md, and
+  node_modules/@solidrt/core/src/types.d.ts + jsx-runtime.d.ts (source of truth)
+- style a screen: a background, a gradient, a shadow, an effect, vector art,
+  a chart -> node_modules/@solidrt/core/agents/painting.md
+- write per-frame code, an animation, or anything writing properties in a
+  loop -> node_modules/@solidrt/core/agents/performance.md
+- use an installed extension (UI components, 2D, 3D) ->
+  node_modules/@solidrt/<name>/AGENTS.md and its examples/
+- debug a running app, or drive it over MCP to verify a change ->
+  node_modules/@solidrt/cli/agents/debugging.md
+- add an asset or font, set the app's identity, or build for distribution ->
+  node_modules/@solidrt/cli/agents/assets.md
+- run, bundle, typecheck or render headlessly ->
+  node_modules/@solidrt/cli/AGENTS.md
+- copy a working pattern -> node_modules/@solidrt/core/examples/ (see its
+  README.md index)
+
+<!-- Claude Code auto-imports these; other tools read the paths above. -->
+@./node_modules/solid-js/CHEATSHEET.md
+@./node_modules/@solidrt/core/AGENTS.md
+<!-- components:begin -->
+@./node_modules/@solidrt/components/AGENTS.md
+<!-- components:end -->
+<!-- 2d:begin -->
+@./node_modules/@solidrt/2d/AGENTS.md
+<!-- 2d:end -->
+<!-- 3d:begin -->
+@./node_modules/@solidrt/3d/AGENTS.md
+<!-- 3d:end -->
+@./node_modules/@solidrt/cli/AGENTS.md
+
+## The three traps that cost the most (this is not React/DOM)
+
+Each package's AGENTS.md carries its own trap list; these three are
+platform-wide and bite in every app:
+
+1. Reading a signal/prop/store at the top level of a component body (not
+   inside JSX, a `createMemo`, or an effect's compute phase) reads it
+   untracked - it silently freezes at the initial value. `createEffect` is
+   two-argument here: `(compute, apply)`; the Solid 1.x single-arg form does
+   not track.
+2. Writing a signal or store from inside an owned scope - a component body,
+   a `createMemo`, an effect's compute phase - throws
+   `REACTIVE_WRITE_IN_OWNED_SCOPE` in dev. Move the write into an event
+   handler, an effect's apply phase, `onSettled`, or an `untrack` block; opt
+   in with `createSignal(v, { ownedWrite: true })` for internal state.
+3. An element-valued prop (children, a content/icon slot) builds a fresh
+   native subtree on EVERY read, and an uninserted subtree is never freed -
+   a permanent memory leak, not wasted work. Read such props exactly once,
+   where they mount; inspect them through the `children()` helper.
+
+## Run / verify
+
+- FIRST check whether a dev server and a client are already running and
+  build against those; do not start a second `srt run` when one is up.
+- The dev loop (reload, logs, snapshots, the holds on reload-on-save and on
+  the user's input), typechecking, headless rendering and the MCP tools:
+  node_modules/@solidrt/cli/AGENTS.md and its agents/debugging.md. Read it
+  before the first reload. The `.mcp.json` here is Claude Code's convention;
+  if your client lists no `solidrt` tools, debugging.md has the entry to add
+  to its own config.

package/src/init/scaffold/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "solidrt-app",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "srt run",
+    "pack": "srt pack -o out",
+    "server": "srt server",
+    "client": "srt client",
+    "android": "srt android"
+  },
+  "dependencies": {
+    "@solidrt/core": "0.0.52",
+    "@solidrt/components": "0.0.52",
+    "@solidrt/2d": "0.0.52",
+    "@solidrt/3d": "0.0.52"
+  },
+  "devDependencies": {
+    "@solidrt/cli": "0.0.52",
+    "@solidrt/flux-types": "0.0.52",
+    "typescript": "^7"
+  }
+}

package/{scaffold → src/init/scaffold}/templates/components/index.tsx

@@ -1,7 +1,6 @@
 // Components template: built with the @solidrt/components framework.
-import { render, createLinearGradient } from "@solidrt/core"
+import { render, createLinearGradient, Logo } from "@solidrt/core"
 import { Window, SafeArea, View, Text } from "@solidrt/components"
-import { Icon } from "./icon"
 
 function App() {
   let backgroundColor = createLinearGradient(0, 0, 1, 1, [
@@ -13,7 +12,7 @@ function App() {
     <Window title="The Solid Runtime" style={{ backgroundColor }}>
       <SafeArea>
         <View layout={{ flex: 1, gap: 20, alignItems: "center", justifyContent: "center" }}>
-          <Icon />
+          <Logo size={300} animation="loop" />
           <Text layout={{ fontSize: 40 }} style={{ color: "#ccc" }}>
             The Solid Runtime
           </Text>

package/{scaffold → src/init/scaffold}/templates/default/index.tsx

@@ -1,5 +1,4 @@
-import { render, createLinearGradient, safeArea } from "@solidrt/core"
-import { Icon } from "./icon"
+import { render, createLinearGradient, safeArea, Logo } from "@solidrt/core"
 
 function App() {
   let backgroundColor = createLinearGradient(0, 0, 1, 1, [
@@ -18,7 +17,7 @@ function App() {
         paddingTop={safeArea().top}
         paddingBottom={safeArea().bottom}
       >
-        <Icon />
+        <Logo size={300} animation="loop" />
         <text fontSize={40} color="#ccc">The Solid Runtime</text>
       </view>
     </window>