solid2-agent-kit 0.23.1 → 0.25.0

package/bin/baseline.mjs

@@ -19,14 +19,14 @@
 // pulls them in — so doctor also checks an undeclared install of any package
 // here, which is where a lockfile holds an older compiler.
 export const BASELINE = {
-  'solid-js': { line: 2, baseline: '2.0.0-rc.17' },
-  '@solidjs/web': { line: 2, baseline: '2.0.0-rc.17' },
-  '@solidjs/signals': { line: 2, baseline: '2.0.0-rc.17' },
-  '@solidjs/diagnostics': { line: 2, baseline: '2.0.0-rc.17' },
-  '@solidjs/compiler': { line: 2, baseline: '2.0.0-rc.17' },
-  '@solidjs/babel-plugin': { line: 2, baseline: '2.0.0-rc.17' },
-  '@solidjs/router': { line: 2, baseline: '2.0.0-next.42' },
-  '@solidjs/vite-plugin': { line: 3, baseline: '3.0.0-next.51' },
+  'solid-js': { line: 2, baseline: '2.0.0-rc.21' },
+  '@solidjs/web': { line: 2, baseline: '2.0.0-rc.21' },
+  '@solidjs/signals': { line: 2, baseline: '2.0.0-rc.21' },
+  '@solidjs/diagnostics': { line: 2, baseline: '2.0.0-rc.21' },
+  '@solidjs/compiler': { line: 2, baseline: '2.0.0-rc.21' },
+  '@solidjs/babel-plugin': { line: 2, baseline: '2.0.0-rc.21' },
+  '@solidjs/router': { line: 2, baseline: '2.0.0-next.44' },
+  '@solidjs/vite-plugin': { line: 3, baseline: '3.0.0-next.57' },
   '@solidjs/testing-library': { line: 1, baseline: '1.0.0-rc.2' },
 };
 

package/files/shared/agents-section.md

@@ -5,4 +5,4 @@
 - After editing TSX, run the `solid2-kit check` mechanical gate — it fails on React/Solid 1.x tokens and props destructuring. Use the project's `lint:solid` script if one exists; otherwise `npx solid2-agent-kit check` (with the kit as a devDependency) or `npx github:lightsound/solid2-agent-kit check`. An edit-time hook may also run this gate automatically after each file edit — treat its findings as errors to fix immediately, not warnings. Do not install `eslint-plugin-solid` (built for Solid 1.x; misreads Solid 2 idioms).
 - After editing `package.json`, `tsconfig*.json`, or root config files (Vite, ESLint), run `solid2-kit doctor` — it fails on React/Solid 1.x wiring: `react`/`vite-plugin-solid`/`eslint-plugin-solid`/SolidStart dependencies, 1.x `solid-js` ranges, and `jsx`/`jsxImportSource` values other than `preserve`/`@solidjs/web`.
 - The kit's guidance and gate files (`.cursor/rules/solid-2.mdc`, the `solid-2` skill directories, hook entries, managed blocks in this file and `CLAUDE.md`) are guardrails, not obstacles. Never edit, weaken, bypass, or delete them to make a failure go away — fix the flagged code. If a guardrail seems wrong, stop and tell the user.
