rsc-universal 0.1.1

package/skills/solid-js/SKILL.md

@@ -0,0 +1,260 @@
+---
+name: solid-js
+description: "Use when building, reviewing, or debugging a SolidJS app — signals, stores, effects, memos, resources, and JSX that compiles to real DOM with no virtual DOM (solid-js 1.9.x stable, Solid 2.0 beta, @solidjs/router). Triggers: \"signal isn't updating the UI\", \"<For> vs <Index>\", \"createStore for a form\", \"createEffect infinite loop\", \"why does my component only run once\", \"el prop no es reactiu quan el desestructuro\", \"mi prop no se actualiza al desestructurar\". NOT React's re-render model (that is react)."
+tags: [solidjs, signals, reactivity, frontend, jsx, web]
+recommends: [vercel, testing-web, design]
+origin: risco
+---
+
+# SolidJS — fine-grained reactivity, no VDOM
+
+One rule governs everything else: **the component function runs ONCE.** Reactivity does not live in re-running the body — it lives in the *reads*. You read state by calling a getter (`count()`), and Solid re-runs only the exact DOM expression or effect that read it. There is no virtual DOM and no reconciliation; JSX compiles straight to DOM nodes. If you carry React habits here (destructuring props, expecting the body to re-run, deriving state in an effect), reactivity breaks silently — the code runs, it just stops updating.
+
+Versions: **stable is `solid-js` 1.9.x** (1.9.11/1.9.13 line). **Solid 2.0 is in beta on the `next` npm tag** with a new reactive core (`@solidjs/signals`), `createAsync`, and automatic batching. Default to 1.9.x APIs unless the task says 2.0; flag the divergence where it matters.
+
+## When to use / when not
+
+| Situation | Skill |
+|---|---|
+| Solid signals/stores/effects/memos/resources, JSX-to-DOM, `<For>`/`<Index>` | **this skill** |
+| React `useState`/hooks/re-render model (the body re-runs) | `react` |
+| Next.js routing, server actions, RSC | `nextjs` |
+| Svelte 5 `$state`/`$derived` runes (similar look, different compiler) | `svelte` |
+| Vue/Nuxt `ref`/`reactive`/`computed` | `vue-nuxt` |
+| Astro island architecture / what ships to the client (can host a Solid island) | `astro` |
+| Plain TypeScript questions with no Solid surface | [`../typescript/SKILL.md`](../typescript/SKILL.md) |
+| Deploying the built app (Vercel/SolidStart adapter) | [`../vercel/SKILL.md`](../vercel/SKILL.md) |
+
+## The mental-model shift (read this first)
+
+React re-runs the component body on every state change; Solid runs it once and re-runs only the tracked reads. So the value is the *call*, not the variable.
+
+```tsx
+// Bad — React reflex: treats `count` as a value, body assumed to re-run.
+function Counter() {
+  const [count, setCount] = createSignal(0);
+  console.log("body ran");        // prints ONCE, ever
+  return <button onClick={() => setCount(count + 1)}>{count}</button>;
+  //                                          ^ NaN: count is the getter fn, not a number
+}
+
+// Good — read by calling the getter; the JSX read is what re-runs.
+function Counter() {
+  const [count, setCount] = createSignal(0);
+  return <button onClick={() => setCount((c) => c + 1)}>{count()}</button>;
+  //                                                      ^ tracked read
+}
+```
+
+Why: the body is setup that runs once. Only getter reads inside JSX, effects, or memos are tracked and re-executed. `count` is the accessor function; `count()` is its current value.
+
+## Signals — single reactive values
+
+`createSignal(initial)` returns `[getter, setter]`. Read with `getter()`, write with `setter(next)` or `setter(prev => next)`.
+
+```tsx
+const [name, setName] = createSignal("Ada");
+setName("Grace");          // replace
+setName((n) => n + "!");   // update from previous
+```
+
+Derived state is just a function — no API needed:
+
+```tsx
+const [first, setFirst] = createSignal("Ada");
+const [last, setLast]  = createSignal("Lovelace");
+const fullName = () => `${first()} ${last()}`;   // re-reads on access, always fresh
+```
+
+Reach for `createMemo` only when the computation is **expensive or shared by many readers** — it caches and re-runs only when its dependencies change:
+
+```tsx
+const sorted = createMemo(() => [...items()].sort(byName));  // expensive: memoize
+```
+
+Rule: derive with a plain `() => …` by default; promote to `createMemo` for cost/sharing. Why: a memo adds a reactive node; a plain function is free and recomputes lazily on read.
+
+## Props — the destructuring trap
+
+Props are a reactive proxy. Destructuring or assigning `.x` reads the value **once at run-once time**, freezing it.
+
+```tsx
+// Bad — both snapshot a dead value; updates from the parent never arrive.
+function Hi(props) { const { name } = props; return <p>{name}</p>; }
+function Hi(props) { const name = props.name; return <p>{name}</p>; }
+
+// Good — read inline, or wrap in an accessor to pass reactivity along.
+function Hi(props) { return <p>{props.name}</p>; }
+function Hi(props) { const name = () => props.name; return <p>{name()}</p>; }
+```
+
+To split or default props while keeping reactivity, use `splitProps` / `mergeProps` — never the spread/destructure idiom:
+
+```tsx
+import { splitProps, mergeProps } from "solid-js";
+
+function Button(props) {
+  const merged = mergeProps({ variant: "primary" }, props);   // reactive defaults
+  const [local, rest] = splitProps(merged, ["variant", "children"]);
+  return <button class={local.variant} {...rest}>{local.children}</button>;
+}
+```
+
+Why: `splitProps`/`mergeProps` return proxies that preserve getter tracking; `{ ...props }` and `const { x } = props` collapse it to a one-time copy.
+
+## Stores — nested object / array state
+
+`createSignal` is for one value. Use `createStore` for nested objects or arrays so updates are **fine-grained per path** (only the components reading the changed leaf re-run), with no cloning of the whole tree.
+
+```tsx
+import { createStore, produce } from "solid-js/store";
+
+const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
+
+setState("user", "name", "Grace");               // path update — only name readers re-run
+setState("todos", (t) => [...t, { id: 1, done: false }]); // append
+setState("todos", 0, "done", true);              // update one item field by index
+setState(produce((s) => { s.todos[0].done = true; }));    // mutate-style, still fine-grained
+```
+
+```tsx
+// Bad — replacing the whole object kills path-level reactivity and re-renders everything.
+setState({ user: { name: "Grace" }, todos: state.todos });
+
+// Good — target the path that changed.
+setState("user", "name", "Grace");
+```
+
+Why: stores diff at the path you touch; whole-object replacement is a single coarse change that defeats the entire point of a store.
+
+## Effects & lifecycle — side effects only
+
+`createEffect` runs **after render** and re-runs when any signal it reads changes. It is for *side effects* (DOM, logging, subscriptions, network) — not for computing state.
+
+```tsx
+createEffect(() => {
+  document.title = `Count: ${count()}`;   // side effect, tracks count()
+});
+
+onMount(() => {                            // runs once after first render
+  const id = setInterval(tick, 1000);
+  onCleanup(() => clearInterval(id));      // before re-run AND on disposal
+});
+
+batch(() => { setA(1); setB(2); });        // one update pass instead of two (1.x; auto in 2.0)
+const snapshot = untrack(() => raw());     // read without subscribing
+```
+
+The signature anti-pattern — deriving state by writing a signal inside an effect — causes an infinite loop and is the most common "Solid is broken" report:
+
+```tsx
+// Bad — effect reads total(), writes total → re-triggers itself forever.
+const [total, setTotal] = createSignal(0);
+createEffect(() => setTotal(price() * qty()));
+
+// Good — derive, don't store.
+const total = createMemo(() => price() * qty());   // or: const total = () => price() * qty();
+```
+
+Why: an effect that writes one of its own dependencies is a feedback loop. Derived values are reads, not writes.
+
+## Control flow — use Solid's primitives, not raw JS
+
+Early `return`, bare `&&`, and `.map()` defeat tracking or leak falsy values. Use the components, which Solid can track and dispose precisely.
+
+```tsx
+<Show when={user()} fallback={<Login />}>{(u) => <Profile user={u()} />}</Show>
+<Switch fallback={<NotFound />}>
+  <Match when={state() === "loading"}><Spinner /></Match>
+  <Match when={state() === "ready"}><Data /></Match>
+</Switch>
+<Dynamic component={tagFor(kind())} {...props} />
+```
+
+`<For>` vs `<Index>` is a real decision:
+
+| Your list is… | Use | Why |
+|---|---|---|
+| Keyed objects that reorder/insert/remove | `<For each={items()}>{(item) => …}</For>` | keys by reference; DOM nodes **move**, not rebuild |
+| Fixed-position rows, primitives, or inputs bound to the index | `<Index each={items()}>{(item) => … item() …}</Index>` | keys by position; `item` is an **accessor** (`item()`) |
+
+```tsx
+// Bad — <For> with index-bound inputs: nodes move on reorder, inputs desync.
+<For each={fields()}>{(f, i) => <input value={f.value} onInput={(e) => setField(i(), e)} />}</For>
+
+// Good — <Index> when the position is the identity.
+<Index each={fields()}>{(f, i) => <input value={f().value} onInput={(e) => setField(i, e)} />}</Index>
+```
+
+Why: `<For>` tracks *which value* lives where (great for keyed data); `<Index>` tracks *what's at slot N* (great for fixed slots). Picking wrong rebuilds or desyncs nodes.
+
+## Async — resources + Suspense
+
+In **1.x** use `createResource`; in **2.0** the standard primitive is `createAsync`. Both surface loading/error through `<Suspense>` and `<ErrorBoundary>`.
+
+```tsx
+// 1.x
+const [user] = createResource(userId, (id) => fetchUser(id));   // refetches when userId() changes
+
+<ErrorBoundary fallback={(err) => <p>Failed: {err.message}</p>}>
+  <Suspense fallback={<Spinner />}>
+    <p>{user()?.name}</p>
+  </Suspense>
+</ErrorBoundary>
+```
+
+The 1.9→2.0 async migration (`createAsync`, automatic batching, `@solidjs/signals`) lives in [references/reactivity-deep-dive.md](references/reactivity-deep-dive.md).
+
+## Project setup
+
+```bash
+npm create vite@latest my-app -- --template solid-ts   # Vite + vite-plugin-solid + TS
+cd my-app && npm install && npm run dev
+```
+
+Routing with `@solidjs/router`:
+
+```tsx
+import { Router, Route, A } from "@solidjs/router";
+
+function App() {
+  return (
+    <Router>
+      <Route path="/" component={Home} />
+      <Route path="/users/:id" component={UserPage} />
+    </Router>
+  );
+}
+// inside UserPage: const params = useParams(); params.id  (reactive)
+// nav links use <A href="…"> (not raw <a>) for client-side routing
+```
+
+For SSR, file-based routing, and server functions (`"use server"`, `query`/`action`), reach for **SolidStart** (1.x stable; 2.0.0-alpha tracks Solid 2.0). The full router + SolidStart map is in [references/router-and-start.md](references/router-and-start.md). Deploying the build → [`../vercel/SKILL.md`](../vercel/SKILL.md).
+
+## Anti-patterns
+
+| Anti-pattern | Why it breaks | Do instead |
+|---|---|---|
+| `const { x } = props` / `const x = props.x` | snapshots a non-reactive value at run-once | read `props.x` inline or `const x = () => props.x` |
+| Reading `count` instead of `count()` | passes the accessor function, not the value | call it: `count()` |
+| Expecting the component body to re-run | it runs once; only tracked reads re-run | move reactive work into JSX / effect / memo |
+| Deriving state via `createEffect` that sets a signal | feedback loop / stale order | `createMemo` or a plain `() => …` |
+| `<For>` for index-bound inputs | nodes move on reorder, inputs desync | `<Index>` (keyed by position, `item()`) |
+| `setStore(wholeNewObject)` | one coarse change defeats fine-grained paths | `setStore("path", …, value)` / `produce` |
+| Early `return null` / `cond && <X/>` for conditionals | leaks falsy values, escapes tracking | `<Show when={…} fallback={…}>` / `<Switch>` |
+| `{...props}` to forward reactively | spread copies once, drops getters | `splitProps` / `mergeProps` |
+
+## Verify
+
+If the project emits Solid components/JSX/config, run the gate:
+
+```bash
+bash scripts/verify.sh
+```
+
+It detects the package runner from the lockfile, then runs `tsc --noEmit` → ESLint → Vitest → `vite build`. Missing tools are SKIPPED (yellow), not failed; it exits non-zero only on a real failure.
+
+## References
+
+- [references/reactivity-deep-dive.md](references/reactivity-deep-dive.md) — ownership & disposal, `createRoot`/`getOwner`/`runWithOwner`, `on()` explicit deps, `createComputed`/`createRenderEffect`, `createSelector`, store `reconcile`/`produce`, and the 1.9→2.0 migration.
+- [references/router-and-start.md](references/router-and-start.md) — full `@solidjs/router` surface (params, data loading, navigation, nested layouts) and a concise SolidStart 1.x map.

