@solidrt/cli 0.0.51 → 0.0.53

package/src/server/watcher.ts

@@ -0,0 +1,121 @@
+import { dir } from "flux:fs"
+import { state } from "./state"
+import { dirname } from "./mode"
+import { rebuildAndBroadcast, showBuildFailure } from "./rebuild"
+
+// Reload-on-save. Not a directory watch: the watch set is the bundle's own
+// input list (BundleOutput.inputs: the app's modules, the dependency modules
+// bundled in, inlined files, package.json, tsconfig.json), so a source file
+// the running app does not import, or a dependency it does not use, never
+// triggers anything, while an edit to a workspace package it does import
+// does. Each input's parent directory is watched (never the file itself: an
+// editor's atomic save replaces the inode, which a file watch would lose)
+// and events are matched by name within that directory. On top of that, in
+// project mode, the whole assets/ tree: the manifest lists the tree, so any
+// change to it is a new version. While the last build failed the input list
+// is gone, so the source directory is watched as a whole until a build
+// succeeds again (the missing-import case: the file the build waits for is
+// not in any list yet). Every hit debounces into the one
+// rebuildAndBroadcast() path, which re-arms the watch from the new inputs.
+// Paused by the MCP pause_watch tool while an agent edits (state.watchPaused):
+// changes made meanwhile are not pushed; the agent's reload is.
+
+const DEBOUNCE_MS = 100
+const SOURCE_EXT = /\.(tsx?|jsx?)$/
+
+let offs: (() => void)[] = []
+let timer: ReturnType<typeof setTimeout> | null = null
+let changed = new Set<string>()
+let building = false
+let dirty = false
+
+function basename(path: string): string {
+  return path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1)
+}
+
+// A path with a dot component (below `root` when given) is never a source:
+// .srt-data in particular is this server's own output, and rebuilding on it
+// would rebuild forever. node_modules is the same in file mode, where the
+// source directory may be a project root.
+function isToolingPath(path: string, root: string): boolean {
+  let rel = path.startsWith(root) ? path.slice(root.length) : path
+  return rel.split(/[\\/]/).some((part) => part.startsWith(".") || part === "node_modules")
+}
+
+/** Arm the watch from a build's inputs; null (a failed build) watches the source tree as a whole. */
+export function armWatcher(inputs: string[] | null) {
+  stopWatcher()
+  let config = state.config
+  let hit = (path: string) => onChange(path)
+  try {
+    if (inputs) {
+      let byDir = new Map<string, Set<string>>()
+      for (let input of inputs) {
+        let parent = dirname(input)
+        let names = byDir.get(parent)
+        if (!names) byDir.set(parent, (names = new Set()))
+        names.add(basename(input))
+      }
+      for (let [parent, names] of byDir) {
+        offs.push(dir(parent).watch((e) => names.has(basename(e.path)) && hit(e.path)))
+      }
+    } else {
+      let root = config.sourceDir
+      offs.push(
+        dir(root).watch((e) => SOURCE_EXT.test(e.path) && !isToolingPath(e.path, root) && hit(e.path), { recursive: true }),
+      )
+    }
+    if (config.projectDir) {
+      let assets = `${config.projectDir}/assets`
+      dir(assets)
+        .exists()
+        .then((exists) => {
+          if (exists && offs.length) offs.push(dir(assets).watch((e) => !isToolingPath(e.path, assets) && hit(e.path), { recursive: true }))
+        })
+    }
+  } catch (e) {
+    console.error(`[cli] Watch failed: ${e instanceof Error ? e.message : e}`)
+    stopWatcher()
+  }
+}
+
+/** Drop every watch; the engine loop can go idle. */
+export function stopWatcher() {
+  for (let off of offs) off()
+  offs = []
+  if (timer !== null) clearTimeout(timer)
+  timer = null
+  changed.clear()
+}
+
+function onChange(path: string) {
+  if (state.watchPaused) return
+  changed.add(path)
+  if (building) {
+    dirty = true
+    return
+  }
+  if (timer !== null) clearTimeout(timer)
+  timer = setTimeout(() => void rebuild(), DEBOUNCE_MS)
+}
+
+// One rebuild per burst; a change that lands while the bundle runs queues
+// exactly one more, since the running build cannot have seen it.
+async function rebuild() {
+  timer = null
+  building = true
+  let root = state.config.projectDir ?? state.config.sourceDir
+  let names = [...changed].map((p) => (p.startsWith(root) ? p.slice(root.length + 1) : p))
+  changed.clear()
+  console.log(`[cli] Change detected: ${names.slice(0, 3).join(", ")}${names.length > 3 ? ` (+${names.length - 3})` : ""}`)
+  let error = await rebuildAndBroadcast()
+  if (error) {
+    console.error(error)
+    showBuildFailure()
+  }
+  building = false
+  if (dirty) {
+    dirty = false
+    onChange(names[0] ?? root)
+  }
+}