-- Solid 2.0 shipped recently and breaks with 1.x — never trust pre-2.0 Solid docs, tutorials, or training knowledge. Verify APIs against https://v2-rebuild--solid-docs-v2.netlify.app/llms.txt (markdown mirror of https://v2.solidjs.com/, which blocks non-browser fetchers). If the project has `@solidjs/router`, server functions, or `@solidjs/meta`, use those official pages (see the skill's official-docs index) — not React Router, Next.js, SolidStart 1.x, or Solid Router 0.x/1.x JSX `<Route>`/`<A>`. Core `action` from `solid-js` is a generator transaction; router `formAction`/`query` from `@solidjs/router` are POST forms and a read cache (router `action` is a deprecated alias of `formAction`, and `useAction` is deprecated: call the server function directly — a mounted router applies its revalidation and redirect on any call <!-- upstream:router-action-deprecated -->). React `useDeferredValue` is `createDeferred(fn)`: an async memo that lags but never leads <!-- upstream:create-deferred-export -->. Core `refresh(source)`, router `revalidate(key)`, and server-function `return reload(...)` are three different APIs. Pass the accessor to `isPending(user)`, not `isPending(user())`. Pass async values as values (`user={user()}`) — JSX props are lazy; types stay `User`, not `Promise<User>`. `<Loading>` wraps the read, not the memo. Nested fetches run in parallel (components do not suspend). `isPending` is a per-expression question (`isPending(() => props.story)` / `isPending(selectedId)`), not a global spinner; `latest(selectedId)` is opt-in so highlight and content stay consistent by default. `<Errored>` heals when the source succeeds. Pass a function to `render`/`hydrate`: `render(() => <App />, root)`. Component teardown is `onSettled`, not `onCleanup` — return the cleanup; `onCleanup`, memo/effect creation, and `flush()` throw inside the `onSettled` callback in dev. Creating a memo/effect/root inside an effect's `apply` callback throws in dev too (`[PRIMITIVE_IN_EFFECT_CALLBACK]`) — create it in the body or compute phase. <!-- upstream:primitive-in-effect-callback --> Effect `apply` functions use block bodies (`(t) => { document.title = t; }`): any return value other than a cleanup function halts reactivity. Stores are written only through the setter's draft — writes to the store itself are ignored (dev warns `[STORE_WRITE_OUTSIDE_SETTER]` <!-- upstream:store-write-outside-setter -->), and `Map`/`Set`/`Date` inside a store are not tracked. Shared state, app-wide included, is created in a provider at the root of `App` (`createContext<T>()` + `useX()`), never a module-level signal/store (one instance serves every SSR request). Errors thrown out of an `action` never reach `<Errored>` — catch them in the action or `.catch` the call. One router instance; in-app navigation is `useNavigate` / `<a href>`, not `window.location`. Types: `solid-js` exports no `JSX` namespace — markup types are `JSX.Element` from `@solidjs/web` or `Element` from `solid-js` (alias it `SolidElement` next to DOM code) <!-- upstream:jsx-namespace-absent -->. Reset-a-signal-on-change is a writable derivation (`createSignal(() => { source(); return initial; })`), never an effect calling the setter. Client mode mounts with `render()` into an empty body — no hydration mismatch exists, so never defer initial values to post-mount React-style (that can overwrite persisted state). Client → server is additive (same setters + `action` + server functions): do not rewrite App with loading/error branches, disable optimistic rows until ack, invent tRPC, or refetch in `hydrate`/`onSettled`. The graph continues across the wire (`live()` owns the client connection; `<Reveal>` not a delayed stream). A server bundle uses `handleRequest` / Fetchable `fetch`; client-only start is static `dist/client`. One browser-only value takes `ssrSource: "client"` on the memo/signal/derived store, not a `clientOnly` component split. Router link state is `aria-current`/`data-active` + CSS (`data-pending` is opt-in via `createRouter({ links: pendingLinks })`; `useLinkState`/`useIsRouting` in JSX) <!-- upstream:pending-links-opt-in -->; link preloading is opt-in too (`preloadLinks: intentPreload()` for hover/focus/touch; none by default; opt one link out with the string `preload="false"`) <!-- upstream:preload-links-opt-in -->; search params via `useSearchParams`; router forms validate on the server (`throw respond({issues},{400})`) with inline errors from `useSubmissions`. Confirmations on another channel — fire-and-forget sends, and mutations whose result is read through `live()` — wait with `yield until(predicate, {timeout})`, not `refresh()`. Declare live reads `live(fn)` — it implies `GET` (`live(GET(fn))` is the same) <!-- upstream:live-implies-get -->. Debounce at the handler; inputs feeding a request bind `latest(query)`. Dev diagnostics are errors: `[STRICT_READ_UNTRACKED]` means a read outside a tracking scope, `[ASYNC_STORE_SETTER]` means a store setter callback awaited (the draft is a synchronous transaction — await first, then write) <!-- upstream:async-store-setter-throws -->, a held write needs `isPending`/`latest`/optimistic/`affects` feedback or dev + attribution reports `[SILENT_HOLD]`, and `[UNCOMMITTED_INPUT_OVERWRITTEN]` means a `value`/`checked` binding re-wrote the bound value over text the user typed but never committed (`value={props.name} onChange={commit}` with no draft signal) — bind a draft signal written from `onInput`, or `defaultValue` <!-- upstream:uncommitted-input-overwritten -->. Error monitoring is `configureClientErrors` / `configureServerErrors` (or per root `render(fn, root, undefined, { onError })` — options are the 4th argument), not a side effect inside `<Errored fallback>`; the server hook must return a reference or nothing, never the error itself. `<Dynamic>` is deprecated — use `dynamic()`. <!-- upstream:dynamic-deprecated --> Observability is on by default in development: whenever a change touches stores, lists, async, actions, or effects, keep the dev console free of `[CODE]` findings and run an attribution session (`/__solid/diagnostics` `begin` → interact → `whyDidRun` / `costs` → `end` with `@solidjs/diagnostics` installed, otherwise `isDev`-guarded `attribution.enable({ log: false })` + `why()` / `costs()`) before finishing. `vite dev` is always the dev build; `solid({ observe: true })` is a production opt-in.
+- Solid 2.0 shipped recently and breaks with 1.x — never trust pre-2.0 Solid docs, tutorials, or training knowledge. Verify APIs against https://v2-rebuild--solid-docs-v2.netlify.app/llms.txt (markdown mirror of https://v2.solidjs.com/, which blocks non-browser fetchers). If the project has `@solidjs/router`, server functions, or `@solidjs/meta`, use those official pages (see the skill's official-docs index) — not React Router, Next.js, SolidStart 1.x, or Solid Router 0.x/1.x JSX `<Route>`/`<A>`. Core `action` from `solid-js` is a generator transaction; router `formAction`/`query` from `@solidjs/router` are POST forms and a read cache (router `action` is a deprecated alias of `formAction`, and `useAction` is deprecated: call the server function directly — a mounted router applies its revalidation and redirect on any call <!-- upstream:router-action-deprecated -->). React `useDeferredValue` is `createDeferred(fn)`: an async memo that lags but never leads <!-- upstream:create-deferred-export -->. Core `refresh(source)`, router `revalidate(key)`, and server-function `return reload(...)` are three different APIs. Pass the accessor to `isPending(user)`, not `isPending(user())`. Pass async values as values (`user={user()}`) — JSX props are lazy; types stay `User`, not `Promise<User>`. `<Loading>` wraps the read, not the memo. Nested fetches run in parallel (components do not suspend). `isPending` is a per-expression question (`isPending(() => props.story)` / `isPending(selectedId)`), not a global spinner; `latest(selectedId)` is opt-in so highlight and content stay consistent by default. `<Errored>` heals when the source succeeds. Pass a function to `render`/`hydrate`: `render(() => <App />, root)`. Component teardown is `onSettled`, not `onCleanup` — return the cleanup; `onCleanup`, memo/effect creation, and `flush()` throw inside the `onSettled` callback in dev. Creating a memo/effect/root inside an effect's `apply` callback throws in dev too (`[PRIMITIVE_IN_EFFECT_CALLBACK]`) — create it in the body or compute phase. <!-- upstream:primitive-in-effect-callback --> Effect `apply` functions use block bodies (`(t) => { document.title = t; }`): any return value other than a cleanup function halts reactivity. Stores are written only through the setter's draft — writes to the store itself are ignored (dev warns `[STORE_WRITE_OUTSIDE_SETTER]` <!-- upstream:store-write-outside-setter -->), and `Map`/`Set`/`Date` inside a store are not tracked. Shared state, app-wide included, is created in a provider at the root of `App` (`createContext<T>()` + `useX()`), never a module-level signal/store (one instance serves every SSR request). Errors thrown out of an `action` never reach `<Errored>` — catch them in the action or `.catch` the call. One router instance; in-app navigation is `useNavigate` / `<a href>`, not `window.location`. Types: `solid-js` exports no `JSX` namespace — markup types are `JSX.Element` from `@solidjs/web` or `Element` from `solid-js` (alias it `SolidElement` next to DOM code) <!-- upstream:jsx-namespace-absent -->. Reset-a-signal-on-change is a writable derivation (`createSignal(() => { source(); return initial; })`), never an effect calling the setter. Client mode mounts with `render()` into an empty body — no hydration mismatch exists, so never defer initial values to post-mount React-style (that can overwrite persisted state). Client → server is additive (same setters + `action` + server functions): do not rewrite App with loading/error branches, disable optimistic rows until ack, invent tRPC, or refetch in `hydrate`/`onSettled`. The graph continues across the wire (`live()` owns the client connection; `<Reveal>` not a delayed stream). A server bundle uses `handleRequest` / Fetchable `fetch`; client-only start is static `dist/client`. One browser-only value takes `ssrSource: "client"` on the memo/signal/derived store, not a `clientOnly` component split. Router link state is `aria-current`/`data-active` + CSS (`data-pending` is opt-in via `createRouter({ links: pendingLinks })`; `useLinkState`/`useIsRouting` in JSX) <!-- upstream:pending-links-opt-in -->; link preloading is opt-in too (`preloadLinks: intentPreload()` for hover/focus/touch; none by default; opt one link out with the string `preload="false"`) <!-- upstream:preload-links-opt-in -->; search params via `useSearchParams`; router forms validate on the server (`throw respond({issues},{400})`) with inline errors from `useSubmissions`. Confirmations on another channel — fire-and-forget sends, and mutations whose result is read through `live()` — wait with `yield until(predicate, {timeout})`, not `refresh()`. Declare live reads `live(fn)` — it implies `GET` (`live(GET(fn))` is the same) <!-- upstream:live-implies-get -->. Debounce at the handler; inputs feeding a request bind `latest(query)`. Dev diagnostics are errors: `[STRICT_READ_UNTRACKED]` means a read outside a tracking scope, `[ASYNC_STORE_SETTER]` means a store setter callback awaited (the draft is a synchronous transaction — await first, then write) <!-- upstream:async-store-setter-throws -->, a held write needs `isPending`/`latest`/optimistic/`affects` feedback or dev + attribution reports `[SILENT_HOLD]` (a write that must not join another update's hold goes in `onFlush(...)` <!-- upstream:on-flush -->), and `[UNCOMMITTED_INPUT_OVERWRITTEN]` means a `value`/`checked` binding re-wrote the bound value over text the user typed but never committed (`value={props.name} onChange={commit}` with no draft signal) — bind a draft signal written from `onInput`, or `defaultValue` <!-- upstream:uncommitted-input-overwritten -->. Error monitoring is `configureClientErrors` / `configureServerErrors` (or per root `render(fn, root, undefined, { onError })` — options are the 4th argument), not a side effect inside `<Errored fallback>`; the server hook must return a reference or nothing, never the error itself. `<Dynamic>` is deprecated — use `dynamic()`. <!-- upstream:dynamic-deprecated --> Observability is on by default in development: whenever a change touches stores, lists, async, actions, or effects, keep the dev console free of `[CODE]` findings and run an attribution session (`/__solid/diagnostics` `begin` → interact → `whyDidRun` / `costs` → `end` with `@solidjs/diagnostics` installed, otherwise `isDev`-guarded `attribution.enable({ log: false })` + `why()` / `costs()`) before finishing. `vite dev` is always the dev build; `solid({ observe: true })` is a production opt-in.

