docs: reconcile Learn pages with the Glossary and the source

Cross-page audit driven by the Glossary's six groups. Mechanism fixes:
- SILENT_HOLD thresholds are 100/200ms; acknowledged long holds report
  LONG_HOLD; a revealed Loading boundary still holds.
- Optimistic writes show at once inside an action; ordinary writes are held.
- A relay effect's write lands in the same flush, not a frame later.
- A returned respond() is a result, not an error; throw it for a 400.
- A no-JS form post follows the redirect's own status (302 by default);
  303 is the flash-back default.
- Query adoption is unbounded outside a navigation, 5s inside one.
- An isServer tag swap reports Hydration tag mismatch, not structure.
- Loading's on is compared with !==.
- ASYNC_WATERFALL prints at three flights; two is info only.
- A file under src/routes is an API route only with a method export.
- Surviving items keep their proxies after a returned filter.
- Server functions read a derived event with a copy of locals.
- Start mode is not a precondition for the server-function transform.

Naming: effect function/phase (not apply), function child (not render
prop), pathless route, the static shell is written not prerendered;
Glossary aliases move reactive context/scope to Owner, drop derived value
from Memo and slots from Children, and Root no longer claims to be ownerless.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

src/routes/(1)getting-started/(0)quick-start.mdx

@@ -286,7 +286,7 @@ The `flush()` call matters: Solid applies DOM updates in a batch after the event
 The [Testing guide](/guides/testing) covers this and the other environments.
 
 Run `npm run build`.
-The output is a static site in `dist/client`, with each route in its own chunk.
+The output is a set of static files in `dist/client`, with each route in its own chunk.
 You can deploy that directory to any static host.
 When you later need server rendering or server functions, add `ssr: true` next to `start: true` in `vite.config.ts`; the files you have written carry over unchanged.
 [Project shapes](/getting-started/project-shapes) compares `bare`, `basic`, and `fullstack`.

src/routes/(1)getting-started/(1)project-shapes.mdx

@@ -19,7 +19,7 @@ Moving up is a configuration change; moving down means removing code you did not
 
 | Shape       | Adds                                                  | Build output                                                 |
 | ----------- | ----------------------------------------------------- | ------------------------------------------------------------ |
-| `bare`      | Solid, nothing else                                   | `vite build` emits a static site                             |
+| `bare`      | Solid, nothing else                                   | `vite build` emits static files                              |
 | `basic`     | Router, file-system routes, per-page titles, testing  | Still static; deploy `dist/client` to any static host        |
 | `fullstack` | Streaming SSR, server functions, sessions, API routes | Static client assets plus a request handler in `dist/server` |
 
@@ -41,7 +41,7 @@ export default defineConfig({
 });
 ```
 
-Without `ssr`, the document shell is prerendered as static HTML and pages render in the browser.
+Without `ssr`, the build writes the empty document shell as static HTML and pages render in the browser.
 With `ssr: true`, pages stream from the server and hydrate in the browser.
 The `src/App.tsx` and `src/Document.tsx` structure does not change.
 

src/routes/(2)concepts/(2)stores.mdx

@@ -143,8 +143,8 @@ setCart((draft) => {
 });
 ```
 