package/src/tool/main.ts

@@ -0,0 +1,70 @@
+import { readdirSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { source, toolArgs } from "../lib/args"
+
+// srt tool: the tools the installed @solidrt packages ship - build-time
+// helpers that belong to an extension, not to core (a model converter in
+// @solidrt/3d, say). Discovery is by convention, like demos: every
+// `<package>/tools/<name>.ts` is a tool named `<package>/<name>`, run with
+// bun in the caller's cwd with the arguments after the tool name passed
+// through untouched. srt knows nothing about what a tool does; a tool
+// prints its own usage.
+
+type Tool = { name: string; script: string }
+
+const SCOPE = join("node_modules", "@solidrt")
+
+/** Every tool installed here, sorted so the listing is stable. The cwd and
+ * nothing above it - the same rule demos follow, so this lists what THIS
+ * project installed. */
+function discover(): Tool[] {
+  let tools: Tool[] = []
+  for (let pkg of names(SCOPE)) {
+    let dir = join(SCOPE, pkg, "tools")
+    for (let file of names(dir)) {
+      if (!file.endsWith(".ts")) continue
+      tools.push({ name: `${pkg}/${file.slice(0, -".ts".length)}`, script: resolve(dir, file) })
+    }
+  }
+  return tools
+}
+
+// A missing folder is the normal case (most packages ship no tools), 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(tools: Tool[]) {
+  for (let tool of tools) console.log(`  ${tool.name}`)
+}
+
+export async function main(): Promise<void> {
+  let tools = discover()
+  if (tools.length === 0) {
+    console.error(`No tools installed in ${process.cwd()} (looked in ${SCOPE}/*/tools/)`)
+    process.exit(1)
+  }
+
+  if (source === undefined) {
+    list(tools)
+    console.log("\nRun one with: srt tool <pkg>/<name> [arguments]")
+    return
+  }
+
+  let picked = tools.find((t) => t.name === source)
+  if (!picked) {
+    console.error(`No such tool: ${source}`)
+    list(tools)
+    process.exit(1)
+  }
+
+  let proc = Bun.spawn([process.execPath, picked.script, ...toolArgs], {
+    stdio: ["inherit", "inherit", "inherit"],
+  })
+  process.exit(await proc.exited)
+}

package/src/types/bundle.d.ts

@@ -0,0 +1,24 @@
+// What `srt bundle --json` (src/bundle/main.ts, a bun subprocess of the
+// dev server) writes to stdout as one JSON object and the dev server
+// (src/server/rebuild.ts) reads back. src/types/ holds the type-only contracts
+// between the two programs: each has its own tsconfig (bun types on one
+// side, flux types on the other), both include this folder, so nothing here
+// may reference either runtime.
+
+export type BundleOutput = {
+  code: string
+  /** Composed sourcemap JSON (bundle -> original .tsx sources), dev builds only. */
+  map: string | null
+  /** Version manifest JSON for this bundle; clients install pushes under its hash. */
+  manifest: string
+  /** The app's isolate bundles, one per "use isolate" module, in id order; maps dev builds only. */
+  isolates: { id: string; code: string; map: string | null }[]
+  /**
+   * Every file this bundle was built from, absolute and sorted: the app's
+   * modules, the dependency modules bundled in, files inlined by import
+   * attribute, and the project's package.json / tsconfig.json. The assets/
+   * tree is not listed (the manifest carries it). What the dev server
+   * watches for reload-on-save.
+   */
+  inputs: string[]
+}

package/src/types/control.d.ts