package/files/shared/rules-body.md

@@ -209,7 +209,8 @@ Claude Code) for full patterns, decision tables, and official documentation URLs
     the callback. The `onSettled` callback is a restricted scope: `onCleanup`
     (`[CLEANUP_IN_FORBIDDEN_SCOPE]`), creating a memo or effect
     (`[PRIMITIVE_IN_FORBIDDEN_SCOPE]`), and `flush()` all throw there in dev and halt
-    the reactive system. A 1.x `onMount(() => { …; onCleanup(…) })` becomes
+    the reactive system; a pending async read there warns `[PENDING_ASYNC_FORBIDDEN_SCOPE]`
+    <!-- upstream:pending-async-forbidden-scope --> (nothing re-runs the callback when the answer lands). A 1.x `onMount(() => { …; onCleanup(…) })` becomes
     `onSettled(() => { const id = setInterval(tick, 1000); return () => clearInterval(id); })`.
 13. **Writes are staged** and commit on the next microtask. Event handlers need nothing
     special; tests and imperative integration code must call `flush()` before observing
@@ -550,7 +551,7 @@ directory (default `src/`).
 | `import ... from "solid-js/store"` or `"solid-js/web"` | stores/`merge`/`omit` from `"solid-js"`; `render`/`hydrate`/`Portal`/`Dynamic` from `"@solidjs/web"` |
 | `import type { JSX } from "solid-js"` | `solid-js` exports no `JSX` namespace: markup types are `JSX.Element` from `"@solidjs/web"` (with `JSX.IntrinsicElements`, `JSX.CSSProperties`) or `Element` from `"solid-js"` — import the latter as `type Element as SolidElement` where the DOM `Element` is also used, or it shadows it <!-- upstream:jsx-namespace-absent --> |
 | `createResource` | async `createMemo` + `<Loading>`/`<Errored>`; `refresh()`, `latest()`, `isPending()` |