package/skills/solid-js/evals/README.md

@@ -0,0 +1,3 @@
+# solid-js evals
+
+Trigger and capability checks for SolidJS reactivity work.

package/skills/solid-js/evals/cases.yaml

@@ -0,0 +1,38 @@
+skill: solid-js
+
+should_trigger:
+  - prompt: "My SolidJS signal is not updating the UI."
+    why: "Signal reads/writes and UI tracking are core SolidJS."
+  - prompt: "Should I use <For> or <Index> for this Solid list?"
+    why: "Solid list control flow choice belongs here."
+  - prompt: "createEffect is looping forever in my Solid component."
+    why: "Solid effects and dependency tracking are specific to this skill."
+  - prompt: "Why does my Solid component body only run once?"
+    why: "Solid's run-once component model is the central mental model."
+  - prompt: "Mi prop no se actualiza al desestructurar en Solid."
+    why: "Spanish props destructuring/reactivity trap triggers SolidJS."
+
+should_not_trigger:
+  - prompt: "Fix this React hook dependency array."
+    route_to: "react"
+    why: "React hook/re-render model is not Solid."
+  - prompt: "Implement a Next.js server action."
+    route_to: "nextjs"
+    why: "Next.js App Router/RSC belongs to nextjs."
+  - prompt: "Migrate this Svelte 4 component to Svelte 5 runes."
+    route_to: "svelte"
+    why: "Svelte runes are a different compiler/reactivity model."
+  - prompt: "Deploy this frontend to Vercel."
+    route_to: "vercel"
+    why: "Deployment target specifics belong to Vercel/deployment."
+
+capability:
+  - scenario: "A SolidJS component destructures props, uses count instead of count(), and has a createEffect that derives state."
+    must_include:
+      - "Explains that Solid component functions run once and tracked getter reads drive updates."
+      - "Reads signals with count() and writes with the setter/updater form."
+      - "Avoids destructuring reactive props in a way that freezes values."
+      - "Uses plain derived functions or createMemo for derived values instead of effect-set-state."
+      - "Chooses <For> vs <Index> based on item identity/stability."
+      - "Keeps React mental-model advice out of Solid code."
+      - "Flags Solid 2.0 beta vs stable 1.9 API differences when relevant."