@@ -0,0 +1,90 @@
+// The control API (/__control__/, server/control.ts) response shapes the
+// MCP bridge (src/mcp/main.ts) reads fields from. Only the server-held
+// answers are shaped here; queries forwarded to a client return whatever the
+// client runtime answers. See bundle.d.ts for the folder.
+
+export type ClientEntry = {
+  id: number
+  platform: string
+  /** The client runtime's version (git describe). */
+  version: string
+  /** Build profile: debug or release. */
+  profile: string
+  capabilities: string[]
+  /** Query kinds this client's runtime answers (empty on runtimes that predate
+   * the advertisement); dev tools plan their verification surface from it. */
+  queries: string[]
+  /** The client's storage tree on its own machine (`<data-root>/client<N>`
+   * for a dev client, the install folder for the launcher or a packed app),
+   * or null when it runs without writable storage or predates the field. */
+  clientDir: string | null
+  /** Whether its stats overlay is drawn (see POST /stats). */
+  stats: boolean
+  /** Its time scale as the client last reported it to POST /clock: 0 paused,
+   * 1 real time. Back to 1 on every push (a reload restarts the clock). */
+  timeScale: number
+  /** The client's process id on its own machine. */
+  pid: number | null
+  /** The runtime binary it runs. */
+  execPath: string | null
+  /** Its machine's hostname. */
+  host: string | null
+  /** The OS as a person names it ("Linux (Ubuntu 24.04)", "Android 15 on Pixel 9 Pro"). */
+  os: string | null
+  /** The kernel version. */
+  kernel: string | null
+  /** The SDL video driver ("wayland", "x11", "android", "offscreen", ...). */
+  videoDriver: string | null
+  /** The GPU strings as GL reports them; null on a client that connected
+   * before its GL context existed (a reconnect fills it in). */
+  gpu: GpuInfo | null
+}
+
+export type GpuInfo = { vendor: string; renderer: string; version: string }
+
+/** GET /clients */
+export type ClientsResponse = {
+  /** Identity of this server run: client ids and log cursors are only valid within one. */
+  generation: number
+  key: string
+  mode: "project" | "file"
+  entry: string
+  projectDir: string | null
+  /** Whether the user's own input is muted on every client (see /mute). */
+  userInputMuted: boolean
+  /** Whether reload-on-save is paused (see /watch). */
+  watchPaused: boolean
+  clients: ClientEntry[]
+}
+
+export type LogEntry = { seq: number; at: number; client: number; level: string; text: string }
+
+/** GET /logs */
+export type LogsResponse = {
+  /** Consecutive identical entries come back as one, with `repeats`. */
+  entries: (LogEntry & { repeats?: number })[]
+  /** The next `since` cursor. */
+  latest: number
+  generation: number
+}
+
+/** POST /reload */
+export type ReloadResponse = { ok: true; clients: number }
+
+/** POST /load: the canonical entry now served. */
+export type LoadResponse = { ok: true; entry: string; clients: number }
+
+/** POST /mute: the mute state now in force and the clients told. */
+export type MuteResponse = { ok: true; active: boolean; clients: number }
+
+/** POST /stats: whether the overlay is now on, and on how many clients. */
+export type StatsResponse = { ok: true; active: boolean; clients: number }
+
+/** POST /watch: whether reload-on-save is now active. */
+export type WatchResponse = { ok: true; active: boolean }
+
+/** GET /snapshot and /texture: png by default, RGBA8 bytes with format=raw. */
+export type ImageResponse = { width: number; height: number; pngBase64?: string; rgbaBase64?: string }
+
+/** Every non-2xx answer. */
+export type ControlError = { error: string }

package/src/types/registry.d.ts

@@ -0,0 +1,16 @@
+// The dev server registry record: ~/.solidrt/servers/<key hash>/live.json,
+// written by the server (server/registry.ts) and read by srt client, srt mcp
+// and the launcher (src/lib/registry.ts). See bundle.d.ts for the folder.
+
+export type LiveRecord = {
+  pid: number
+  port: number
+  address: string
+  /** The canonical project root or file path (see src/lib/mode.ts). */
+  key: string
+  mode: "project" | "file"
+  entry: string
+  projectDir: string | null
+  /** ISO timestamp of the bind. */
+  started: string
+}

package/scaffold/AGENTS.md