-| `createEffect(fn)` (one arg), `on(...)`, `createTrackedEffect` (deprecated in 2.0) <!-- upstream:tracked-effect-deprecated --> | `createEffect(compute, apply)`; deps belong in `compute`; one-time DOM work is `onSettled` |
+| `createEffect(fn)` (one arg — dev throws `[MISSING_EFFECT_FN]` <!-- upstream:missing-effect-fn -->), `on(...)`, `createTrackedEffect` (deprecated in 2.0) <!-- upstream:tracked-effect-deprecated --> | `createEffect(compute, apply)`; deps belong in `compute`; one-time DOM work is `onSettled` |
 | `onMount` | `onSettled(() => { ...; return cleanup })` — return the cleanup; `onCleanup`, memo/effect creation, and `flush()` throw inside the callback |
 | `batch(...)` | delete it — writes auto-batch; `flush()` only to observe synchronously |
 | `<Suspense>`, `<ErrorBoundary>`, `<SuspenseList>` | `<Loading>`, `<Errored>` (fallback gets an error *accessor*), `<Reveal>` |
@@ -564,7 +565,7 @@ directory (default `src/`).
 | `createDeferred(source, { timeoutMs })` (1.x: a signal that lags by idle time) | `createDeferred(fn)` (2.0: an async memo that may lag its inputs but never leads them; `isPending(deferred)` while it catches up) <!-- upstream:create-deferred-export --> |
 | `startTransition`, `useTransition` | automatic held updates + `isPending` |
 | `onError` / `catchError` | `<Errored>` or effect bundle `{ effect, error }` |
-| `from(...)` / `observable(...)` (the solid-js helpers) | inbound: async iterable from a memo; outbound: split effect |
+| `from(...)` / `observable(...)` (the solid-js helpers) | inbound: `from(source)` — the same name in 2.0, but it returns an AsyncIterable for a computation (`createMemo(() => from(source))`), not a signal <!-- upstream:from-source-adapts -->; outbound: split effect |
 | `createDynamic(...)`, `<Dynamic component={...}>` (deprecated in 2.0) <!-- upstream:dynamic-deprecated --> | `dynamic(source)` from `@solidjs/web` — `dynamicComponent(source)` from `solid-js` when the source only answers with a component <!-- upstream:dynamic-component-export --> |
 | `renderToStringAsync(...)` | `await renderToStream(() => <App />)` (one consumer: `pipe` / `pipeTo` / `readable`) |
 | `clearDelegatedEvents` | delete — delegated listeners are scoped to each render root |
@@ -582,6 +583,11 @@ When unsure about any API, verify against the official Solid 2.0 docs — fetcha
 listed in `references/official-docs.md` next to the `solid-2` skill. Do not guess from
 Solid 1.x or React memory.
 
+`createOwner` is not public API either: since 2.0.0-rc.21 it is typed only through
+`solid-js/internal` (a runtime export kept for the renderers) <!-- upstream:create-owner-internal --> — host a
+scope with `createRoot()`, pass its `dispose` around as a plain function, and re-enter
+with `runWithOwner(owner, …)`.
+
 `createRenderEffect` exists in Solid 2 but is not a default. `storePath`
 (the 1.x path-setter migration helper) is no longer exported from `solid-js` as of
 2.0.0-rc.9 — convert path setters to draft setters instead of importing it from

package/files/skills/solid-2/SKILL.md

@@ -44,7 +44,7 @@ Practical consequences:
 | App-wide state (theme, session, cart, locale) | the same provider, placed at the root of `App` — not a module-level signal/store (under SSR one module instance serves every request) |
 | Constants (a category list, a formatter, the `createContext` call) | module scope |
 | Tentative value during a mutation | `createOptimistic` / `createOptimisticStore` + `action` |
-| Values pushed by an external subscription (websocket, reactive client) | async iterable returned from a memo (or function-form `createStore` for keyed reconciliation) — never `{ data, error }` signal pairs |
+| Values pushed by an external subscription (websocket, reactive client) | async iterable returned from a memo — `from(source)` adapts a callback subscription, an Observable, or an AsyncIterable <!-- upstream:from-source-adapts --> (or function-form `createStore` for keyed reconciliation) — never `{ data, error }` signal pairs |
 
 ### Should this be an effect?
 