package/skills/solid-js/references/reactivity-deep-dive.md

@@ -0,0 +1,89 @@
+# Reactivity deep dive
+
+Depth most tasks won't need inline. Read this when ownership, disposal, explicit
+dependencies, or the 1.9→2.0 migration is actually in play.
+
+## Ownership & disposal
+
+Every reactive computation runs inside an **owner**. When the owner is disposed,
+its children, effects, and `onCleanup` callbacks are torn down. Components create
+owners automatically; outside a component you must establish one.
+
+```tsx
+import { createRoot, getOwner, runWithOwner } from "solid-js";
+
+// Run reactive code outside a component and get an explicit dispose handle.
+const dispose = createRoot((dispose) => {
+  createEffect(() => console.log(count()));
+  return dispose;
+});
+dispose();   // tears down the effect
+
+// Capture the current owner to re-enter it later (e.g. after an await).
+const owner = getOwner();
+queueMicrotask(() => runWithOwner(owner, () => createEffect(() => …)));
+```
+
+Why it matters: an effect created without an owner (or after an `await` that lost
+the owner) never gets cleaned up — a memory/subscription leak. If `onCleanup`
+doesn't fire, an owner boundary is the first thing to check.
+
+## Explicit dependencies with `on()`
+
+`createEffect`/`createMemo` track every read by default. Use `on()` to depend on
+specific signals and optionally defer the first run.
+
+```tsx
+import { on } from "solid-js";
+
+createEffect(on(userId, (id) => fetchUser(id), { defer: true }));
+// runs only when userId() changes, skips the initial run
+```
+
+## Effect variants
+
+| Primitive | When it runs | Use for |
+|---|---|---|
+| `createEffect` | after render (queued) | DOM side effects, subscriptions, network |
+| `createRenderEffect` | during render, before paint | measuring/writing the DOM before it shows |
+| `createComputed` | synchronously, eagerly | low-level chained computations (rare; prefer `createMemo`) |
+
+Prefer `createMemo` for derived values. `createComputed` is eager and easy to
+misuse — reach for it only when ordering before paint truly requires it.
+
+## `createSelector`
+
+For "which item is selected?" across a large list, `createSelector` makes
+selection O(1) per item instead of O(n) re-checks.
+
+```tsx
+const isSelected = createSelector(selectedId);
+<For each={items()}>{(item) => <Row active={isSelected(item.id)} />}</For>
+```
+
+## Store helpers: `produce` and `reconcile`
+
+```tsx
+import { produce, reconcile } from "solid-js/store";
+
+setState(produce((s) => { s.todos.push(newTodo); }));   // mutable-style writes, fine-grained
+setState("todos", reconcile(serverTodos));              // diff incoming data, keep stable refs
+```
+
+`reconcile` is the right tool after fetching fresh server data into an existing
+store: it diffs and patches in place rather than replacing the array, so node
+identity (and focus/scroll) survives.
+
+## 1.9 → 2.0 migration notes
+
+Solid 2.0 (beta, `next` npm tag) keeps the same authoring feel but changes the
+foundation:
+
+- New reactive core extracted to **`@solidjs/signals`**.
+- **`createAsync`** becomes the standard async primitive (over `createResource`),
+  paired with `<Suspense>`/`<ErrorBoundary>`; supports concurrent transitions.
+- **Automatic batching** — explicit `batch()` is largely unnecessary.
+- Immutable, diffable stores; self-healing error boundaries.
+
+Default to 1.9.x APIs for production work. Adopt 2.0 only when the task targets it,
+and pin the `next` tag explicitly. SolidStart 2.0.0-alpha tracks Solid 2.0.