@@ -1,185 +0,0 @@
-# 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 frameworks 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.
-- Higher-level component frameworks build on core. @solidrt/components is
-  the first-party one: themed widgets (Window, View, Text, Button,
-  ScrollView, SafeArea, ...) with the `layout={{...}}`/`style={{...}}` prop
-  split. It is not privileged - a framework 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: if no component framework is among the
-dependencies, the app is core-only - do not add one for a change core
-covers.
-
-## 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)
-<!-- components:begin -->
-- build UI from the component vocabulary ->
-  node_modules/@solidrt/components/AGENTS.md, with full prop tables in its
-  README.md and single-concept usage in its examples/ (see that README index)
-<!-- components:end -->
-- 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
-- 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
-<!-- components:begin -->
-@./node_modules/@solidrt/components/AGENTS.md
-<!-- components:end -->
-@./node_modules/@solidrt/core/AGENTS.md
-@./node_modules/@solidrt/cli/AGENTS.md
-
-## The things assistants get wrong (this is not React/DOM)
-
-1. In a components-based app, most components split their props into two
-   objects: `layout={{...}}` for anything that feeds the layout engine
-   (flex/grid, sizing, padding/margin, position; font fields for Text), and
-   `style={{...}}` for paint-only properties that never relayout
-   (`backgroundColor`, `borderColor`, `borderWidth`, `borderRadius`, `color`,
-   and the transform `x`/`y`/`rotate`/`scale`). Event handlers
-   (`onPointerDown`, `onKeyDown`, ...) are top-level props, not inside
-   `layout`/`style`. Core intrinsics take these props flat instead - there
-   are no `layout`/`style` objects at that level.
-2. `render(() => <App/>)` once, top level. The root MUST be a `<Window>`
-   (from @solidrt/components) or the core `<window>` - it throws otherwise.
-3. Components' `Window`/`View` do not paint on their own; they only paint
-   when you set `style.backgroundColor`/`borderColor` etc - there is no
-   separate background element to place by hand. The core `<view>`/`<window>`
-   have no background prop at all: in a core-only app the background is a
-   draw-primitive child (`<d-rect color={...} />`) behind the content.
-4. There is no onClick/onPress on host elements: `onPointerDown` is how you
-   make something tappable. A components-based app gets `onPress` from
-   `Pressable`/`Button` on top of it.
-5. Reactive window state: prefer the accessors windowSize(), safeArea(),
-   displayScale(), windowFocused(), keyboardHeight(), pointerLocked()
-   (re-exported from @solidrt/core) over onResize/onLayout callbacks for
-   reading layout and window state. SafeArea (the component) is usually the
-   simpler fix for avoiding notches and system UI. For mouse look,
-   lockPointer(true) enters relative mouse mode (cursor hidden and confined,
-   positions freeze) and pointer events keep reporting motion through
-   movementX/movementY.
-6. Animation is target-shaped first: declare `transition` on the element and
-   write targets, and the runtime animates natively with no per-frame JS.
-   Reach for per-frame work only for genuinely procedural motion, where
-   onFrame((tick, frame) => {}) is the native hook (runtime-paced,
-   auto-cleans, re-exported from @solidrt/core); requestAnimationFrame
-   exists as a web-standard one-shot but is not the preferred driver. A JS
-   tween loop or an animation library pushing interpolated values through
-   signals is the single most expensive mistake available here - read
-   @solidrt/core/agents/performance.md before writing either.
-7. In a components-based app, reach for @solidrt/core directly only for what
-   components doesn't wrap: raw host intrinsics and the `d-` (detached,
-   non-layout) primitives like `d-rect`/`d-path`/`d-oval` for vector art or
-   perf-sensitive positioned drawing, device/GPU subpath imports
-   (@solidrt/core/camera, /microphone, /gpu), gradients
-   (createLinearGradient/createRadialGradient), and createImage/decodeImage
-   for images below the `Image` component's level. Components and core
-   primitives compose freely in the same tree - a components-based app can
-   drop to a `<d-path>` for one custom shape without giving up `View`/`Text`
-   everywhere else.
-8. tsconfig needs jsx:"preserve" + jsxImportSource:"@solidrt/core" (still
-   true even when you build almost entirely with @solidrt/components -
-   components are plain functions returning core JSX). Solid peer deps are
-   pinned betas - do not bump them casually.
-9. Use ASCII characters whenever possible in code and text - for example, no
-   em-dashes (use a hyphen), no smart/curly quotes, no unicode symbols.
-10. Prefer let over const. Use const only for real constants - a single fixed
-    string or number value - and name those in ALL_CAPS.
-11. 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 instead of updating
-    on change. `createEffect` takes two arguments now: `(compute, apply)`.
-    `compute` is the tracked read phase; `apply(value, prev)` runs untracked
-    and is where side effects/DOM-equivalent writes belong. The old
-    single-arg `createEffect(fn)` form is gone - using it is an error.
-12. A scroll container (ScrollView, or anything on createScroll) needs an
-    explicit main-axis size - a height, or flex inside a sized parent. With
-    neither it resolves to 0 and its content silently vanishes; maxHeight
-    alone does not size it (the auto size it would clamp is already 0). The
-    runtime warns when this happens.
-13. Text `lineHeight` is a MULTIPLIER of fontSize (the theme uses 1.3-1.6),
-    not pixels. A CSS-reflex value like 22 makes each line box 22x the font
-    size: the text becomes blank space and the parent balloons.
-14. Signal writes flush on a microtask: a handler that sets a signal and
-    immediately reads it back gets the OLD value. Read the new value in an
-    effect, or call `flush()` (from @solidjs/signals) to force it through.
-15. Portals cannot mount during the app's initial render: a Modal (or any
-    createPortal content) that is visible at first mount throws "no mount
-    target". Gate it behind a signal that starts false and open it after
-    startup - overlay content is opened, not born open.
-16. An element-valued prop (children, a content/icon slot) compiles to a
-    getter that builds a fresh native subtree on EVERY read, and a subtree
-    that is never inserted is never freed - native nodes are not garbage
-    collected, so what is only wasted work in DOM Solid is a permanent
-    memory leak here. Read such props exactly once, at the place they are
-    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.
-17. 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. Calling a loader/init function in
-    the component body that sets state is the classic React / Solid 1.x
-    reflex and hits this every time. Move the write into an event handler, an
-    effect's apply phase, or `onSettled`; opt in narrowly with
-    `createSignal(v, { ownedWrite: true })` for a signal that genuinely is
-    internal state.
-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.
-
-## Run / verify
-
-- FIRST check whether a dev server and a client are already running (the MCP
-  list_clients tool) and build 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.
-- The dev loop is edit -> reload -> get_logs -> get_snapshot. `reload`
-  surfaces build errors but not type errors; run `bunx srt check` for those.
-- 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:
-  writes nothing and never triggers a dev-server reload, so use this while
-  iterating - `srt bundle` writes output files and reloads connected clients
-- bunx srt render src/index.tsx --size 480x640 --duration 1 --fps 2 - headless
-  render to PNG frames (proves it renders; see the cli AGENTS.md for where the
-  frames land). The project's assets/ resolve exactly as under `srt run`, so
-  asset-dependent apps render headlessly too. It is also the ONLY way to see
-  the output of a window shader, which every MCP capture is blind to.
-- The project ships an MCP server (.mcp.json, `srt mcp`) that inspects and
-  drives the running app: logs, render tree, snapshots, GPU resources, stats,
-  synthetic input, a controllable clock. Each tool documents itself in full -
-  prefer them over guessing at runtime state, and read
-  node_modules/@solidrt/cli/agents/debugging.md before an investigation.