@@ -307,7 +307,10 @@ returns the value it set. Dev throws `effect callback returned an invalid cleanu
 production throws a `TypeError` on the next run, and both halt the whole
 reactive system (`[REACTIVITY_HALTED]`). TypeScript reports it as TS2345; a JS project
 gets no warning. The cleanup of an effect is the `apply` return value — `onCleanup`
-inside `apply` has no owner and never runs (`[NO_OWNER_CLEANUP]`).
+inside `apply` has no owner and never runs (`[NO_OWNER_CLEANUP]`). The two-phase
+signature itself is enforced: `createEffect(compute)` with no apply function throws
+`[MISSING_EFFECT_FN]` in dev <!-- upstream:missing-effect-fn --> (prod dies on the same call with an uncoded
+`TypeError`).
 
 **Effects never compare.** `apply` runs on every re-run of `compute`, whether or not the
 computed value changed; there is no `equals` on an effect. When equal results should skip
@@ -330,6 +333,13 @@ intercepted with the bundle form `createEffect(compute, { effect, error })`. Ski
 initial run with `{ defer: true }` — the `on(deps, fn, { defer: true })` replacement;
 the effect first runs on the next change.
 
+When the side effect should fire **once per arming** rather than on every change —
+"run this the first time the value crosses the threshold" — use `createReaction(fn)`
+from `solid-js`: it returns a tracker; `fn` runs once after a source read inside a
+`track(() => …)` call changes, then stays silent until the tracker is called again
+(re-arm from inside `fn` to keep listening). Nothing runs at creation, and changes
+made while unarmed are ignored. <!-- upstream:create-reaction -->
+
 A two-phase effect whose apply only calls a local signal setter is "state + effect" in
 disguise — formally legal Solid 2, still rule 4 (`solid2-kit check` flags it). The reset
 form of a writable derivation replaces it, and moves the source read to the read site
@@ -452,7 +462,9 @@ return <StoryDetail story={story} />;
   `affects(item, "quantity")`) or `isPending(() => todos.length)` dims only what
   that read depends on. A hold with no feedback at all is `[SILENT_HOLD]` under
   attribution — always pair a held write with one of these questions, an
-  optimistic value, or `affects()`.
+  optimistic value, or `affects()`. `affects` keys address store leaves only:
+  `affects(accessor, "quantity")` throws `[INVALID_AFFECTS_TARGET]` in dev
+  <!-- upstream:invalid-affects-target --> — the keyed form needs a store (or store row); a bare accessor takes no key.
 - Default navigation **holds**. `selectedId()` and the old story stay put until
   the new answer lands, so the highlight never points at the wrong content.
   `latest(selectedId)` is the opt-in when the design wants the highlight to move
@@ -460,14 +472,27 @@ return <StoryDetail story={story} />;
   `transition-delay` so fast swaps do not flash. Inputs that feed a request follow
   the same rule: bind `value={latest(query)}` so a controlled search box reflects
   keystrokes while its write is held (an uncontrolled input needs nothing).
+  When one write in a handler must *not* join the hold — closing a menu before
+  `props.onSelect` starts a navigation — defer just that write with
+  `onFlush(() => setOpen(false))` (since 2.0.0-rc.19): it runs once right after the
+  pending flush as its own update, instead of flushing early
+  <!-- upstream:on-flush -->. It belongs in event handlers and effect callbacks; in a
+  component body or computation dev warns `ON_FLUSH_IN_OWNED_SCOPE`.
 - Read every reactive input **before the first `await`** in an async computation. A read
   after `await` does not subscribe (dev reports `[UNTRACKED_READ_AFTER_AWAIT]` on V8 —
   Chromium, Node, Deno, Bun); production can sit pending with no retry.
+- An async memo returns **data**, never rendered output. On the server, a memo (or async
+  iterable source) landing on JSX, a component result, or a `<Loading>`/`<Errored>`
+  boundary cannot serialize for hydration: since 2.0.0-rc.19 the memo rejects with
+  `ASYNC_MEMO_ELEMENT` and the nearest `<Errored>` contains it like any render error
+  <!-- upstream:async-memo-element -->. Render the JSX from the data the memo returns.
 - `<Errored>` function fallbacks receive an error **accessor** and a `reset` callback:
   `fallback={(error, reset) => ...}`. The boundary **heals** when the source succeeds
   again (refresh, live reconnect, input change) — it is graph status, not a terminal
   React ErrorBoundary. `reset` retries the collected *data sources*, not a UI remount.
-- Refetch: `refresh(results)`. In-flight indicator: `isPending(results)` (or
+- Refetch: `refresh(results)`. `refresh` takes a source accessor or a refreshable
+  store only — anything else (a plain function included) throws `[INVALID_REFRESH_TARGET]`
+  in dev <!-- upstream:invalid-refresh-target -->, and prod silently accepts it. In-flight indicator: `isPending(results)` (or
   `isPending(() => results())`). Freshest in-flight value for a preview:
   `latest(results)`. `latest` is not a null-safe probe: before the source's first value
   it throws `NotReadyError` in every scope (since 2.0.0-rc.9 also in event handlers and
@@ -540,7 +565,7 @@ functions (middleware, request setup) reported via
 `renderToString` / `renderToStream`'s first pass is reported `render` / `failed`
 before rethrow. <!-- upstream:report-request-failure --> A monitoring SDK's `init()` that
 registers this hook must load before the server graph — put it in the plugin's
-`start: { instrument: "./src/instrument.ts" }`, not at the top of an entry (see
+`start: { serverSetup: "./src/instrument.ts" }`, not at the top of an entry (see
 [Production observability](#production-observability-the-observe-build)).
 
 `render` / `hydrate` accept a per-root `onError` that wins over the ambient hook —
@@ -558,7 +583,15 @@ errors matter (the rc.8 one-argument form keeps working). <!-- upstream:render-o
 Push-based sources integrate by returning an **async iterable** from a computation — reads
 then suspend to `<Loading>` until the first value, later pushes update the settled value,
 and thrown errors reach `<Errored>`. Integration layers should return a plain accessor, not
-`{ data, error }` signals:
+`{ data, error }` signals.
+
+For a callback subscription, an Observable, or an existing AsyncIterable, the adapter is
+built in: `from(source)` returns the async iterable a computation consumes —
+`createMemo(() => from(source))` <!-- upstream:from-source-adapts -->. Read the inputs that
+choose the source before calling it, so a change re-runs the memo, closes the old source,
+and opens the new one <!-- upstream:from-source-adapts -->. The hand-rolled form below remains for what `from` does not fit —
+an event stream where every message matters (keep a queue instead of conflating to the
+latest), or a subscribe signature that is not `(next, error, complete) => unsubscribe`:
 
 ```tsx
 import { createMemo, onCleanup } from 'solid-js';