-A returned or assigned collection is matched by position, not by identity.
-If the surviving items must keep their proxies, and therefore their rows, filter inside a [projection](#derive-a-store-with-a-projection) instead, which reconciles by key.
+A returned or assigned collection replaces the array by index, and the items that survive are the same objects, so their proxies and their rows are kept.
+When the new array holds new objects, such as a fresh server response, nothing matches them to the old ones; reconcile that inside a [projection](#derive-a-store-with-a-projection) with a key, or with `reconcile`.
 
 Store writes are staged and applied in the same batch as signal writes, so a read on the next line sees the previous value until the batch lands.
 [When updates land](/concepts/reactivity#when-updates-land) explains the batch and when to call `flush()`.

src/routes/(2)concepts/(4)boundaries.mdx

@@ -91,7 +91,7 @@ Without it, choosing a new product keeps the old product on screen while the new
 Pending work caused by anything else, such as a refresh of the same product, leaves the content in place.
 
 :::pitfall[Passing the accessor to on instead of its value]
-`on` is compared by value across updates.
+`on` is compared with `!==` across updates, so pass a primitive; join several inputs into one string rather than passing an array.
 
 ```tsx
 // Avoid: the function reference never changes, so the fallback never returns

src/routes/(2)concepts/(6)rendering-and-ssr.mdx

@@ -141,7 +141,7 @@ onSettled(() => setRenderedAt(Date.now()));
 </p>;
 ```
 
-The `Avoid` version logs, in development, a warning such as `Hydration structure mismatch: expected <time> as first child of` followed by the node it found instead, and the client's bindings for that region attach to the wrong nodes.
+The `Avoid` version logs, in development, a warning such as `Hydration tag mismatch for key "...": expected <time> but found` followed by the `<p>` it found instead, and the client's bindings for that region attach to the wrong node.
 The `Prefer` version hydrates cleanly and updates the text once the browser has taken over.
 A value that differs only in its text, such as `<p>{Date.now()}</p>`, produces no warning: hydration adopts the server's text node as it is, so the page keeps showing the server's value until a reactive update replaces it.
 [SSR-safe code](/guides/ssr-safe-code#values-that-differ-on-every-run) goes through these cases and how to read each warning.
@@ -297,9 +297,9 @@ A module or component body reads a browser API while the server renders.
 Move the read into an effect function or an `onSettled` callback, guard it with `isServer`, or wrap the component in `clientOnly`.
 See [Server and client boundaries](#server-and-client-boundaries).
 
-### `Hydration structure mismatch` or `Hydration key miss` in the console
+### `Hydration tag mismatch`, `Hydration structure mismatch`, or `Hydration key miss` in the console
 
-The server and the client rendered different elements for the same region: a conditional on `isServer` that picks a different tag, a `Show` whose condition depends on `Math.random()`, or data that differs between the request and the browser.
+The server and the client rendered different elements for the same region: a conditional on `isServer` that picks a different tag reports a tag mismatch; a `Show` whose condition depends on `Math.random()`, or data that differs between the request and the browser, reports a structure mismatch inside the template.
 Render the same structure on both sides and fill in browser-only values after hydration; [Reading the hydration warnings](/guides/ssr-safe-code#reading-the-hydration-warnings) explains what each message checks.
 A key miss whose message mentions namespaces means a subtree was hydrated with a different `renderId` than the server used; see [Controlling hydration](#controlling-hydration).
 

src/routes/(3)building-apps/(0)app-structure.mdx

@@ -31,7 +31,7 @@ export default defineConfig({
 The three modes the [Choose a rendering mode](/guides/choose-a-rendering-mode) guide compares all use the same `App` and `Document` files:
 
 - A static shell rendered in the browser, the default without `ssr`.
-  The build prerenders `Document` without the app into `dist/client/index.html`, and the generated client entry calls `render()` to mount `App` into `document.body`.
+  The build writes `Document` without the app into `dist/client/index.html`, and the generated client entry calls `render()` to mount `App` into `document.body`.
   Without server functions the build removes `dist/server`, so `dist/client` deploys to any static host.
 - Streaming server rendering, with `ssr: true`.
   Each request renders `<Document><App /></Document>` on the server and streams it; the generated client entry calls `hydrate()` on the same tree.

src/routes/(3)building-apps/(3)server-functions/(0)index.mdx

@@ -214,7 +214,7 @@ Move that read into a server function, or put the import in a `"use server"` mod
 
 ### The function body runs in the browser
 
-The `serverFunctions` option is off, or the project is not in start mode.
+The `serverFunctions` option is off.
 Without the transform, `"use server"` is a string expression the engine evaluates and ignores, and the body runs wherever it is called.
 Check `vite.config.ts` against the [Enable server functions](#enable-server-functions) section.
 

src/routes/(3)building-apps/(3)server-functions/(3)mutations-and-responses.mdx

@@ -75,7 +75,7 @@ Both reach the caller the same way.
 
 What the browser does next depends on who made the call.
 A Solid Router `action()` navigates to `/goodbye` without a page load.
-An HTML form post without JavaScript is answered with a 303 and the browser follows it.
+An HTML form post without JavaScript is answered with the redirect itself, 302 by default, and the browser follows it.
 Plain code that called `deleteAccount()` directly receives the `Response` object as the resolved value, because the transport hands navigation metadata back whole for the caller to apply.
 
 The target can be a string or an `Href` produced by a router's typed paths helper; a branded `Href` redirects to its logical path.
@@ -197,7 +197,7 @@ export const addToCartAction = action(addToCart);
 ```
 
 Render `<form method="post" action={addToCartAction}>` and the form posts to the function's URL before JavaScript loads; after hydration the router intercepts the submit, calls the function over the transport, and applies the `reload`.
-The router tracks the submission while it runs and turns the thrown envelope's value into `submission.error`, which the [Forms guide](/guides/forms) reads to show messages next to the fields.
+The router marks the form `aria-busy` while it runs and, once it settles, records a submission whose `error` is the thrown envelope's value, which the [Forms guide](/guides/forms) reads to show messages next to the fields.
 
 Keep the server function a named export and wrap it separately, as above, so a test or an API route can call `addToCart` without the form.
 When the function exists only for the form, write the body inline, `action(async (form: FormData) => { "use server"; ... })`; the [Data loading and mutations](/routing/solid-router/data#mutate-with-actions) page uses that shape throughout, and the two behave the same.
@@ -236,7 +236,7 @@ Pass a string path, or the value a router's typed paths helper returns.
 ## Recap
 
 - Return a plain value when the caller needs data and nothing else; use `respond()` to add a status or headers to it.
-- Return or throw `redirect(path)`; a router action navigates, a form post follows a 303, and direct code receives the `Response`.
+- Return or throw `redirect(path)`; a router action navigates, a form post follows the redirect, and direct code receives the `Response`.
 - Return `reload({ revalidate })` after a write so the router refetches the named reads.
 - Throw `respond(value, { status })` for a failure the caller should see; a returned envelope resolves the caller whatever its status.
 - A plain thrown value becomes `Internal Server Error` in production; `markSafeError()` opts one `Error` out of that.

src/routes/(3)building-apps/(3)server-functions/(5)progressive-enhancement.mdx

@@ -52,7 +52,7 @@ const addToCartAction = action(addToCart);
 ```
 
 Load the page with JavaScript disabled and submit.
-The browser posts to the function's URL, the server runs `addToCart`, and the 303 it answers sends the browser to `/cart`.
+The browser posts to the function's URL, the server runs `addToCart`, and the redirect it answers sends the browser to `/cart`.
 With JavaScript on, the router intercepts the submit, calls the function over the transport, and navigates to `/cart` without a page load.
 
 The wiring that makes this work is the form, not the handler:
@@ -177,7 +177,7 @@ Bind a string or number and convert inside the function, or pass the value throu
 ### The form submits but the page reloads instead of staying put
 
 The router is not mounted around the form, so nothing intercepts the submit and the browser follows the `action` URL as a full-page navigation.
-The result is still correct, because the function ran and the 303 was followed; mount the form inside the `Router` to get the scripted path.
+The result is still correct, because the function ran and the redirect was followed; mount the form inside the `Router` to get the scripted path.
 
 ### The 400 shows nothing after a no-JavaScript submit
 
@@ -190,7 +190,7 @@ Solid Router reads the cookie on the next server render and records the submissi
 - Put every mutation behind `<form method="post" action={...}>` so the browser can submit it before the client bundle runs.
 - Wrap the server function with the router's `action()`; it serializes to the function's plain-HTTP URL and takes over after hydration.
 - Pending state, `useSubmissions`, and `.onSubmit` optimistic writes are layers the hydrated page adds; the HTML and the server function stay the same.
-- A browser form post is answered with a 303 and a flash cookie; the router turns the cookie into a submission on the next render.
+- A browser form post follows a returned redirect; any other outcome is answered with a 303 back to the page and a flash cookie, which the router turns into a submission on the next render.
 - Use `method="get"` and `fn.url` only for a `GET()` read; the function receives the fields as `URLSearchParams`.
 - `url` is on every reference at runtime and only on `GET()` and `live()` references in the type.
 - Bound arguments travel in the `args` query parameter and must be JSON-safe.

src/routes/(3)building-apps/(4)sessions-and-auth.mdx

@@ -250,7 +250,7 @@ async function attachCustomer(
 }
 ```
 
-Server functions, API handlers, and the page render for that request read the same event, so `locals.userId` set here is visible to all of them.
+Server functions, API handlers, and the page render for that request read that request's event, so `locals.userId` set here is visible to all of them; a server function called during the render gets a derived event with a copy of `locals`, so what it writes stays with the call.
 Augment `RequestEventLocals` from `@solidjs/web` when the application wants a precise type for those fields:
 
 ```ts