package/scaffold/package.json

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

package/scaffold/templates/components/icon.tsx

@@ -1,48 +0,0 @@
-// The animated SolidRT logo: each segment fades in, then out, on its own delay.
-import { For, onFrame, createSignal, createLinearGradient } from "@solidrt/core"
-
-const FADE = 360
-
-let SEGMENTS = [
-  { base: 0, light: "#3f5494", dark: "#162b6c", d: "M50.000 50.000 L28.330 50.000 C28.330 48.810 27.695 47.711 26.665 47.116 C25.635 46.521 24.365 46.521 23.335 47.116 C22.305 47.711 21.670 48.810 21.670 50.000 L0.000 50.000 L50.000 0.000 L50.000 9.170 C48.810 9.170 47.711 9.805 47.116 10.835 C46.521 11.865 46.521 13.135 47.116 14.165 C47.711 15.195 48.810 15.830 50.000 15.830 L50.000 25.000 L50.000 34.170 C48.810 34.170 47.711 34.805 47.116 35.835 C46.521 36.865 46.521 38.135 47.116 39.165 C47.711 40.195 48.810 40.830 50.000 40.830 L50.000 50.000 Z" },
-  { base: 90, light: "#547ebf", dark: "#2b5696", d: "M50.000 50.000 L50.000 59.170 C48.810 59.170 47.711 59.805 47.116 60.835 C46.521 61.865 46.521 63.135 47.116 64.165 C47.711 65.195 48.810 65.830 50.000 65.830 L50.000 75.000 L50.000 84.170 C48.810 84.170 47.711 84.805 47.116 85.835 C46.521 86.865 46.521 88.135 47.116 89.165 C47.711 90.195 48.810 90.830 50.000 90.830 L50.000 100.000 L0.000 50.000 L21.670 50.000 C21.670 48.810 22.305 47.711 23.335 47.116 C24.365 46.521 25.635 46.521 26.665 47.116 C27.695 47.711 28.330 48.810 28.330 50.000 L50.000 50.000 Z" },
-  { base: 180, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 25.000 L50.000 15.830 C48.810 15.830 47.711 15.195 47.116 14.165 C46.521 13.135 46.521 11.865 47.116 10.835 C47.711 9.805 48.810 9.170 50.000 9.170 L50.000 0.000 L75.000 25.000 L65.830 25.000 C65.830 26.190 65.195 27.289 64.165 27.884 C63.135 28.479 61.865 28.479 60.835 27.884 C59.805 27.289 59.170 26.190 59.170 25.000 L50.000 25.000 Z" },
-  { base: 270, light: "#547ebf", dark: "#2b5696", d: "M50.000 25.000 L59.170 25.000 C59.170 26.190 59.805 27.289 60.835 27.884 C61.865 28.479 63.135 28.479 64.165 27.884 C65.195 27.289 65.830 26.190 65.830 25.000 L75.000 25.000 L75.000 34.170 C73.810 34.170 72.711 34.805 72.116 35.835 C71.521 36.865 71.521 38.135 72.116 39.165 C72.711 40.195 73.810 40.830 75.000 40.830 L75.000 50.000 L65.830 50.000 C65.830 48.810 65.195 47.711 64.165 47.116 C63.135 46.521 61.865 46.521 60.835 47.116 C59.805 47.711 59.170 48.810 59.170 50.000 L50.000 50.000 L50.000 40.830 C48.810 40.830 47.711 40.195 47.116 39.165 C46.521 38.135 46.521 36.865 47.116 35.835 C47.711 34.805 48.810 34.170 50.000 34.170 L50.000 25.000 Z" },
-  { base: 360, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 50.000 L59.170 50.000 C59.170 48.810 59.805 47.711 60.835 47.116 C61.865 46.521 63.135 46.521 64.165 47.116 C65.195 47.711 65.830 48.810 65.830 50.000 L75.000 50.000 L64.855 60.145 C64.013 59.304 62.787 58.976 61.638 59.283 C60.489 59.591 59.591 60.489 59.283 61.638 C58.976 62.787 59.304 64.013 60.145 64.855 L50.000 75.000 L50.000 65.830 C48.810 65.830 47.711 65.195 47.116 64.165 C46.521 63.135 46.521 61.865 47.116 60.835 C47.711 59.805 48.810 59.170 50.000 59.170 L50.000 50.000 Z" },
-  { base: 450, light: "#3f5494", dark: "#162b6c", d: "M75.000 50.000 L75.000 59.170 C73.810 59.170 72.711 59.805 72.116 60.835 C71.521 61.865 71.521 63.135 72.116 64.165 C72.711 65.195 73.810 65.830 75.000 65.830 L75.000 75.000 L50.000 100.000 L50.000 90.830 C48.810 90.830 47.711 90.195 47.116 89.165 C46.521 88.135 46.521 86.865 47.116 85.835 C47.711 84.805 48.810 84.170 50.000 84.170 L50.000 75.000 L60.145 64.855 C59.304 64.013 58.976 62.787 59.283 61.638 C59.591 60.489 60.489 59.591 61.638 59.283 C62.787 58.976 64.013 59.304 64.855 60.145 L75.000 50.000 Z" },
-  { base: 540, light: "#7ea9ea", dark: "#5681c1", d: "M100.000 50.000 L75.000 75.000 L75.000 65.830 C73.810 65.830 72.711 65.195 72.116 64.165 C71.521 63.135 71.521 61.865 72.116 60.835 C72.711 59.805 73.810 59.170 75.000 59.170 L75.000 50.000 L75.000 40.830 C73.810 40.830 72.711 40.195 72.116 39.165 C71.521 38.135 71.521 36.865 72.116 35.835 C72.711 34.805 73.810 34.170 75.000 34.170 L75.000 25.000 L100.000 50.000 Z" },
-]
-
-let LAST = SEGMENTS[SEGMENTS.length - 1]!.base
-let IN_DONE = LAST + FADE
-let CYCLE = IN_DONE + LAST + FADE
-
-let clamp = (x: number) => (x < 0 ? 0 : x > 1 ? 1 : x)
-let ease = (t: number) => 1 - (1 - t) * (1 - t)
-let byte = (x: number) => Math.round(Math.max(0, Math.min(255, x))).toString(16).padStart(2, "0")
-
-let fill = (seg: (typeof SEGMENTS)[number], a: number) =>
-  createLinearGradient(0, 0, 1, 1, [
-    { offset: 0, color: seg.light + byte(a * 255) },
-    { offset: 1, color: seg.dark + byte(a * 255) },
-  ])
-
-export function Icon() {
-  let [clock, setClock] = createSignal(0)
-  let start = -1
-  onFrame((t) => (start < 0 && (start = t), setClock((t - start) % CYCLE)))
-  return (
-    <view width={300} height={300} viewBox={[100, 100]}>
-      <For each={SEGMENTS}>
-        {(seg) => {
-          let a = () => {
-            let t = clock(), end = IN_DONE + seg.base + FADE
-            if (t < seg.base || t >= end) return 0
-            return ease(Math.min(clamp((t - seg.base) / FADE), clamp((end - t) / FADE)))
-          }
-          return <d-path d={seg.d} color={fill(seg, a())} />
-        }}
-      </For>
-    </view>
-  )
-}

package/scaffold/templates/default/icon.tsx

@@ -1,48 +0,0 @@
-// The animated SolidRT logo: each segment fades in, then out, on its own delay.
-import { For, onFrame, createSignal, createLinearGradient } from "@solidrt/core"
-
-const FADE = 360
-
-let SEGMENTS = [
-  { base: 0, light: "#3f5494", dark: "#162b6c", d: "M50.000 50.000 L28.330 50.000 C28.330 48.810 27.695 47.711 26.665 47.116 C25.635 46.521 24.365 46.521 23.335 47.116 C22.305 47.711 21.670 48.810 21.670 50.000 L0.000 50.000 L50.000 0.000 L50.000 9.170 C48.810 9.170 47.711 9.805 47.116 10.835 C46.521 11.865 46.521 13.135 47.116 14.165 C47.711 15.195 48.810 15.830 50.000 15.830 L50.000 25.000 L50.000 34.170 C48.810 34.170 47.711 34.805 47.116 35.835 C46.521 36.865 46.521 38.135 47.116 39.165 C47.711 40.195 48.810 40.830 50.000 40.830 L50.000 50.000 Z" },
-  { base: 90, light: "#547ebf", dark: "#2b5696", d: "M50.000 50.000 L50.000 59.170 C48.810 59.170 47.711 59.805 47.116 60.835 C46.521 61.865 46.521 63.135 47.116 64.165 C47.711 65.195 48.810 65.830 50.000 65.830 L50.000 75.000 L50.000 84.170 C48.810 84.170 47.711 84.805 47.116 85.835 C46.521 86.865 46.521 88.135 47.116 89.165 C47.711 90.195 48.810 90.830 50.000 90.830 L50.000 100.000 L0.000 50.000 L21.670 50.000 C21.670 48.810 22.305 47.711 23.335 47.116 C24.365 46.521 25.635 46.521 26.665 47.116 C27.695 47.711 28.330 48.810 28.330 50.000 L50.000 50.000 Z" },
-  { base: 180, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 25.000 L50.000 15.830 C48.810 15.830 47.711 15.195 47.116 14.165 C46.521 13.135 46.521 11.865 47.116 10.835 C47.711 9.805 48.810 9.170 50.000 9.170 L50.000 0.000 L75.000 25.000 L65.830 25.000 C65.830 26.190 65.195 27.289 64.165 27.884 C63.135 28.479 61.865 28.479 60.835 27.884 C59.805 27.289 59.170 26.190 59.170 25.000 L50.000 25.000 Z" },
-  { base: 270, light: "#547ebf", dark: "#2b5696", d: "M50.000 25.000 L59.170 25.000 C59.170 26.190 59.805 27.289 60.835 27.884 C61.865 28.479 63.135 28.479 64.165 27.884 C65.195 27.289 65.830 26.190 65.830 25.000 L75.000 25.000 L75.000 34.170 C73.810 34.170 72.711 34.805 72.116 35.835 C71.521 36.865 71.521 38.135 72.116 39.165 C72.711 40.195 73.810 40.830 75.000 40.830 L75.000 50.000 L65.830 50.000 C65.830 48.810 65.195 47.711 64.165 47.116 C63.135 46.521 61.865 46.521 60.835 47.116 C59.805 47.711 59.170 48.810 59.170 50.000 L50.000 50.000 L50.000 40.830 C48.810 40.830 47.711 40.195 47.116 39.165 C46.521 38.135 46.521 36.865 47.116 35.835 C47.711 34.805 48.810 34.170 50.000 34.170 L50.000 25.000 Z" },
-  { base: 360, light: "#7ea9ea", dark: "#5681c1", d: "M50.000 50.000 L59.170 50.000 C59.170 48.810 59.805 47.711 60.835 47.116 C61.865 46.521 63.135 46.521 64.165 47.116 C65.195 47.711 65.830 48.810 65.830 50.000 L75.000 50.000 L64.855 60.145 C64.013 59.304 62.787 58.976 61.638 59.283 C60.489 59.591 59.591 60.489 59.283 61.638 C58.976 62.787 59.304 64.013 60.145 64.855 L50.000 75.000 L50.000 65.830 C48.810 65.830 47.711 65.195 47.116 64.165 C46.521 63.135 46.521 61.865 47.116 60.835 C47.711 59.805 48.810 59.170 50.000 59.170 L50.000 50.000 Z" },
-  { base: 450, light: "#3f5494", dark: "#162b6c", d: "M75.000 50.000 L75.000 59.170 C73.810 59.170 72.711 59.805 72.116 60.835 C71.521 61.865 71.521 63.135 72.116 64.165 C72.711 65.195 73.810 65.830 75.000 65.830 L75.000 75.000 L50.000 100.000 L50.000 90.830 C48.810 90.830 47.711 90.195 47.116 89.165 C46.521 88.135 46.521 86.865 47.116 85.835 C47.711 84.805 48.810 84.170 50.000 84.170 L50.000 75.000 L60.145 64.855 C59.304 64.013 58.976 62.787 59.283 61.638 C59.591 60.489 60.489 59.591 61.638 59.283 C62.787 58.976 64.013 59.304 64.855 60.145 L75.000 50.000 Z" },
-  { base: 540, light: "#7ea9ea", dark: "#5681c1", d: "M100.000 50.000 L75.000 75.000 L75.000 65.830 C73.810 65.830 72.711 65.195 72.116 64.165 C71.521 63.135 71.521 61.865 72.116 60.835 C72.711 59.805 73.810 59.170 75.000 59.170 L75.000 50.000 L75.000 40.830 C73.810 40.830 72.711 40.195 72.116 39.165 C71.521 38.135 71.521 36.865 72.116 35.835 C72.711 34.805 73.810 34.170 75.000 34.170 L75.000 25.000 L100.000 50.000 Z" },
-]
-
-let LAST = SEGMENTS[SEGMENTS.length - 1]!.base
-let IN_DONE = LAST + FADE
-let CYCLE = IN_DONE + LAST + FADE
-
-let clamp = (x: number) => (x < 0 ? 0 : x > 1 ? 1 : x)
-let ease = (t: number) => 1 - (1 - t) * (1 - t)
-let byte = (x: number) => Math.round(Math.max(0, Math.min(255, x))).toString(16).padStart(2, "0")
-
-let fill = (seg: (typeof SEGMENTS)[number], a: number) =>
-  createLinearGradient(0, 0, 1, 1, [
-    { offset: 0, color: seg.light + byte(a * 255) },
-    { offset: 1, color: seg.dark + byte(a * 255) },
-  ])
-
-export function Icon() {
-  let [clock, setClock] = createSignal(0)
-  let start = -1
-  onFrame((t) => (start < 0 && (start = t), setClock((t - start) % CYCLE)))
-  return (
-    <view width={300} height={300} viewBox={[100, 100]}>
-      <For each={SEGMENTS}>
-        {(seg) => {
-          let a = () => {
-            let t = clock(), end = IN_DONE + seg.base + FADE
-            if (t < seg.base || t >= end) return 0
-            return ease(Math.min(clamp((t - seg.base) / FADE), clamp((end - t) / FADE)))
-          }
-          return <d-path d={seg.d} color={fill(seg, a())} />
-        }}
-      </For>
-    </view>
-  )
-}