@@ -736,7 +769,8 @@ list). An in-flight action does not freeze unrelated writes. Collecting failed
 actions to replay is a design choice, not something the runtime requires.
 
 Ordinary signal/store writes inside an action are held until it settles. Never call
-`flush()` inside an action. Invoke actions from handlers, not from component/computation bodies.
+`flush()` inside an action. Invoke actions from handlers, not from component/computation bodies (dev warns
+`[ACTION_CALLED_IN_OWNED_SCOPE]` <!-- upstream:action-in-owned-scope -->).
 Do not set a `submitted` signal and watch it from an effect — that work belongs in the
 handler or the `action`.
 
@@ -748,7 +782,9 @@ leaves an empty list once the action settles, with no warning. <!-- upstream:opt
 from the function form — `createOptimisticStore(() => api.list(), [])` refreshed
 after the `yield`, or `createOptimisticStore(() => base.todos, [])` over a separate
 `createStore` that the action writes the confirmed value into. Keep the value form for
-in-flight flags.
+in-flight flags. A write against a function-form source whose first answer has not
+landed yet is not guessed at all — dev warns `[OPTIMISTIC_WRITE_BEFORE_LOAD]`
+<!-- upstream:optimistic-write-before-load -->; let the first answer land before writing.
 
 `createOptimistic` / `createOptimisticStore` are for a tentative value during an
 active mutation, not a local editing session (use a writable derivation or a plain
@@ -1073,7 +1109,11 @@ do not `return () => cleanup`. Put owned setup in a **directive factory** (like
 `onCleanup` throws there (`[CLEANUP_IN_FORBIDDEN_SCOPE]`), creating a memo or effect
 throws (`[PRIMITIVE_IN_FORBIDDEN_SCOPE]`), and so does `flush()` — each halts the
 reactive system in dev. Return the cleanup; create effects and memos in the component
-body, next to the `onSettled` call, not inside it.
+body, next to the `onSettled` call, not inside it. A pending async read inside the
+callback warns `[PENDING_ASYNC_FORBIDDEN_SCOPE]` <!-- upstream:pending-async-forbidden-scope --> — the callback is not a
+computation, so nothing re-runs it when the answer lands. Register `onSettled` in the
+body, not out-of-band after an `await`: a cleanup returned from an unowned registration
+warns `[SETTLED_CLEANUP_UNOWNED]` <!-- upstream:settled-cleanup-unowned --> and never runs.
 
 ```tsx
 // WRONG — the mechanical 1.x port of onMount + onCleanup
@@ -1098,6 +1138,12 @@ component body or the compute phase, or attach them to an owner captured with
 `getOwner()` in the body via `runWithOwner(owner, …)`.
 <!-- upstream:primitive-in-effect-callback -->
 
+`createOwner` is not public API: since rc.21 it is typed only through
+`solid-js/internal`, as a runtime export kept for the renderers
+<!-- upstream:create-owner-internal -->. Host a scope with `createRoot()` and pass its `dispose` argument
+around as a plain function (a detached `owner.dispose` is a method and throws unbound
+<!-- upstream:ownerless-and-disposed -->); re-enter the scope with `runWithOwner(owner, …)`.
+
 ### Per-value SSR policy: `ssrSource`
 
 `clientOnly` splits a *component*; `ssrSource` keeps one *value* off the server,
@@ -1227,13 +1273,23 @@ Always-on dev checks include misplaced reads
 for a first read made after an `await` in an async compute — V8 engines only), misplaced writes
 (`[REACTIVE_WRITE_IN_OWNED_SCOPE]` — since rc.9 also for store setters called in a
 component or root body <!-- upstream:store-write-owned-scope -->, `[ASYNC_STORE_SETTER]` for a store setter callback that returns
-a promise <!-- upstream:async-store-setter-throws -->, `[FLUSH_IN_ACTION]`, `[SERVER_WRITE]`,
+a promise <!-- upstream:async-store-setter-throws -->, `[FLUSH_IN_ACTION]`,
+`[ACTION_CALLED_IN_OWNED_SCOPE]` for an `action()` invoked from a component body or
+computation <!-- upstream:action-in-owned-scope -->, `[SERVER_WRITE]`,
 and since rc.17 `[STORE_WRITE_OUTSIDE_SETTER]` for a write to the store proxy itself
 <!-- upstream:store-write-outside-setter -->), misplaced bindings
 (`[UNCOMMITTED_INPUT_OVERWRITTEN]` — a `value` / `checked` binding re-applied its
 committed value over uncommitted user input <!-- upstream:uncommitted-input-overwritten -->),
-`[ASYNC_OUTSIDE_LOADING_BOUNDARY]` when a tracked read has no boundary above it, and
-`[LOADING_ON_OUTSIDE_HOLD]` when a `<Loading on>` boundary's data is also read outside it.
+`[ASYNC_OUTSIDE_LOADING_BOUNDARY]` when a tracked read has no boundary above it,
+`[LOADING_ON_OUTSIDE_HOLD]` when a `<Loading on>` boundary's data is also read outside it,
+`[LOADING_ON_ACCESSOR]` when a `<Loading on>` receives a function instead of the value
+(the boundary never calls it, so it never re-arms; since rc.20) <!-- upstream:loading-on-accessor -->, and
+since rc.21 `[CAUGHT_REACTIVE_READ]` when a computation catches a reactive read's throw
+itself and completes with a value — the catch masks the load or hides the error from the
+boundaries <!-- upstream:caught-reactive-read -->. Ownerless creation warns rather than throws: `[NO_OWNER_EFFECT]`
+for an effect created outside any root or component, `[NO_OWNER_BOUNDARY]` for a
+boundary invoked outside a reactive context, and `[RUN_WITH_DISPOSED_OWNER]` for
+`runWithOwner` on a disposed owner <!-- upstream:ownerless-and-disposed --> — none of them is ever disposed.
 Each entry carries a stable `[CODE]`, what the runtime observed, an owner chain
 (`in <App> › <Cart> › <LineItem>`), and — since rc.16, under `vite dev` — an
 `at src/Cart.tsx:12:5` line naming where the scope was created (the compiler's
@@ -1325,7 +1381,8 @@ first), `[ABANDONED_FLIGHTS]` (a source re-asked on every keystroke, answers thr
 — debounce at the handler), `[STACKED_HOLDS]` (repeated clicks piling into one hold),
 `[FALLBACK_FLASH]` (a fallback shown under 150ms), `[WASTED_RECOMPUTE]` (a scope whose
 runs mostly compared equal — narrow its reads upstream), `[GRAPH_GROWTH]` (the graph grows
-on every visit to a route — an undisposed root or subscription), and `[OPTIMISTIC_REVERTED]`
+on every visit to a route — an undisposed root or subscription), `[HOT_SCOPE_FANOUT]`
+(many scopes hot from one root cause), and `[OPTIMISTIC_REVERTED]`
 (info: a guess the screen showed was replaced). `costs()` and `feedback()` (named imports)
 rank the session worst-first; `attribution.history("hold")` / `("waterfall")` /
 `("navigation")` / `("interaction")` hold the fact tables behind the verdicts (each hold
@@ -1546,10 +1603,15 @@ production too (observe build; a no-op on the prod build).
 - **Instrumentation order.** A monitoring SDK's `init()` (and `configureServerErrors`)
   must run before the modules it patches load. `import "./instrument"` at the top of an
   entry does not achieve that in ESM (static imports are hoisted in dependency order);
-  the plugin's `start: { instrument: "./src/instrument.ts" }` awaits that server-only
-  module before anything else in the server graph — since vite-plugin 3.0.0-next.51 the
-  `node` entry too: `dist/server/node.js` awaits `./server.js` (which awaits the
-  instrument module) and then loads `node-runtime.js`, so deploy both files. Failures the
+  the plugin's `start: { serverSetup: "./src/instrument.ts" }` awaits that server-only
+  module before anything else in the server graph — the `node` entry too:
+  `dist/server/node.js` awaits `./server.js` (which awaits the
+  setup module) and then loads `node-runtime.js`, so deploy both files. The option was
+  renamed from `start.instrument` between vite-plugin next.52 and next.57 — the plugin
+  throws on the old key <!-- upstream:start-server-setup -->. The sibling seam
+  `start: { serverRenderSetup: "./src/render-setup.ts" }` runs per request immediately
+  before SSR — `(event, App) => Component | void` — for integrations that must prepare
+  a per-request app instance before the render. Failures the
   handler contains itself reach the hook as `{ kind: "request", handling: "failed" }`.
   The client-side counterpart is `start: { clientSetup: "./src/client-setup.ts" }`: a
   browser module run (and awaited, top-level `await` allowed) before `hydrate` / `render`,
@@ -1681,7 +1743,10 @@ plain `<a href={Router.paths.about}>` (or `useNavigate`); there is no `<A>` /
 `<Navigate>` / `<HashRouter>` / `<FileRoutes />`. Do not assign
 `window.location.href` or call `history.pushState` for in-app navigation.
 Session location is `useLocation` / `useParams`,
-not `Router.paths`.
+not `Router.paths`. `useMatch(() => "/docs/:page")` tests a pattern against the
+current pathname without a route existing for it — the memo answers the match (params
+typed from the pattern) or nothing; that is the breadcrumb / section-highlight read
+<!-- upstream:router-use-match -->.
 
 **Route `preload` starts reads; the page reads them in a memo.** `preload` runs when
 the route matches (and ahead of a click under a `preloadLinks` strategy <!-- upstream:preload-links-opt-in -->), so it should kick off the query and return
@@ -2033,9 +2098,13 @@ every POST call as one). `live(GET(fn))` is the same declaration spelled out —
 component rendered into a document that reads an *undeclared* async iterable still
 producing after 5s is `[SSR_UNDECLARED_LIVE_SOURCE]` in dev — declare it `live()` (the
 document takes the first value and closes it; the client connects after hydration) or
-bound the source. `broadcast(fn)` (experimental) is `live()` for one answer shared across
+bound the source. `broadcast(fn)` is `live()` for one answer shared across
 every viewer — the server runs the generator once per argument set instead of once per
-connection.
+connection. In a router app, `liveQuery(fn, "key")` from `@solidjs/router` declares
+the `live()` server function itself and keeps one connection per key, shared by every
+consumer — when several components need the same stream, declare it once with
+`liveQuery` instead of hoisting a hand-rolled `live()` declaration and sharing code
+<!-- upstream:router-live-query -->.
 
 ```ts
 // src/data/auction.ts
@@ -2171,7 +2240,7 @@ how to reuse. Prefer the form on the right.
 | `createEffect(() => user, (u) => { log(u.name); })` | `createEffect(() => user.name, (name) => { log(name); })` |
 | `createEffect(() => title(), (t) => (document.title = t))` / `(v) => setX(v)` | `(t) => { document.title = t; }` — apply returns a cleanup or nothing; any other return value halts reactivity. An apply that only calls a local setter is rule 4 even with braces (`solid2-kit check` flags it): use a (writable) derivation |
 | `<Loading fallback={<PageSkeleton />}>{/* header + data */}</Loading>` | wrap only the data slot; chrome stays outside |
-| `<Loading on={id} fallback={...}>` (the accessor), or `` on={`${a()}/${b()}`} `` to key several inputs | `on={id()}` / `on={[a(), b()]}` — `on` is a tracked dependency list, not a compared key: a bare accessor is never read (`solid2-kit check` flags it), and an array is the several-inputs form <!-- upstream:loading-on-dependency-list --> |
+| `<Loading on={id} fallback={...}>` (the accessor), or `` on={`${a()}/${b()}`} `` to key several inputs | `on={id()}` / `on={[a(), b()]}` — `on` is a tracked dependency list, not a compared key: a bare accessor is never read (`solid2-kit check` flags it; dev warns `[LOADING_ON_ACCESSOR]` since rc.20 <!-- upstream:loading-on-accessor -->), and an array is the several-inputs form <!-- upstream:loading-on-dependency-list --> |
 | `setCount(count() + 1)` when writes can batch | `setCount((c) => c + 1)` |
 | `setHandler(fn)` to store a function | `setHandler(() => fn)` (otherwise `fn` is an updater) |
 | `{user() ? <P user={user()!} /> : <SignIn />}` | `<Show when={user()}>{(u) => <P user={u()} />}</Show>` |
@@ -2279,7 +2348,7 @@ how to reuse. Prefer the form on the right.
 | `attribution.enable()` unguarded in app code, or `enable()` with the default `log: true` left on | `if (isDev) attribution.enable({ log: false })` — on the observe build an unguarded `enable()` records in production; prefer the `/__solid/diagnostics` session (`begin` enables, `end` disables) so app code carries nothing |
 | `solid({ observe: true })` added "to see diagnostics in dev" | `vite dev` is always the dev build; `observe: true` is the production-observability opt-in (observe condition + `sourceNames` for `vite build`/preview <!-- upstream:source-names-option -->) |
 | `configureServerErrors({ onError: (e) => { report(e); return e; } })` | return nothing or a reference (`new Error(\`ref ${id}\`)`) — the return value replaces the sanitized wire value; the error itself leaks message/stack/secrets |
-| `import "./instrument"` at the top of the server entry for a monitoring SDK | `start: { instrument: "./src/instrument.ts" }` — ESM hoists static imports in dependency order, so the entry's own deps load first (next.51 wraps the `node` entry too: deploy `node.js` with `server.js`). Browser-side init before `hydrate` / `render` is `start: { clientSetup: "./src/client-setup.ts" }` |
+| `import "./instrument"` at the top of the server entry for a monitoring SDK | `start: { serverSetup: "./src/instrument.ts" }` — ESM hoists static imports in dependency order, so the entry's own deps load first (the `node` entry wraps it too: deploy `node.js` with `server.js`; the pre-rename spelling `start.instrument` throws in the plugin). Browser-side init before `hydrate` / `render` is `start: { clientSetup: "./src/client-setup.ts" }` |
 | Express/middleware injecting `traceparent` / trace headers into responses | the runtime carries a sampled or provided trace on `Server-Timing` + `<meta>`; forward downstream with `getTraceContext()?.entries`; SDKs use `OBSERVE?.server.trace.provide` |
 | `OBSERVE.records.subscribe("call", (e) => setStats(...))` | listeners run synchronously inside the runtime and must not write signals; collect into a plain buffer and drain from outside |
 | `import { storePath } from "solid-js"` | gone from `solid-js` (rc.9); write draft setters `setState((d) => { d.user.name = "Grace"; })` <!-- upstream:store-path-removed --> |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid2-agent-kit",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "Teach AI coding agents (Cursor, Claude Code) to write correct Solid 2.0 instead of React or Solid 1.x — always-applied rules, an agent skill, and a mechanical pattern gate.",
   "type": "module",
   "license": "MIT",