package/skills/solid-js/references/router-and-start.md

@@ -0,0 +1,93 @@
+# @solidjs/router & SolidStart
+
+## @solidjs/router
+
+The official router. Routes are components; params and location are reactive.
+
+```tsx
+import { Router, Route, A, useParams, useNavigate, useSearchParams } from "@solidjs/router";
+
+function App() {
+  return (
+    <Router root={Layout}>
+      <Route path="/" component={Home} />
+      <Route path="/users/:id" component={UserPage} />
+      <Route path="/users/:id/posts/:postId" component={Post} />
+      <Route path="*404" component={NotFound} />
+    </Router>
+  );
+}
+```
+
+Reactive params and navigation:
+
+```tsx
+const params = useParams();          // params.id is reactive — read it inside JSX/effects
+const navigate = useNavigate();
+navigate(`/users/${id}`, { replace: true });
+const [search, setSearch] = useSearchParams();
+setSearch({ page: "2" });
+```
+
+Always use `<A href="…">` for in-app links (client-side navigation, active class
+support). A raw `<a>` triggers a full page reload.
+
+### Data loading
+
+`@solidjs/router` exposes a `load` function per route plus `query` for cached,
+dedup'd reads. The loader runs before/parallel to rendering so data is ready when
+the component mounts.
+
+```tsx
+import { query, createAsync } from "@solidjs/router";
+
+const getUser = query(async (id: string) => fetchUser(id), "user");
+
+function UserPage() {
+  const params = useParams();
+  const user = createAsync(() => getUser(params.id));   // suspends until resolved
+  return <Suspense fallback={<Spinner />}><h1>{user()?.name}</h1></Suspense>;
+}
+```
+
+Nested layouts: a parent `<Route>` with a `component` that renders `props.children`
+wraps its child routes; the `root` prop on `<Router>` is the app-wide shell.
+
+## SolidStart (1.x stable)
+
+The meta-framework on top of Solid + `@solidjs/router` + Vite. Use it for SSR,
+file-based routing, and server functions. This skill is reactivity-first — SolidStart
+is the SSR/routing host, not the center of gravity.
+
+- **File routing**: files under `src/routes/` map to URLs. `src/routes/users/[id].tsx`
+  → `/users/:id`. `(group)` folders organize without affecting the path.
+- **Server functions**: a function marked `"use server"` runs only on the server;
+  the client calls it over RPC. Compose with router `query`/`action` for reads/mutations.
+
+```tsx
+// src/routes/todos.tsx
+import { query, action, createAsync, useAction } from "@solidjs/router";
+
+const getTodos = query(async () => {
+  "use server";
+  return db.todo.findMany();
+}, "todos");
+
+const addTodo = action(async (formData: FormData) => {
+  "use server";
+  await db.todo.create({ data: { title: String(formData.get("title")) } });
+}, "addTodo");
+
+export default function Todos() {
+  const todos = createAsync(() => getTodos());
+  const add = useAction(addTodo);
+  // render with <Suspense>, submit via a <form action={addTodo}> or add(formData)
+}
+```
+
+- **Deployment**: SolidStart uses Nitro-style adapters; for Vercel/Netlify/Node
+  targets configure the adapter in `app.config.ts`. Deployment specifics →
+  [`../vercel/SKILL.md`](../vercel/SKILL.md).
+
+Version note: SolidStart 1.x is the maintained stable line; **2.0.0-alpha** tracks
+Solid 2.0. Default to 1.x unless the task targets the alpha.

package/skills/solid-js/scripts/verify.sh

@@ -0,0 +1,130 @@
+#!/usr/bin/env bash
+# verify.sh — SolidJS project gate.
+#
+# Usage:
+#   bash scripts/verify.sh            # run from the Solid project root
+#
+# What it does (in order): tsc --noEmit -> ESLint -> Vitest -> vite build.
+# Each tool is detected; if it is not installed/resolvable, it is skipped with a
+# yellow warning (NOT a failure). Exits non-zero only on a real tool failure.
+# On an empty or non-Solid directory every step SKIPs and it exits 0.
+#
+# Side effects: type-check / lint / test are read-only. The final `vite build`
+# WRITES the `dist/` output directory — it is not a pure read-only step. It
+# performs no installs and no network mutations. Safe to re-run.
+#
+# Portability: targets stock macOS bash 3.2. We avoid `mapfile`, never expand a
+# possibly-empty array under `set -u`, and degrade gracefully when a tool is
+# missing. `set -e` is intentionally NOT used (each check handles its own exit
+# code); `set -u` is on.
+
+set -u
+
+# --- colors (only when stdout is a TTY) -----------------------------------
+if [ -t 1 ] && command -v tput >/dev/null 2>&1; then
+  RED="$(tput setaf 1)"; GREEN="$(tput setaf 2)"; YELLOW="$(tput setaf 3)"; RESET="$(tput sgr0)"
+else
+  RED=""; GREEN=""; YELLOW=""; RESET=""
+fi
+
+failures=0
+skips=""
+
+have() { command -v "$1" >/dev/null 2>&1; }
+warn() { printf '%s\n' "${YELLOW}SKIP: $1${RESET}"; skips="${skips}${skips:+ }$2"; return 0; }
+fail() { printf '%s\n' "${RED}FAIL: $1${RESET}"; failures=$((failures + 1)); }
+ok()   { printf '%s\n' "${GREEN}OK: $1${RESET}"; }
+
+# --- resolve a package runner from the lockfile ----------------------------
+RUN=""
+if [ -f pnpm-lock.yaml ] && have pnpm; then
+  RUN="pnpm exec"
+elif [ -f yarn.lock ] && have yarn; then
+  RUN="yarn"
+elif [ -f bun.lockb ] && have bun; then
+  RUN="bunx"
+elif [ -f package-lock.json ] && have npm; then
+  RUN="npm exec --"
+elif have npx; then
+  RUN="npx --no-install"
+fi
+
+run_bin() {
+  # run_bin <bin-name> <args...> : true if the bin is resolvable and runs
+  bin="$1"; shift
+  if have "$bin"; then "$bin" "$@"; return $?; fi
+  if [ -x "node_modules/.bin/$bin" ]; then "node_modules/.bin/$bin" "$@"; return $?; fi
+  if [ -n "$RUN" ]; then $RUN "$bin" "$@"; return $?; fi
+  return 127
+}
+
+bin_available() {
+  bin="$1"
+  have "$bin" && return 0
+  [ -x "node_modules/.bin/$bin" ] && return 0
+  return 1
+}
+
+# --- 1. TypeScript ---------------------------------------------------------
+if bin_available tsc && [ -f tsconfig.json ]; then
+  printf '%s\n' "Running tsc --noEmit..."
+  if run_bin tsc --noEmit; then ok "tsc --noEmit"; else fail "tsc --noEmit"; fi
+else
+  warn "tsc or tsconfig.json missing — skipping type check" "tsc"
+fi
+
+# --- 2. ESLint -------------------------------------------------------------
+# Solid projects typically use eslint-plugin-solid. We run eslint only if it is
+# resolvable AND an eslint config exists; otherwise SKIP (never FAIL).
+has_eslint_config=false
+if ls .eslintrc .eslintrc.* eslint.config.* >/dev/null 2>&1; then
+  has_eslint_config=true
+fi
+if bin_available eslint && [ "$has_eslint_config" = true ]; then
+  printf '%s\n' "Running ESLint..."
+  if run_bin eslint .; then ok "eslint"; else fail "eslint"; fi
+else
+  warn "eslint or its config not resolvable — skipping lint" "eslint"
+fi
+
+# --- 3. Vitest -------------------------------------------------------------
+# Treat the repo as having Vitest unit tests when a vitest config exists OR
+# *.test.* files exist.
+has_tests=false
+if ls vitest.config.* vitest.workspace.* >/dev/null 2>&1; then
+  has_tests=true
+elif find . \( -name node_modules -o -name dist -o -name .solid \) -prune -o \
+       -name '*.test.*' -print 2>/dev/null | grep -q .; then
+  has_tests=true
+fi
+if bin_available vitest && [ "$has_tests" = true ]; then
+  printf '%s\n' "Running vitest run..."
+  if run_bin vitest run; then ok "vitest"; else fail "vitest"; fi
+else
+  warn "vitest or unit tests (vitest.config.* / *.test.*) not present — skipping unit tests" "vitest"
+fi
+
+# --- 4. vite build (slow; WRITES dist/; run last) --------------------------
+# Only attempt a build when this looks like a Vite project (vite config present).
+has_vite_config=false
+if ls vite.config.* >/dev/null 2>&1; then
+  has_vite_config=true
+fi
+if bin_available vite && [ "$has_vite_config" = true ]; then
+  printf '%s\n' "Running vite build... (writes dist/)"
+  if run_bin vite build; then ok "vite build"; else fail "vite build"; fi
+else
+  warn "vite or vite.config.* not present — skipping build" "vite build"
+fi
+
+# --- summary ---------------------------------------------------------------
+printf '\n'
+if [ -n "$skips" ]; then
+  printf '%s\n' "${YELLOW}skipped: ${skips}${RESET}"
+fi
+if [ "$failures" -gt 0 ]; then
+  printf '%s\n' "${RED}verify.sh: $failures check(s) failed${RESET}"
+  exit 1
+fi
+printf '%s\n' "${GREEN}verify.sh: all runnable checks passed${RESET}"
+exit 0