From fc1de64d0edd7ef68fe8c6233ff4f4fc516be3d6 Mon Sep 17 00:00:00 2001
From: Aditya Tripathi <aditya@climactic.co>
Date: Sat, 3 Oct 2026 21:37:34 +0000
Subject: [PATCH 1/5] feat!: Inertia v3 parity (client 3.8 / inertia-laravel
 3.5), DevTools, dependency update

Brings the protocol surface up to the current Inertia v3 spec
(https://inertiajs.com/docs/v3/core-concepts/the-protocol), checked against
the inertia-laravel 3.x source and the real client in a browser.

Protocol
- X-Inertia-Version on the version-mismatch 409
- 409 + X-Inertia-Redirect for redirects with a URL fragment
- page JSON in the HTML shell escapes `<`, `>` and `/`
- flash data is the top-level `flash` field and survives redirect chains,
  plain responses and the version 409
- error bags, sharedProps, preserveFragment, Vary on all responses
- an empty 200 to an Inertia request redirects back

Props
- `Prop`: composable closure prop (optional, defer, once, merge, prepend,
  deep merge, match-on, rescue, infinite scroll, nested dot paths)
- partial reloads: dot paths, `errors` always sent, except-only reloads,
  reset removes merge labels
- big integers as `$bigint` markers

Other
- Precognition: `Inertia::precognition()` + `Precognition::respond`
- DevTools protocol: recorder, headers, read API (`InertiaConfig::devtools`)
- all validation messages per field (`with_all_errors`)
- SSR client: timeout, health check, error detail
- validator 0.21, ts-rs 12, base64 0.23, getrandom 0.4
- example: showcase page, Precognition, Inertia 3.7, Vite 8.3, TypeScript 7

BREAKING CHANGE: flash moves from `props.flash` to the page's `flash`;
`reset_merge` / `resetMergeProps` are removed; `location()` returns 302 for
non-Inertia requests; `LazyProp` / `DeferredProp` are replaced by `Prop`;
`Flash::errors` holds a list per field; the `ts` feature needs ts-rs 12.
See CHANGELOG.md.
---
 CHANGELOG.md                                  |   72 ++
 Cargo.toml                                    |   10 +-
 README.md                                     |   90 +-
 examples/axum-react-todo/Cargo.toml           |    4 +-
 .../frontend/components/Layout.tsx            |    6 +-
 .../frontend/gen/actions/showcase.ts          |   10 +
 .../axum-react-todo/frontend/gen/index.ts     |   32 +-
 .../frontend/pages/showcase.tsx               |   54 +
 .../frontend/pages/todos/create.tsx           |    7 +-
 examples/axum-react-todo/frontend/ssr.tsx     |    4 +-
 examples/axum-react-todo/package.json         |   16 +-
 examples/axum-react-todo/src/lib.rs           |   73 +-
 examples/axum-react-todo/src/main.rs          |   14 +-
 examples/axum-react-todo/src/todos.rs         |    9 +-
 examples/axum-react-todo/tsconfig.json        |    3 +-
 src/adapters/axum/extractor.rs                |    2 +
 src/adapters/axum/layer.rs                    |  173 ++-
 src/adapters/axum/mod.rs                      |    2 +
 src/adapters/axum/precognition.rs             |   81 ++
 src/adapters/axum/response.rs                 |  405 ++++---
 src/bigint.rs                                 |   52 +
 src/bindings/mod.rs                           |   37 +-
 src/config.rs                                 |   64 +
 src/devtools.rs                               |  536 +++++++++
 src/errors/garde.rs                           |   10 +
 src/errors/mod.rs                             |   12 +
 src/errors/validator.rs                       |   28 +-
 src/headers.rs                                |   23 +-
 src/inertia.rs                                |    2 +-
 src/lib.rs                                    |   24 +-
 src/page.rs                                   |  104 +-
 src/props/always.rs                           |   30 +-
 src/props/closure.rs                          |   30 -
 src/props/merge.rs                            |   31 +-
 src/props/mod.rs                              |    3 +-
 src/props/prop.rs                             |  279 +++++
 src/props/resolver.rs                         | 1069 +++++++++++------
 src/protocol.rs                               |  102 +-
 src/request.rs                                |   68 +-
 src/response.rs                               |  111 +-
 src/session/cookie.rs                         |   22 +-
 src/session/mod.rs                            |   20 +-
 src/session/tower.rs                          |   41 +-
 src/ssr/http.rs                               |   39 +-
 tests/axum_integration.rs                     |    8 +-
 tests/fixtures/conformance.json               |    2 +-
 tests/spec_coverage.rs                        |   58 +-
 tests/v3_protocol.rs                          |  593 +++++++++
 48 files changed, 3577 insertions(+), 888 deletions(-)
 create mode 100644 examples/axum-react-todo/frontend/gen/actions/showcase.ts
 create mode 100644 examples/axum-react-todo/frontend/pages/showcase.tsx
 create mode 100644 src/adapters/axum/precognition.rs
 create mode 100644 src/bigint.rs
 create mode 100644 src/devtools.rs
 delete mode 100644 src/props/closure.rs
 create mode 100644 src/props/prop.rs
 create mode 100644 tests/v3_protocol.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7ee4624..c56bede 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,77 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - Unreleased
+
+Brings the protocol surface up to Inertia client 3.8.0 / `inertia-laravel` 3.5.1.
+
+### Added
+
+- `Prop`: a composable closure prop (`optional`, `defer`/`group`, `once`,
+  `merge`/`prepend`/`deep_merge`, `Prop::try_new` + `rescue` for rescued props,
+  `Prop::scroll` + `ScrollMetadata` for infinite scroll), attached with
+  `InertiaResponse::prop`. `lazy`, `optional` and `deferred` build on it.
+- Once props (`InertiaResponse::once`, `InertiaConfig::share_once`,
+  `X-Inertia-Except-Once-Props`, `onceProps`).
+- Page object fields `prependProps`, `deepMergeProps`, `matchPropsOn`,
+  `scrollProps`, `rescuedProps`, `sharedProps`, `onceProps`, `flash`,
+  `preserveFragment`, `preserveBigIntegers`.
+- Builder methods `prepend`, `deep_merge`, `match_on`, `preserve_fragment`,
+  `preserve_big_integers`; config methods `encrypt_history`,
+  `preserve_big_integers`.
+- Big-integer transport (`$bigint` markers) for props and flash data.
+- `X-Inertia-Version` on the version-mismatch 409, so that the client does not
+  hard-reload on background requests.
+- 409 + `X-Inertia-Redirect` for redirects whose target has a URL fragment.
+- `X-Inertia-Error-Bag` support: errors nest under the bag name.
+- Precognition: `Inertia::precognition()` and `Precognition::respond`.
+- `RequestInfo` fields `error_bag`, `except_once_props`, `scroll_prepend`,
+  `is_prefetch`, `is_precognition`, `validate_only`.
+- Inertia DevTools protocol: `InertiaConfig::devtools(DevTools::new())` records
+  each request, sets the `X-Inertia-Devtools-*` headers and serves the read API.
+- All validation messages per field: `IntoErrorBag::into_all_errors`,
+  `InertiaConfig::with_all_errors`.
+- `Prop` at a nested dot path (`.prop("auth.permissions", …)`).
+- An empty `200` response to an Inertia request redirects back.
+- `HttpSsrClient::timeout` and `HttpSsrClient::health`.
+- `Vary: X-Inertia` on all responses that pass through `InertiaLayer`.
+- Plain handler responses (for example `axum::response::Redirect`) now get the
+  version-mismatch 409, fragment redirect and flash carry-over too.
+
+### Changed (breaking)
+
+- Flash data is the page object's top-level `flash` (`usePage().flash`), not
+  `props.flash`. It is omitted when empty.
+- `InertiaResponse::reset_merge` and the non-protocol `resetMergeProps` field
+  are removed. A prop named in `X-Inertia-Reset` is sent without merge labels.
+- `Inertia::location` returns a 302 for non-Inertia requests (409 only for
+  Inertia requests).
+- `props::closure::{LazyProp, DeferredProp}` are replaced by `props::Prop`;
+  `ResolveInput` / `ResolvedProps` changed with it. `ResponseShape` has new
+  variants.
+- `RequestInfo` and `PageObject` are `#[non_exhaustive]`.
+- `with_errors` on a render puts the errors on that page (not on the next one).
+- Flash data is used only by a page render; other responses pass it on.
+- `Flash::errors` is `HashMap<String, Vec<String>>` (all messages per field).
+- `Flash` is `#[non_exhaustive]` and has `clear_history` / `preserve_fragment`;
+  `clear_history()` on a redirect now applies to the page the redirect lands on.
+- Wrapper paths are dot paths; a nested `Merge<T>` now emits `mergeProps`.
+- `ts` feature: `ts-rs` 12 (was 11). Generated `PageObject` type updated.
+- `validator` 0.21, `base64` 0.23, `getrandom` 0.4.
+
+### Fixed
+
+- `errors` is an always prop: partial reloads no longer drop it.
+- A partial reload with only `X-Inertia-Partial-Except` no longer drops every prop.
+- Partial reloads accept dot paths and no longer emit merge labels for props
+  that the response leaves out.
+- The page JSON in the HTML shell escapes `<`, `>` and `/`. A prop that held
+  `<!--<script>` gave a blank page.
+- Flash data survives a version-mismatch 409 and redirect chains.
+- `Always` / `Merge` wrappers inside shared props are stripped.
+- Redirect responses no longer run shared props and prop closures.
+- SSR errors include the error body of the SSR server.
+
 ## [0.1.2] - 2026-05-26
 
 ### Added
@@ -16,4 +87,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   embedded in the binary (rust-embed / `include_dir` / map) — the single-binary
   deploy counterpart to `ServeDir`.
 
+[0.2.0]: https://github.com/Climactic/Veer/compare/v0.1.2...HEAD
 [0.1.2]: https://github.com/Climactic/Veer/compare/v0.1.1...v0.1.2
diff --git a/Cargo.toml b/Cargo.toml
index 9ca6948..fd46677 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "veer"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.88"
 license = "MIT OR Apache-2.0"
@@ -47,16 +47,16 @@ reqwest = { version = "0.13", default-features = false, features = ["json", "rus
 cookie = { version = "0.18", optional = true }
 hmac = { version = "0.13", optional = true }
 sha2 = { version = "0.11", optional = true }
-base64 = { version = "0.22", optional = true }
-getrandom = { version = "0.3", optional = true }
+base64 = { version = "0.23", optional = true }
+getrandom = { version = "0.4", optional = true }
 subtle = { version = "2", optional = true }
 
 tower-sessions = { version = "0.15", optional = true }
 
-validator = { version = "0.20", features = ["derive"], optional = true }
+validator = { version = "0.21", features = ["derive"], optional = true }
 garde = { version = "0.23", features = ["derive", "email"], optional = true }
 
-ts-rs = { version = "11", optional = true }
+ts-rs = { version = "12", optional = true }
 inventory = { version = "0.3", optional = true }
 
 [dev-dependencies]
diff --git a/README.md b/README.md
index 0b1c77f..29528c2 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Build modern single-page apps in React, Vue, or Svelte — without writing a JSO
 [![Latest Version on crates.io](https://img.shields.io/crates/v/veer.svg?style=for-the-badge)](https://crates.io/crates/veer)
 [![GitHub CI Status](https://img.shields.io/github/actions/workflow/status/climactic/veer/ci.yml?branch=main&label=ci&style=for-the-badge)](https://github.com/climactic/veer/actions?query=workflow%3Aci+branch%3Amain)
 [![docs.rs](https://img.shields.io/docsrs/veer?style=for-the-badge)](https://docs.rs/veer)
-[![MSRV 1.85](https://img.shields.io/badge/MSRV-1.85-blue?style=for-the-badge)](https://www.rust-lang.org)
+[![MSRV 1.88](https://img.shields.io/badge/MSRV-1.88-blue?style=for-the-badge)](https://www.rust-lang.org)
 [![Sponsor on GitHub](https://img.shields.io/badge/Sponsor-GitHub-ea4aaa?style=for-the-badge&logo=github)](https://github.com/sponsors/climactic)
 [![Support on Ko-fi](https://img.shields.io/badge/Support-Ko--fi-FF5E5B?style=for-the-badge&logo=ko-fi&logoColor=white)](https://ko-fi.com/ClimacticCo)
 
@@ -42,7 +42,7 @@ Build modern single-page apps in React, Vue, or Svelte — without writing a JSO
 
 [Inertia.js](https://inertiajs.com) is a glue layer that lets a classic server-rendered backend drive a modern SPA frontend. The server returns a page object (component name + props); the official Inertia client adapter for React/Vue/Svelte takes care of mounting the component, hydrating props, intercepting links, and making subsequent navigations into JSON XHRs.
 
-`veer` is a clean-room Rust implementation of the server side of the [Inertia v3 protocol](https://inertiajs.com/the-protocol). It targets [axum](https://github.com/tokio-rs/axum) out of the box; the protocol core is framework-agnostic, so adapters for other Rust web frameworks slot in beside it.
+`veer` is a clean-room Rust implementation of the server side of the [Inertia v3 protocol](https://inertiajs.com/docs/v3/core-concepts/the-protocol). It targets [axum](https://github.com/tokio-rs/axum) out of the box; the protocol core is framework-agnostic, so adapters for other Rust web frameworks slot in beside it.
 
 ```text
    ┌─────────────────────────┐                       ┌─────────────────────────┐
@@ -58,7 +58,7 @@ Build modern single-page apps in React, Vue, or Svelte — without writing a JSO
 - 🦀 Pure Rust server-side implementation of Inertia v3
 - ⚡ First-class [axum](https://github.com/tokio-rs/axum) adapter (extractor + tower layer)
 - 🧩 Framework-agnostic protocol core — drop new adapters in beside the axum one
-- 📦 Partial reloads, deferred props, merge props, encrypted/clear history
+- 📦 Partial reloads, deferred / optional / once props, merge / prepend / deep-merge props, infinite scroll, flash data, encrypted/clear history, big integers, Precognition
 - 🖥️ SSR via `@inertiajs/server` (Node or Bun) with graceful fallback
 - ⚙️ Vite dev + production manifest integration that mirrors Laravel's `@vite`
 - 📤 File uploads via typed `InertiaForm` + a streaming `MultipartStream` extractor
@@ -71,7 +71,7 @@ Add `veer` to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-veer = "0.1"
+veer = "0.2"
 ```
 
 Or with `cargo add`:
@@ -133,7 +133,15 @@ async fn users_create(
 
 `InertiaForm` accepts `application/json`, `application/x-www-form-urlencoded`, and (with the `multipart` feature) `multipart/form-data`. The same handler works regardless of how the Inertia client serialized the request.
 
-On the frontend, `usePage().props.errors` and `usePage().props.flash` are auto-populated whenever a `SessionStore` is configured — no extra wiring.
+On the frontend, `usePage().props.errors` and `usePage().flash` are auto-populated whenever a `SessionStore` is configured — no extra wiring. Flash data is the page object's top-level `flash`, so the client does not keep it in the history state. A request that sends `X-Inertia-Error-Bag` (the `errorBag` visit option) gets its errors nested under that bag name.
+
+For live validation ([Precognition](https://inertiajs.com/docs/v3/the-basics/forms#precognition)), answer the validation request before the action runs:
+
+```rust,ignore
+if let Some(precognition) = inertia.precognition() {
+    return precognition.respond(body.validate());   // 204, or 422 with the errors
+}
+```
 
 </details>
 
@@ -186,29 +194,57 @@ async fn oauth_start(inertia: Inertia) -> impl IntoResponse {
 }
 ```
 
-Returns 409 + `X-Inertia-Location`. The Inertia client honors this with a hard navigation.
+An Inertia request gets 409 + `X-Inertia-Location`, which the client honors with a hard navigation. A plain browser request gets a normal 302.
+
+`inertia.redirect("/docs#install")` (a target with a URL fragment) becomes 409 + `X-Inertia-Redirect` for Inertia requests, because XHR drops the fragment of a followed redirect. To keep the fragment of the *original* request instead, call `.preserve_fragment()` on the redirect.
 
 </details>
 
 <details>
-<summary><b>Partial reloads, lazy & deferred props</b></summary>
+<summary><b>Partial reloads, lazy, deferred, once, merge & scroll props</b></summary>
 
 ```rust,ignore
 inertia
-    .render("Users/Index", serde_json::json!({ "users": users }))
+    .render("Users/Index", serde_json::json!({ "users": users, "notifications": notifications }))
     .lazy("stats", || async { json!({ "hits": load_stats().await }) })
     .deferred("expensive", "dashboard", || async { json!(load_expensive().await) })
-    .merge("notifications")
+    .once("plans", || async { json!(load_plans().await) })
+    .prepend("notifications")
+    .match_on("notifications.id")
+    .prop("posts", Prop::scroll(move || async move {
+        let page = load_posts(page_no).await;
+        (json!({ "data": page.items }), ScrollMetadata::paged("page", page_no, page.has_more))
+    }))
+    .prop("permissions", Prop::try_new(|| async { load_permissions().await.map(|p| json!(p)) }).defer().rescue())
 ```
 
 | Method | Behavior |
 |---|---|
 | `lazy(key, closure)` (alias `optional`) | Closure only runs when the client requests this key via a partial reload |
 | `deferred(key, group, closure)` | First response advertises the key under `deferredProps[group]`; client then issues a follow-up reload that resolves it |
-| `merge(key)` | Marks the key so the client merges the value into existing state instead of replacing |
-| `encrypt_history()` / `clear_history()` | Set the Inertia v2+ history-state primitives |
+| `once(key, closure)` | Resolved one time; the client remembers the value across pages (`onceProps`) and the closure is skipped while the client holds it |
+| `merge(path)` / `prepend(path)` / `deep_merge(path)` | The client appends / prepends / deep-merges the value into existing state instead of replacing it. Dot paths merge a nested array (`posts.data`) |
+| `match_on("posts.id")` | Field that identifies an item, so that a merge updates it in place (`matchPropsOn`) |
+| `prop(key, Prop)` | Attach a composable closure prop (see below) |
+| `encrypt_history()` / `clear_history()` | Set the history-state primitives. `InertiaConfig::encrypt_history(true)` turns encryption on for every page |
+| `preserve_big_integers(bool)` | Send integers outside the JavaScript safe range as `{"$bigint": "…"}`, which the client (3.8+) revives as `BigInt`. `InertiaConfig::preserve_big_integers(true)` sets the default |
 | `no_ssr()` | Skip SSR for this response only |
 
+`inertia.with_errors(errors)` keeps all messages of a field. `props.errors` has the first message as a string by default; `InertiaConfig::with_all_errors(true)` sends all of them as an array.
+
+`Prop` composes the Inertia categories the way the protocol does. A dot path as key (`.prop("auth.permissions", …)`) puts the prop inside a nested object:
+
+| Constructor / modifier | Behavior |
+|---|---|
+| `Prop::new(closure)` | Resolved on full visits and on partial reloads that select it |
+| `Prop::try_new(closure)` | Closure returns `Result`. On `Err` the response is a 500, unless the prop has `.rescue()`: then the prop is left out and its key goes into `rescuedProps` (the `rescue` slot of `<Deferred>`) |
+| `Prop::scroll(closure)` | [Infinite scroll](https://inertiajs.com/docs/v3/data-props/infinite-scroll): closure returns `(value, ScrollMetadata)`; emits `scrollProps` and merges at `<key>.data` (`.wrapper("items")` changes the key). Honors the client's append/prepend intent and reset |
+| `.optional()` / `.defer()` / `.group("name")` | When the prop loads |
+| `.once()` / `.once_as("key")` / `.until(duration)` / `.fresh()` | Once behavior: custom key, expiry, forced refresh |
+| `.merge()` / `.prepend()` / `.deep_merge()` / `.append_at("data")` / `.prepend_at("data")` / `.match_on("id")` | Merge behavior, relative to the prop |
+
+Partial reloads follow the v3 rules: `only` and `except` take dot paths (`user.name`), `errors` and `Always<T>` values are always sent, and a prop named in `X-Inertia-Reset` is sent without its merge label. `InertiaConfig::share_once(key, closure)` shares a once prop with every page.
+
 </details>
 
 <details>
@@ -242,7 +278,7 @@ let cfg = InertiaConfig::new()
     .ssr(HttpSsrClient::new("http://127.0.0.1:13714/render"));
 ```
 
-SSR failures fall back to client-side rendering by default. Set `ssr_required(true)` for hard-fail behavior.
+SSR failures fall back to client-side rendering by default, and the log has the error detail from the SSR server. Set `ssr_required(true)` for hard-fail behavior. `HttpSsrClient::timeout(duration)` changes the request timeout (default 5 seconds), and `client.health().await` tells you if the SSR server is up.
 
 For end-to-end SSR you'll usually combine this with `ViteRootView` (next entry) — `ViteRootView` inlines the SSR body verbatim and emits the `<script data-page>` mount the Inertia v3 client expects.
 
@@ -296,10 +332,26 @@ For SSR in production, build the sidecar with `vite build --ssr frontend/ssr.tsx
 
 </details>
 
+<details>
+<summary><b>Inertia DevTools</b></summary>
+
+veer implements the [DevTools protocol](https://inertiajs.com/docs/v3/advanced/devtools-protocol), so the Inertia DevTools browser extension shows each request with its props, headers and route.
+
+```rust,ignore
+let mut cfg = InertiaConfig::new();
+if cfg!(debug_assertions) {
+    cfg = cfg.devtools(veer::DevTools::new());
+}
+```
+
+`InertiaLayer` then records one entry for each request (in memory, the 100 newest for each browser tab), adds the `X-Inertia-Devtools-Id` headers, and serves `GET /_inertia/devtools/entries[/{id}]`. Sensitive keys (`password`, `token`, …) and headers (`Cookie`, `Authorization`, …) are redacted. The read API is open by default, so enable the recorder in development only; `DevTools::new().authorize(|request| …)` adds a guard. Source-location links ("open in editor") are not available.
+
+</details>
+
 <details>
 <summary><b>CSRF protection (Inertia/axios)</b></summary>
 
-The Inertia client uses axios, which reads an `XSRF-TOKEN` cookie and echoes it
+The Inertia client reads an `XSRF-TOKEN` cookie and echoes it
 back in an `X-XSRF-TOKEN` header on every mutating request — no frontend code
 needed. `CsrfLayer` is the server side of that convention: it issues the cookie
 and verifies the header using a stateless, HMAC-signed double-submit token (no
@@ -382,8 +434,8 @@ Enable the `ts` feature and the frontend gets an auto-generated `gen/` directory
 
 ```toml
 [dependencies]
-veer = { version = "0.1", features = ["ts"] }
-ts-rs = "10"
+veer = { version = "0.2", features = ["ts"] }
+ts-rs = "12"
 ```
 
 Annotate each prop struct and register it as a page:
@@ -605,7 +657,9 @@ The protocol core has zero I/O and zero framework deps — pure data structures
 
 ## ⚠️ Caveats
 
-> `Always<T>` and `Merge<T>` are detected at any depth and through any serialization path — typed `#[derive(Serialize)]` structs, `serde_json::json!`, hand-built `Value`s, mixed maps. Only top-level matches affect the Inertia wire format though, because the protocol has no notion of a "nested merge prop". Wrappers placed deeper are still stripped from the JSON sent to the client; they just don't appear in `mergeProps`.
+> `Always<T>` and `Merge<T>` are detected at any depth and through any serialization path — typed `#[derive(Serialize)]` structs, `serde_json::json!`, hand-built `Value`s, mixed maps. A nested wrapper acts at its dot path: `Merge` adds the path (`posts.data`) to `mergeProps`, and `Always` keeps the value through partial-reload filters.
+>
+> An empty `200` response to an Inertia request becomes a redirect back (`Referer`, or `/`), as in the Laravel adapter, because the client cannot render it.
 
 ## 🧪 Example App
 
@@ -623,7 +677,7 @@ bun dev
 
 ## 🗺️ Status & Roadmap
 
-`veer` is pre-1.0. The v0.1 protocol surface is complete (all Inertia v3 features: partial reloads, deferred props, merge props, encrypted/clear history, SSR, asset versioning, validation flash). Planned for follow-ups:
+`veer` is pre-1.0. The protocol surface follows Inertia v3 as of client 3.8 / `inertia-laravel` 3.5 (partial reloads, deferred / optional / once props, merge props, infinite scroll, flash data, history encryption, fragment redirects, big integers, Precognition, SSR, asset versioning, validation errors, DevTools). Planned for follow-ups:
 
 - Adapters for `actix-web` and `rocket`
 - Typed route-param inference (today: `string | number`; goal: read each handler's `Path` extractor and emit the matching TS type)
@@ -646,7 +700,7 @@ Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed re
 
 ## 🤝 Contributing
 
-Please see [CONTRIBUTING](CONTRIBUTING.md) for details.
+Issues and pull requests are welcome.
 You can also join our Discord server to discuss ideas and get help: [Discord Invite](http://go.climactic.co/discord).
 
 ## 🔒 Security Vulnerabilities
diff --git a/examples/axum-react-todo/Cargo.toml b/examples/axum-react-todo/Cargo.toml
index 4fd8729..5fa7d6c 100644
--- a/examples/axum-react-todo/Cargo.toml
+++ b/examples/axum-react-todo/Cargo.toml
@@ -16,5 +16,5 @@ serde_json = "1"
 tower = "0.5"
 tracing = "0.1"
 tracing-subscriber = "0.3"
-validator = { version = "0.20", features = ["derive"] }
-ts-rs = "11"
+validator = { version = "0.21", features = ["derive"] }
+ts-rs = "12"
diff --git a/examples/axum-react-todo/frontend/components/Layout.tsx b/examples/axum-react-todo/frontend/components/Layout.tsx
index c5119bc..90da6f7 100644
--- a/examples/axum-react-todo/frontend/components/Layout.tsx
+++ b/examples/axum-react-todo/frontend/components/Layout.tsx
@@ -1,11 +1,8 @@
 import { Link, usePage } from "@inertiajs/react";
 import type { ReactNode } from "react";
 
-type Flash = { success?: string };
-
 export default function Layout({ children }: { children: ReactNode }) {
-  const { props } = usePage<{ flash?: Flash }>();
-  const success = props.flash?.success;
+  const success = usePage().flash.success as string | undefined;
 
   return (
     <div className="layout">
@@ -17,6 +14,7 @@ export default function Layout({ children }: { children: ReactNode }) {
           <nav className="layout-nav">
             <Link href="/">home</Link>
             <Link href="/todos">todos</Link>
+            <Link href="/showcase">showcase</Link>
           </nav>
         </div>
       </header>
diff --git a/examples/axum-react-todo/frontend/gen/actions/showcase.ts b/examples/axum-react-todo/frontend/gen/actions/showcase.ts
new file mode 100644
index 0000000..5c30de9
--- /dev/null
+++ b/examples/axum-react-todo/frontend/gen/actions/showcase.ts
@@ -0,0 +1,10 @@
+// This file is auto-generated by veer. Do not edit manually.
+// Run `cargo run --bin gen-bindings` to regenerate.
+
+export const jump = Object.assign(
+  () => ({ url: "/showcase/jump", method: "post" } as const),
+  {
+    url: () => "/showcase/jump",
+    form: () => ({ action: "/showcase/jump", method: "post" } as const),
+  },
+);
diff --git a/examples/axum-react-todo/frontend/gen/index.ts b/examples/axum-react-todo/frontend/gen/index.ts
index d155193..2a6b361 100644
--- a/examples/axum-react-todo/frontend/gen/index.ts
+++ b/examples/axum-react-todo/frontend/gen/index.ts
@@ -9,30 +9,48 @@ export interface PageObject<P = Pages> {
   version: string;
   encryptHistory?: boolean;
   clearHistory?: boolean;
+  preserveFragment?: boolean;
+  preserveBigIntegers?: boolean;
+  sharedProps?: string[];
   mergeProps?: string[];
-  resetMergeProps?: string[];
+  prependProps?: string[];
+  deepMergeProps?: string[];
+  matchPropsOn?: string[];
   deferredProps?: Record<string, string[]>;
+  rescuedProps?: string[];
+  scrollProps?: Record<string, ScrollProp>;
+  onceProps?: Record<string, { prop: string; expiresAt: number | null }>;
+  flash?: Flash;
+}
+
+export interface ScrollProp {
+  pageName: string;
+  previousPage: number | string | null;
+  nextPage: number | string | null;
+  currentPage: number | string | null;
+  reset: boolean;
 }
 
 export type ErrorBag = Record<string, string>;
 
-export interface Flash {
-  errors: ErrorBag;
-  bags: Record<string, unknown>;
-}
+export type Flash = Record<string, unknown>;
+
+export type HomeProps = Record<symbol, never>;
 
-export type HomeProps = Record<string, never>;
+export type ShowcaseProps = Record<symbol, never>;
 
 export type Todo = { id: bigint, title: string, done: boolean, };
 
-export type TodosCreateProps = Record<string, never>;
+export type TodosCreateProps = Record<symbol, never>;
 
 export type TodosIndexProps = { todos: Array<Todo>, };
 
 export type Pages =
   | { component: "home"; props: HomeProps }
+  | { component: "showcase"; props: ShowcaseProps }
   | { component: "todos/create"; props: TodosCreateProps }
   | { component: "todos/index"; props: TodosIndexProps };
 
 export * as _root from "./actions/_root";
+export * as showcase from "./actions/showcase";
 export * as todos from "./actions/todos";
diff --git a/examples/axum-react-todo/frontend/pages/showcase.tsx b/examples/axum-react-todo/frontend/pages/showcase.tsx
new file mode 100644
index 0000000..f2ff8b1
--- /dev/null
+++ b/examples/axum-react-todo/frontend/pages/showcase.tsx
@@ -0,0 +1,54 @@
+import { Deferred, InfiniteScroll, router, usePage } from "@inertiajs/react";
+import Button from "../components/Button";
+import Layout from "../components/Layout";
+import { showcase } from "../gen";
+
+type Item = { id: number; title: string };
+
+// The closure props that the handler attaches (see `showcase` in src/lib.rs).
+type Props = {
+  plans: string[];
+  stats?: { todos: number };
+  feed: { data: Item[] };
+};
+
+export default function Showcase() {
+  const { props } = usePage<Props>();
+
+  return (
+    <Layout>
+      <h1>Showcase</h1>
+
+      <h2>Once prop</h2>
+      <p id="plans">Plans: {props.plans.join(", ")}</p>
+
+      <h2>Deferred prop</h2>
+      <Deferred data="stats" fallback={<p>Loading stats…</p>}>
+        <p id="stats">{props.stats?.todos} todos in the store</p>
+      </Deferred>
+
+      <h2>Rescued prop</h2>
+      <Deferred
+        data="broken"
+        fallback={<p>Loading…</p>}
+        rescue={<p id="rescued">This prop failed on the server.</p>}
+      >
+        <p>Not shown: the prop always fails.</p>
+      </Deferred>
+
+      <h2>Fragment redirect</h2>
+      <Button onClick={() => router.post(showcase.jump.url())}>
+        Jump to the feed
+      </Button>
+
+      <h2 id="feed">Infinite scroll</h2>
+      <InfiniteScroll data="feed">
+        <ul className="todos">
+          {props.feed.data.map((item) => (
+            <li key={item.id}>{item.title}</li>
+          ))}
+        </ul>
+      </InfiniteScroll>
+    </Layout>
+  );
+}
diff --git a/examples/axum-react-todo/frontend/pages/todos/create.tsx b/examples/axum-react-todo/frontend/pages/todos/create.tsx
index 5a6f985..93dc8da 100644
--- a/examples/axum-react-todo/frontend/pages/todos/create.tsx
+++ b/examples/axum-react-todo/frontend/pages/todos/create.tsx
@@ -5,7 +5,9 @@ import Layout from "../../components/Layout";
 import { todos } from "../../gen";
 
 export default function Create() {
-  const form = useForm({ title: "" });
+  // The (method, url, data) form enables Precognition: `validate` asks the
+  // server to check a field without running the action.
+  const form = useForm("post", todos.store.url(), { title: "" });
 
   return (
     <Layout>
@@ -13,7 +15,7 @@ export default function Create() {
       <form
         onSubmit={(e) => {
           e.preventDefault();
-          form.post(todos.store.url());
+          form.submit();
         }}
       >
         <Field
@@ -22,6 +24,7 @@ export default function Create() {
           autoFocus
           value={form.data.title}
           onChange={(e) => form.setData("title", e.target.value)}
+          onBlur={() => form.validate("title")}
           error={form.errors.title}
         />
         <div className="actions">
diff --git a/examples/axum-react-todo/frontend/ssr.tsx b/examples/axum-react-todo/frontend/ssr.tsx
index e54c781..a7216bf 100644
--- a/examples/axum-react-todo/frontend/ssr.tsx
+++ b/examples/axum-react-todo/frontend/ssr.tsx
@@ -4,7 +4,7 @@
 //
 // Pages are imported into a static map rather than via Vite's
 // `import.meta.glob` — that's a Vite-specific transform Bun doesn't apply
-// when running this file directly, and a 3-page demo doesn't need the
+// when running this file directly, and a 4-page demo doesn't need the
 // dynamic version. For production, swap to `vite build --ssr frontend/ssr.tsx`
 // and run the built bundle; the SSR adapter compiles the glob away anyway.
 
@@ -14,11 +14,13 @@ import ReactDOMServer from "react-dom/server";
 import type { ComponentType } from "react";
 
 import Home from "./pages/home";
+import Showcase from "./pages/showcase";
 import TodosIndex from "./pages/todos/index";
 import TodosCreate from "./pages/todos/create";
 
 const pages: Record<string, ComponentType<any>> = {
   home: Home,
+  showcase: Showcase,
   "todos/index": TodosIndex,
   "todos/create": TodosCreate,
 };
diff --git a/examples/axum-react-todo/package.json b/examples/axum-react-todo/package.json
index ccb5b1f..e79a18b 100644
--- a/examples/axum-react-todo/package.json
+++ b/examples/axum-react-todo/package.json
@@ -9,15 +9,15 @@
     "ssr:dev": "bun frontend/ssr.tsx"
   },
   "dependencies": {
-    "@inertiajs/react": "^3.1.1",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6"
+    "@inertiajs/react": "^3.7.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
   },
   "devDependencies": {
-    "@types/react": "^19.2.15",
-    "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^6.0.2",
-    "typescript": "^6.0.3",
-    "vite": "^8.0.13"
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.1"
   }
 }
diff --git a/examples/axum-react-todo/src/lib.rs b/examples/axum-react-todo/src/lib.rs
index f62b42b..1b4e423 100644
--- a/examples/axum-react-todo/src/lib.rs
+++ b/examples/axum-react-todo/src/lib.rs
@@ -1,10 +1,12 @@
 pub mod todos;
 
-use axum::extract::{Path, State};
-use serde_json::json;
-use todos::{HomeProps, NewTodo, TodoStore, TodosCreateProps, TodosIndexProps};
+use axum::extract::{Path, Query, State};
+use axum::response::IntoResponse;
+use serde_json::{json, Value};
+use std::time::Duration;
+use todos::{HomeProps, NewTodo, ShowcaseProps, TodoStore, TodosCreateProps, TodosIndexProps};
 use validator::Validate;
-use veer::{Inertia, InertiaForm, Method::*};
+use veer::{Inertia, InertiaForm, Method::*, Prop, ScrollMetadata};
 
 /// Build the named-route table. Used by `main.rs` for serving and by
 /// `src/bin/gen-bindings.rs` to populate the TS bindings registry.
@@ -15,6 +17,57 @@ pub fn router() -> veer::Router<TodoStore> {
         .named_route(POST, "todos.store", "/todos", todos_create)
         .named_route(GET, "todos.create", "/todos/new", todos_new)
         .named_route(DELETE, "todos.destroy", "/todos/{id}", todos_delete)
+        .named_route(GET, "showcase", "/showcase", showcase)
+        .named_route(POST, "showcase.jump", "/showcase/jump", showcase_jump)
+}
+
+#[derive(serde::Deserialize)]
+struct ShowcaseQuery {
+    page: Option<u64>,
+}
+
+/// One page that uses the closure prop types: once, deferred, rescued, and
+/// infinite scroll.
+async fn showcase(
+    inertia: Inertia,
+    State(store): State<TodoStore>,
+    Query(query): Query<ShowcaseQuery>,
+) -> impl IntoResponse {
+    let page = query.page.unwrap_or(1).clamp(1, 3);
+    inertia
+        .render("showcase", ShowcaseProps {})
+        .once("plans", || async { json!(["Free", "Pro", "Team"]) })
+        .deferred("stats", "default", move || async move {
+            tokio::time::sleep(Duration::from_millis(300)).await;
+            json!({ "todos": store.all().len() })
+        })
+        .prop(
+            "broken",
+            Prop::try_new(|| async { Err::<Value, _>("simulated failure") })
+                .group("unstable")
+                .rescue(),
+        )
+        .prop(
+            "feed",
+            Prop::scroll(move || async move {
+                let first = (page - 1) * 20;
+                let items: Vec<Value> = (first + 1..=first + 20)
+                    .map(|n| json!({ "id": n, "title": format!("Item {n}") }))
+                    .collect();
+                (
+                    json!({ "data": items }),
+                    ScrollMetadata::paged("page", page, page < 3),
+                )
+            })
+            .match_on("data.id"),
+        )
+}
+
+/// A redirect whose target has a URL fragment (409 + `X-Inertia-Redirect`).
+async fn showcase_jump(inertia: Inertia) -> impl IntoResponse {
+    inertia
+        .redirect("/showcase#feed")
+        .with_flash("success", json!("Jumped to the feed"))
 }
 
 async fn home(inertia: Inertia) -> impl axum::response::IntoResponse {
@@ -36,14 +89,22 @@ async fn todos_create(
     inertia: Inertia,
     State(store): State<TodoStore>,
     InertiaForm(body): InertiaForm<NewTodo>,
-) -> impl axum::response::IntoResponse {
+) -> axum::response::Response {
+    // Live validation (Precognition): answer and do not create the todo.
+    if let Some(precognition) = inertia.precognition() {
+        return precognition.respond(body.validate());
+    }
     if let Err(errors) = body.validate() {
-        return inertia.with_errors(errors).redirect("/todos/new");
+        return inertia
+            .with_errors(errors)
+            .redirect("/todos/new")
+            .into_response();
     }
     store.add(body.title);
     inertia
         .redirect("/todos")
         .with_flash("success", json!("Todo created"))
+        .into_response()
 }
 
 async fn todos_delete(
diff --git a/examples/axum-react-todo/src/main.rs b/examples/axum-react-todo/src/main.rs
index eb2c679..7cfc1d6 100644
--- a/examples/axum-react-todo/src/main.rs
+++ b/examples/axum-react-todo/src/main.rs
@@ -1,8 +1,8 @@
 use axum_react_todo::{router, todos::TodoStore};
 use std::net::SocketAddr;
 use veer::{
-    session::cookie::CookieSessionStore, ssr::http::HttpSsrClient, CsrfLayer, InertiaConfig,
-    InertiaLayer, ViteRootView,
+    session::cookie::CookieSessionStore, ssr::http::HttpSsrClient, CsrfLayer, DevTools,
+    InertiaConfig, InertiaLayer, ViteRootView,
 };
 
 #[tokio::main]
@@ -29,13 +29,21 @@ async fn main() {
     let mut cfg = InertiaConfig::new().version(|| "dev".into()).session(
         CookieSessionStore::new(b"01234567890123456789012345678901".to_vec()).secure(false),
     );
+    // Record requests for the Inertia DevTools browser extension. The read
+    // API has no authorization, so this is for debug builds only.
+    if cfg!(debug_assertions) {
+        cfg = cfg.devtools(DevTools::new());
+    }
     if ssr_mode {
+        // `VITE_DEV_SERVER` lets you move Vite off :5173 (`bun dev --port 5174`).
+        let vite = std::env::var("VITE_DEV_SERVER")
+            .unwrap_or_else(|_| "http://localhost:5173".to_string());
         cfg = cfg
             .root_view(
                 ViteRootView::dev()
                     .title("veer todo")
                     .entry("frontend/app.tsx")
-                    .dev_server("http://localhost:5173")
+                    .dev_server(vite)
                     .react_refresh(true),
             )
             .ssr(HttpSsrClient::new("http://127.0.0.1:13714/render"))
diff --git a/examples/axum-react-todo/src/todos.rs b/examples/axum-react-todo/src/todos.rs
index 20b95f3..ecade24 100644
--- a/examples/axum-react-todo/src/todos.rs
+++ b/examples/axum-react-todo/src/todos.rs
@@ -13,7 +13,7 @@ pub struct Todo {
 
 #[derive(Deserialize, Validate)]
 pub struct NewTodo {
-    #[validate(length(min = 1, message = "title is required"))]
+    #[validate(length(min = 3, message = "title must have at least 3 characters"))]
     pub title: String,
 }
 
@@ -54,6 +54,13 @@ impl TodoStore {
 pub struct HomeProps {}
 veer::register_page!(HomeProps, "home");
 
+/// The closure props of the showcase page (`plans`, `stats`, `broken`, `feed`)
+/// are attached in the handler, so they are not part of this type.
+#[derive(Serialize, TS)]
+#[ts(export)]
+pub struct ShowcaseProps {}
+veer::register_page!(ShowcaseProps, "showcase");
+
 #[derive(Serialize, TS)]
 #[ts(export)]
 pub struct TodosIndexProps {
diff --git a/examples/axum-react-todo/tsconfig.json b/examples/axum-react-todo/tsconfig.json
index 2b1567c..e6ad503 100644
--- a/examples/axum-react-todo/tsconfig.json
+++ b/examples/axum-react-todo/tsconfig.json
@@ -11,7 +11,8 @@
     "isolatedModules": true,
     "noEmit": true,
     "jsx": "react-jsx",
-    "strict": true
+    "strict": true,
+    "types": ["vite/client"]
   },
   "include": ["frontend"]
 }
diff --git a/src/adapters/axum/extractor.rs b/src/adapters/axum/extractor.rs
index 76e9459..ad4e20d 100644
--- a/src/adapters/axum/extractor.rs
+++ b/src/adapters/axum/extractor.rs
@@ -17,6 +17,8 @@ pub(crate) struct PerRequest {
     /// `SessionStore::write` hook can recover session middleware handles
     /// (`tower-sessions::Session`, etc.) that live in request extensions.
     pub req_extensions: Arc<Extensions>,
+    /// Id of the DevTools entry of this request, when the recorder is on.
+    pub devtools_id: Option<String>,
 }
 
 impl<S> FromRequestParts<S> for Inertia
diff --git a/src/adapters/axum/layer.rs b/src/adapters/axum/layer.rs
index 99ce2f4..59d608c 100644
--- a/src/adapters/axum/layer.rs
+++ b/src/adapters/axum/layer.rs
@@ -2,12 +2,17 @@
 //! finalizes any `InertiaResponseMarker` produced by handlers.
 
 use super::extractor::PerRequest;
-use super::response::{finalize, InertiaResponseMarker};
+use super::response::{
+    finalize, finish_with_flash, redirect, version_mismatch, InertiaResponseMarker, RecordedPage,
+};
 use crate::config::InertiaConfig;
+use crate::devtools::{self, Finished};
+use crate::headers as veer_headers;
+use crate::protocol::is_version_mismatch;
 use crate::request::RequestInfo;
 use crate::session::Flash;
 use axum::body::Body;
-use axum::http::{Method, Request, Response, StatusCode};
+use axum::http::{HeaderValue, Method, Request, Response, StatusCode};
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -64,8 +69,26 @@ where
         let cfg = self.config.clone();
         let mut inner = self.inner.clone();
         Box::pin(async move {
+            let (mut parts, mut body) = req.into_parts();
+
+            // DevTools: answer the read API, or start a recording.
+            let mut recording = None;
+            let mut request_body = devtools::body_empty();
+            if let Some(devtools) = &cfg.devtools {
+                if let Some((status, json)) = devtools.read_api(&parts) {
+                    let mut resp = Response::new(Body::from(json));
+                    *resp.status_mut() = status;
+                    resp.headers_mut().insert(
+                        http::header::CONTENT_TYPE,
+                        HeaderValue::from_static("application/json"),
+                    );
+                    return Ok(resp);
+                }
+                recording = Some(devtools.start(&parts.headers));
+                (body, request_body) = capture_request_body(&parts, body).await;
+            }
+
             // Read flash from session (if configured).
-            let (mut parts, body) = req.into_parts();
             let flash = if let Some(s) = &cfg.session {
                 s.read_and_clear(&parts).await
             } else {
@@ -88,19 +111,18 @@ where
                 config: cfg.clone(),
                 flash: Arc::new(flash),
                 req_extensions: extensions_snapshot.clone(),
+                devtools_id: recording.as_ref().map(|r| r.id.clone()),
             };
             parts.extensions.insert(per_request.clone());
 
             let request = Request::from_parts(parts, body);
             let mut resp = inner.call(request).await?;
 
+            let req_info =
+                RequestInfo::from_parts(method_for_post.clone(), url_for_finalize, &headers_clone);
+
             // If handler returned an Inertia marker, finalize.
             if let Some(marker) = resp.extensions_mut().remove::<InertiaResponseMarker>() {
-                let req_info = RequestInfo::from_parts(
-                    method_for_post.clone(),
-                    url_for_finalize,
-                    &headers_clone,
-                );
                 // Marker wraps Arc<Mutex<Option<InertiaResponse>>>. Take the inner value.
                 let inner_response = marker
                     .0
@@ -111,19 +133,136 @@ where
                     resp = finalize(ir, &per_request, &req_info).await;
                 }
             } else {
-                // If the handler returned a plain 302 from a non-GET, rewrite to 303 per Inertia spec.
-                let status = resp.status();
-                if status == StatusCode::FOUND
-                    && matches!(
-                        method_for_post,
-                        Method::POST | Method::PUT | Method::PATCH | Method::DELETE
-                    )
-                {
-                    *resp.status_mut() = StatusCode::SEE_OTHER;
+                resp = plain_response(resp, &per_request, &req_info).await;
+            }
+
+            // HTML and JSON share a URL, so caches must key on the header.
+            if !resp
+                .headers()
+                .get_all(&veer_headers::VARY)
+                .iter()
+                .any(|v| v.as_bytes().eq_ignore_ascii_case(b"x-inertia"))
+            {
+                resp.headers_mut()
+                    .append(&veer_headers::VARY, HeaderValue::from_static("X-Inertia"));
+            }
+
+            if let Some(recording) = recording {
+                let page = resp.extensions_mut().remove::<RecordedPage>();
+                for (name, value) in [
+                    (devtools::X_INERTIA_DEVTOOLS_ID, recording.id.as_str()),
+                    (
+                        devtools::X_INERTIA_DEVTOOLS_PARENT_OUT,
+                        recording.parent_out(&req_info),
+                    ),
+                ] {
+                    if let Ok(value) = HeaderValue::from_str(value) {
+                        resp.headers_mut().insert(name, value);
+                    }
                 }
+                recording.finish(Finished {
+                    req: &req_info,
+                    request_headers: &headers_clone,
+                    request_body,
+                    status: resp.status(),
+                    response_headers: resp.headers(),
+                    page: page.as_ref().map(|p| &*p.0),
+                    response_is_empty: http_body::Body::size_hint(resp.body()).exact() == Some(0),
+                    route: extensions_snapshot
+                        .get::<axum::extract::MatchedPath>()
+                        .map(|p| p.as_str()),
+                });
             }
 
             Ok(resp)
         })
     }
 }
+
+/// Capture the request body for a DevTools entry. Only a JSON body of a known,
+/// small size is read; it is then handed on unchanged.
+async fn capture_request_body(
+    parts: &http::request::Parts,
+    body: Body,
+) -> (Body, serde_json::Value) {
+    let header = |name| parts.headers.get(name).and_then(|v| v.to_str().ok());
+    let length = header(http::header::CONTENT_LENGTH).and_then(|v| v.parse::<usize>().ok());
+    let is_json = header(http::header::CONTENT_TYPE).is_some_and(|t| t.contains("json"));
+    let is_inertia = header(veer_headers::X_INERTIA) == Some("true");
+    let capture = match length {
+        None | Some(0) if matches!(parts.method, Method::GET | Method::HEAD) => {
+            devtools::body_empty()
+        }
+        Some(0) => devtools::body_empty(),
+        _ if !is_inertia => devtools::body_omitted("non-inertia-request"),
+        None => devtools::body_omitted("streamed"),
+        Some(n) if n > devtools::BODY_LIMIT => devtools::body_omitted("too-large"),
+        Some(_) if !is_json => devtools::body_omitted("non-textual"),
+        Some(n) => {
+            return match axum::body::to_bytes(body, n).await {
+                Ok(bytes) => {
+                    let capture = match serde_json::from_slice(&bytes) {
+                        Ok(value) => devtools::body_present(value),
+                        Err(_) => devtools::body_omitted("unserializable"),
+                    };
+                    (Body::from(bytes), capture)
+                }
+                Err(_) => (Body::empty(), devtools::body_omitted("streamed")),
+            };
+        }
+    };
+    (body, capture)
+}
+
+/// Apply the protocol rules to a response that did not come from
+/// `Inertia::render` / `Inertia::redirect` (for example `axum::response::Redirect`).
+async fn plain_response(
+    mut resp: Response<Body>,
+    per: &PerRequest,
+    req: &RequestInfo,
+) -> Response<Body> {
+    let version = (per.config.version)();
+    let is_redirect = resp.status().is_redirection();
+    let fragment_target = resp
+        .headers()
+        .get(http::header::LOCATION)
+        .and_then(|v| v.to_str().ok())
+        .filter(|l| is_redirect && l.contains('#'))
+        .map(str::to_owned);
+
+    if is_version_mismatch(req, &version) {
+        resp = version_mismatch(&req.url, &version);
+    } else if let (true, false, Some(location)) = (req.is_inertia, req.is_prefetch, fragment_target)
+    {
+        resp = redirect(
+            StatusCode::CONFLICT,
+            veer_headers::X_INERTIA_REDIRECT,
+            &location,
+        );
+    } else if resp.status() == StatusCode::FOUND
+        && matches!(
+            req.method,
+            Method::POST | Method::PUT | Method::PATCH | Method::DELETE
+        )
+    {
+        // A plain 302 from a non-GET becomes a 303 per Inertia spec.
+        *resp.status_mut() = StatusCode::SEE_OTHER;
+    } else if req.is_inertia
+        && resp.status() == StatusCode::OK
+        && http_body::Body::size_hint(resp.body()).exact() == Some(0)
+    {
+        // An empty 200 is not a page. Go back, as the Laravel adapter does.
+        resp = redirect(
+            StatusCode::SEE_OTHER,
+            http::header::LOCATION,
+            req.referer.as_deref().unwrap_or("/"),
+        );
+    }
+
+    // Only a page render uses the flash data. From any other response it goes
+    // on to the request that follows.
+    if per.flash.is_empty() {
+        return resp;
+    }
+    finish_with_flash(resp, (*per.flash).clone(), per).await
+}
diff --git a/src/adapters/axum/mod.rs b/src/adapters/axum/mod.rs
index 8664139..120c675 100644
--- a/src/adapters/axum/mod.rs
+++ b/src/adapters/axum/mod.rs
@@ -3,6 +3,7 @@
 pub mod extractor;
 pub mod form;
 pub mod layer;
+pub mod precognition;
 pub mod response;
 pub mod router;
 
@@ -14,6 +15,7 @@ pub mod embed;
 
 pub use form::{InertiaForm, InertiaFormRejection};
 pub use layer::InertiaLayer;
+pub use precognition::Precognition;
 pub use router::{Method, Router};
 
 #[cfg(feature = "csrf")]
diff --git a/src/adapters/axum/precognition.rs b/src/adapters/axum/precognition.rs
new file mode 100644
index 0000000..2d7c698
--- /dev/null
+++ b/src/adapters/axum/precognition.rs
@@ -0,0 +1,81 @@
+//! Precognition: live validation requests from the Inertia form helpers.
+
+use crate::errors::IntoErrorBag;
+use crate::headers as veer_headers;
+use crate::inertia::Inertia;
+use axum::body::Body;
+use axum::http::{HeaderValue, Response, StatusCode};
+use serde_json::json;
+use std::collections::{BTreeMap, HashSet};
+
+/// A Precognition validation request. See [`Inertia::precognition`].
+#[derive(Debug, Clone)]
+pub struct Precognition {
+    validate_only: HashSet<String>,
+}
+
+impl Inertia {
+    /// `Some` when the request only asks to validate its input
+    /// (`Precognition: true`). Answer it with [`Precognition::respond`] and do
+    /// not run the action:
+    ///
+    /// ```ignore
+    /// if let Some(precognition) = inertia.precognition() {
+    ///     return precognition.respond(form.validate());
+    /// }
+    /// ```
+    pub fn precognition(&self) -> Option<Precognition> {
+        self.request.is_precognition.then(|| Precognition {
+            validate_only: self.request.validate_only.clone(),
+        })
+    }
+}
+
+impl Precognition {
+    /// Build the validation response: `204` when no requested field has an
+    /// error, otherwise `422` with the errors. Only the fields named in
+    /// `Precognition-Validate-Only` are reported when that header is set.
+    pub fn respond<E: IntoErrorBag>(self, result: Result<(), E>) -> Response<Body> {
+        let errors: BTreeMap<String, Vec<String>> = result
+            .err()
+            .map(IntoErrorBag::into_all_errors)
+            .unwrap_or_default()
+            .into_iter()
+            .filter(|(field, _)| {
+                self.validate_only.is_empty() || self.validate_only.contains(field)
+            })
+            .collect();
+
+        let mut response = match errors.values().find_map(|messages| messages.first()) {
+            None => {
+                let mut r = Response::new(Body::empty());
+                *r.status_mut() = StatusCode::NO_CONTENT;
+                r.headers_mut().insert(
+                    &veer_headers::PRECOGNITION_SUCCESS,
+                    HeaderValue::from_static("true"),
+                );
+                r
+            }
+            Some(message) => {
+                let body = json!({ "message": message, "errors": errors });
+                let mut r = Response::new(Body::from(body.to_string()));
+                *r.status_mut() = StatusCode::UNPROCESSABLE_ENTITY;
+                r.headers_mut().insert(
+                    http::header::CONTENT_TYPE,
+                    HeaderValue::from_static("application/json"),
+                );
+                r
+            }
+        };
+        let headers = response.headers_mut();
+        headers.insert(
+            &veer_headers::PRECOGNITION,
+            HeaderValue::from_static("true"),
+        );
+        headers.append(
+            &veer_headers::VARY,
+            HeaderValue::from_static("Precognition"),
+        );
+        response
+    }
+}
diff --git a/src/adapters/axum/response.rs b/src/adapters/axum/response.rs
index 3b8dffb..05dec5a 100644
--- a/src/adapters/axum/response.rs
+++ b/src/adapters/axum/response.rs
@@ -1,25 +1,27 @@
 //! `IntoResponse` for `InertiaResponse` — runs the protocol decision and serializes.
 
 use crate::adapters::axum::extractor::PerRequest;
+use crate::bigint::encode_big_integers;
 use crate::headers as veer_headers;
 use crate::page::PageObject;
-use crate::props::resolver::{resolve, serialize_tag_aware, ResolveInput, SerializedBase};
+use crate::props::resolver::{resolve, serialize_tag_aware, ResolveInput};
+use crate::props::Prop;
 use crate::protocol::{decide, DecisionInputs, ResponseShape};
 use crate::request::RequestInfo;
 use crate::response::InertiaResponse;
 use crate::root_view::RootViewContext;
 use axum::body::Body;
-use axum::http::{HeaderValue, Response, StatusCode};
+use axum::http::{HeaderName, HeaderValue, Response, StatusCode};
 use axum::response::IntoResponse;
-use serde_json::Value;
+use serde_json::{json, Map, Value};
 use std::sync::{Arc, Mutex};
 
 impl IntoResponse for InertiaResponse {
     fn into_response(self) -> Response<Body> {
         // Inertia handle context is recovered via request extensions on the response path
-        // by carrying it inside the response builder. For simplicity in v0.1, we require
-        // the layer to wrap the response after the handler runs. This impl produces a
-        // placeholder; the layer (Task 16) finishes the work using `finalize`.
+        // by carrying it inside the response builder. The layer wraps the response
+        // after the handler runs: this impl produces a placeholder, and the layer
+        // finishes the work using `finalize`.
         let marker = InertiaResponseMarker(Arc::new(Mutex::new(Some(self))));
         let mut resp = Response::new(Body::empty());
         resp.extensions_mut().insert(marker);
@@ -37,182 +39,257 @@ pub(crate) struct InertiaResponseMarker(pub Arc<Mutex<Option<InertiaResponse>>>)
 
 /// Finish the response. Called by the layer with access to per-request state.
 pub(crate) async fn finalize(
-    builder: InertiaResponse,
+    mut builder: InertiaResponse,
     per: &PerRequest,
     req_info: &RequestInfo,
 ) -> Response<Body> {
-    let cfg = per.config.clone();
-    let version_owned = (cfg.version)().into_owned();
+    let cfg = &per.config;
+    let incoming = &*per.flash;
+    let version = (cfg.version)().into_owned();
 
     let decision = decide(DecisionInputs {
         req: req_info,
-        server_version: &version_owned,
-        redirect: builder.redirect.clone(),
+        server_version: &version,
+        redirect: builder.redirect.take(),
         csr_only: cfg.csr_only,
     });
 
-    // Outgoing flash (write later in this function via finish_with_flash).
-    let pending_flash = builder.pending_flash.clone();
+    let mut pending = std::mem::take(&mut builder.pending_flash);
 
-    // Resolve shared + base props.
-    let shared = match &cfg.shared {
-        Some(s) => Some(s.shared(req_info).await),
-        None => None,
+    // Control responses carry no page. The flash data that this request read
+    // goes on to the request that follows.
+    let control = match &decision {
+        ResponseShape::SeeOther { location } => Some(redirect(
+            StatusCode::SEE_OTHER,
+            http::header::LOCATION,
+            location,
+        )),
+        ResponseShape::Found { location } => Some(redirect(
+            StatusCode::FOUND,
+            http::header::LOCATION,
+            location,
+        )),
+        ResponseShape::InertiaLocation { location } => Some(redirect(
+            StatusCode::CONFLICT,
+            veer_headers::X_INERTIA_LOCATION,
+            location,
+        )),
+        ResponseShape::InertiaRedirect { location } => Some(redirect(
+            StatusCode::CONFLICT,
+            veer_headers::X_INERTIA_REDIRECT,
+            location,
+        )),
+        ResponseShape::VersionMismatch { location } => {
+            pending.errors = incoming.errors.clone();
+            Some(version_mismatch(location, &version))
+        }
+        ResponseShape::Html | ResponseShape::Json => None,
     };
+    if let Some(response) = control {
+        for (k, v) in &incoming.bags {
+            pending.bags.entry(k.clone()).or_insert_with(|| v.clone());
+        }
+        pending.clear_history |= builder.clear_history || incoming.clear_history;
+        pending.preserve_fragment |= builder.preserve_fragment || incoming.preserve_fragment;
+        return finish_with_flash(response, pending, per).await;
+    }
 
-    let base_serialized = serialize_tag_aware(&builder.base_props).unwrap_or_else(|e| {
+    // Shared props, plus the always-present `errors`.
+    let mut shared = match &cfg.shared {
+        Some(s) => serialize_tag_aware(&s.shared(req_info).await).unwrap_or_default(),
+        None => Default::default(),
+    };
+    if !shared.value.is_object() {
+        shared.value = Value::Object(Map::new());
+    }
+    // Errors from the previous request, then errors set on this render.
+    let mut all_errors = incoming.errors.clone();
+    all_errors.extend(std::mem::take(&mut pending.errors));
+    let mut errors: Value = all_errors
+        .iter()
+        .map(|(field, messages)| {
+            let value = if cfg.with_all_errors {
+                json!(messages)
+            } else {
+                json!(messages.first())
+            };
+            (field.clone(), value)
+        })
+        .collect::<Map<_, _>>()
+        .into();
+    if let (Some(bag), false) = (&req_info.error_bag, all_errors.is_empty()) {
+        errors = Value::Object(Map::from_iter([(bag.clone(), errors)]));
+    }
+    let mut shared_keys = Vec::new();
+    if let Value::Object(map) = &mut shared.value {
+        map.insert("errors".into(), errors);
+        shared_keys.extend(map.keys().cloned());
+    }
+
+    let base = serialize_tag_aware(&builder.base_props).unwrap_or_else(|e| {
         tracing::error!(error = %e, "veer: failed to serialize base props; using null");
-        SerializedBase {
-            value: Value::Null,
-            always_paths: Default::default(),
-            merge_paths: Default::default(),
-        }
+        Default::default()
     });
 
-    // Auto-inject `errors` and `flash` shared props (always present).
-    let mut shared_value = shared.unwrap_or_else(|| Value::Object(Default::default()));
-    if let Value::Object(map) = &mut shared_value {
-        let errors_value = serde_json::to_value(&per.flash.errors).unwrap_or_else(|e| {
-            tracing::error!(error = %e, "veer: failed to serialize flash errors");
-            Value::Null
-        });
-        map.insert("errors".into(), errors_value);
-        let bags_value = serde_json::to_value(&per.flash.bags).unwrap_or_else(|e| {
-            tracing::error!(error = %e, "veer: failed to serialize flash bags");
-            Value::Null
-        });
-        map.insert("flash".into(), bags_value);
+    // Shared once props. A handler prop with the same key wins.
+    for (key, f) in &cfg.shared_once {
+        shared_keys.push(key.clone());
+        if !builder.props.contains_key(key) && base.value.get(key).is_none() {
+            let value = f(req_info);
+            builder
+                .props
+                .insert(key.clone(), Prop::new(move || value).once());
+        }
     }
+    shared_keys.sort();
+    shared_keys.dedup();
 
     let resolved = resolve(ResolveInput {
         req: req_info,
         component: &builder.component,
-        base: base_serialized,
-        lazies: builder.lazies,
-        deferreds: builder.deferreds,
-        merges: builder.merges,
-        shared: Some(SerializedBase {
-            value: shared_value,
-            always_paths: Default::default(),
-            merge_paths: Default::default(),
-        }),
+        base,
+        shared: Some(shared),
+        props: builder.props,
+        merge: builder.merge,
     })
     .await;
+    let resolved = match resolved {
+        Ok(resolved) => resolved,
+        Err(error) => {
+            tracing::error!(%error, "veer: prop failed to resolve");
+            let mut r = Response::new(Body::from("Internal Server Error"));
+            *r.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+            return finish_with_flash(r, pending, per).await;
+        }
+    };
 
-    let mut page = PageObject::new(
-        &builder.component,
-        resolved.props,
-        &req_info.url,
-        &version_owned,
-    );
-    page.encrypt_history = builder.encrypt_history;
-    page.clear_history = builder.clear_history;
+    let mut page = PageObject::new(&builder.component, resolved.props, &req_info.url, &version);
+    page.encrypt_history = builder.encrypt_history || cfg.encrypt_history;
+    page.clear_history = builder.clear_history || incoming.clear_history;
+    page.preserve_fragment = builder.preserve_fragment || incoming.preserve_fragment;
+    page.shared_props = shared_keys;
     page.merge_props = resolved.merge_props;
+    page.prepend_props = resolved.prepend_props;
+    page.deep_merge_props = resolved.deep_merge_props;
+    page.match_props_on = resolved.match_props_on;
     page.deferred_props = resolved.deferred_props;
-    // Combine builder-attached reset keys with any the client signaled via
-    // `X-Inertia-Reset`, deduped.
-    let mut reset = builder.reset_merge_props.clone();
-    for k in &req_info.reset {
-        if !reset.contains(k) {
-            reset.push(k.clone());
-        }
+    page.rescued_props = resolved.rescued_props;
+    page.scroll_props = resolved.scroll_props;
+    page.once_props = resolved.once_props;
+    // Flash data from the previous request, then data flashed by this handler.
+    page.flash = incoming.bags.clone().into_iter().collect();
+    page.flash.extend(std::mem::take(&mut pending.bags));
+    if builder
+        .preserve_big_integers
+        .unwrap_or(cfg.preserve_big_integers)
+    {
+        page.preserve_big_integers = true;
+        encode_big_integers(&mut page.props);
+        page.flash.values_mut().for_each(encode_big_integers);
     }
-    reset.sort();
-    page.reset_merge_props = reset;
-
-    // Build response based on decision.
-    let response = match decision {
-        ResponseShape::Json => {
-            let body = serde_json::to_vec(&page).unwrap_or_else(|e| {
-                tracing::error!(error = %e, "veer: failed to serialize PageObject as JSON");
-                Vec::new()
-            });
-            let mut r = Response::new(Body::from(body));
-            *r.status_mut() = StatusCode::OK;
-            r.headers_mut().insert(
-                http::header::CONTENT_TYPE,
-                HeaderValue::from_static("application/json"),
-            );
-            r.headers_mut()
-                .insert(&veer_headers::X_INERTIA, HeaderValue::from_static("true"));
-            r.headers_mut()
-                .insert(&veer_headers::VARY, HeaderValue::from_static("X-Inertia"));
-            r
-        }
-        ResponseShape::Html => {
-            let page_json = serde_json::to_string(&page).unwrap_or_else(|e| {
-                tracing::error!(error = %e, "veer: failed to serialize PageObject for HTML embed");
-                String::new()
+
+    // The DevTools recorder reads the page from the response extensions.
+    let recorded = per
+        .devtools_id
+        .as_ref()
+        .map(|_| RecordedPage(Arc::new(serde_json::to_value(&page).unwrap_or_default())));
+
+    let mut response = if decision == ResponseShape::Json {
+        let body = serde_json::to_vec(&page).unwrap_or_else(|e| {
+            tracing::error!(error = %e, "veer: failed to serialize PageObject as JSON");
+            Vec::new()
+        });
+        let mut r = Response::new(Body::from(body));
+        r.headers_mut().insert(
+            http::header::CONTENT_TYPE,
+            HeaderValue::from_static("application/json"),
+        );
+        r.headers_mut()
+            .insert(&veer_headers::X_INERTIA, HeaderValue::from_static("true"));
+        r
+    } else {
+        let page_json = serde_json::to_string(&page).unwrap_or_else(|e| {
+            tracing::error!(error = %e, "veer: failed to serialize PageObject for HTML embed");
+            String::new()
+        });
+        let escaped = html_attr_escape(&page_json);
+        let script_escaped = script_tag_escape(&page_json);
+
+        // Optional SSR.
+        let mut ssr_payload = None;
+        if let (false, Some(client)) = (builder.skip_ssr, &cfg.ssr) {
+            let page_value = serde_json::to_value(&page).unwrap_or_else(|e| {
+                tracing::error!(error = %e, "veer: failed to serialize PageObject for SSR");
+                Value::Null
             });
-            let escaped = html_attr_escape(&page_json);
-            let script_escaped = script_tag_escape(&page_json);
-
-            // Optional SSR.
-            let ssr_payload = if !builder.skip_ssr {
-                if let Some(client) = &cfg.ssr {
-                    let page_value = serde_json::to_value(&page).unwrap_or_else(|e| {
-                        tracing::error!(error = %e, "veer: failed to serialize PageObject for SSR");
-                        Value::Null
-                    });
-                    match client.render(&page_value).await {
-                        Ok(p) => Some(p),
-                        Err(e) => {
-                            if cfg.ssr_required {
-                                let mut r = Response::new(Body::from(format!("ssr failed: {e}")));
-                                *r.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                return finish_with_flash(r, pending_flash, per).await;
-                            }
-                            tracing::warn!(error = ?e, "SSR failed; falling back to client render");
-                            None
-                        }
-                    }
-                } else {
-                    None
+            match client.render(&page_value).await {
+                Ok(p) => ssr_payload = Some(p),
+                Err(e) if cfg.ssr_required => {
+                    let mut r = Response::new(Body::from(format!("ssr failed: {e}")));
+                    *r.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+                    return finish_with_flash(r, pending, per).await;
                 }
-            } else {
-                None
-            };
-
-            let html = cfg
-                .root_view
-                .render(RootViewContext {
-                    page_json: &escaped,
-                    page_json_script: &script_escaped,
-                    asset_version: &version_owned,
-                    ssr: ssr_payload.as_ref(),
-                })
-                .unwrap_or_else(|e| format!("root view error: {e}"));
-            let mut r = Response::new(Body::from(html));
-            r.headers_mut().insert(
-                http::header::CONTENT_TYPE,
-                HeaderValue::from_static("text/html; charset=utf-8"),
-            );
-            r
+                Err(e) => tracing::warn!(error = ?e, "SSR failed; falling back to client render"),
+            }
         }
-        ResponseShape::SeeOther { location } => {
-            let mut r = Response::new(Body::empty());
-            *r.status_mut() = StatusCode::SEE_OTHER;
-            r.headers_mut().insert(
-                http::header::LOCATION,
-                HeaderValue::from_str(&location).unwrap_or(HeaderValue::from_static("/")),
-            );
-            r
-        }
-        ResponseShape::InertiaLocation { location } => {
-            let mut r = Response::new(Body::empty());
-            *r.status_mut() = StatusCode::CONFLICT;
-            r.headers_mut().insert(
-                &veer_headers::X_INERTIA_LOCATION,
-                HeaderValue::from_str(&location).unwrap_or(HeaderValue::from_static("/")),
-            );
-            r
+
+        let mut html = cfg
+            .root_view
+            .render(RootViewContext {
+                page_json: &escaped,
+                page_json_script: &script_escaped,
+                asset_version: &version,
+                ssr: ssr_payload.as_ref(),
+            })
+            .unwrap_or_else(|e| format!("root view error: {e}"));
+        // The extension sees the first page load through the DOM only.
+        if let (Some(id), Some(at)) = (&per.devtools_id, html.rfind("</body>")) {
+            html.insert_str(at, &crate::devtools::Recording::script_tag(id));
         }
+        let mut r = Response::new(Body::from(html));
+        r.headers_mut().insert(
+            http::header::CONTENT_TYPE,
+            HeaderValue::from_static("text/html; charset=utf-8"),
+        );
+        r
     };
 
-    finish_with_flash(response, pending_flash, per).await
+    if let Some(recorded) = recorded {
+        response.extensions_mut().insert(recorded);
+    }
+    finish_with_flash(response, pending, per).await
+}
+
+/// The rendered page object, for the DevTools recorder.
+#[derive(Clone)]
+pub(crate) struct RecordedPage(pub Arc<Value>);
+
+/// An empty response that points the client at `location` through `header`.
+pub(crate) fn redirect(status: StatusCode, header: HeaderName, location: &str) -> Response<Body> {
+    let mut r = Response::new(Body::empty());
+    *r.status_mut() = status;
+    r.headers_mut().insert(
+        header,
+        HeaderValue::from_str(location).unwrap_or(HeaderValue::from_static("/")),
+    );
+    r
 }
 
-async fn finish_with_flash(
+/// 409 for an asset version mismatch. `X-Inertia-Version` tells the client
+/// that this is a version change and not an external redirect.
+pub(crate) fn version_mismatch(location: &str, version: &str) -> Response<Body> {
+    let mut r = redirect(
+        StatusCode::CONFLICT,
+        veer_headers::X_INERTIA_LOCATION,
+        location,
+    );
+    if let Ok(v) = HeaderValue::from_str(version) {
+        r.headers_mut().insert(&veer_headers::X_INERTIA_VERSION, v);
+    }
+    r
+}
+
+pub(crate) async fn finish_with_flash(
     mut response: Response<Body>,
     pending: crate::session::Flash,
     per: &PerRequest,
@@ -233,14 +310,28 @@ fn html_attr_escape(s: &str) -> String {
         .replace('\'', "&#39;")
 }
 
-/// Make a JSON string safe to embed inside `<script>...</script>`. The HTML
-/// spec's only forbidden subsequences in script content are `</`, `<!--`, and
-/// `]]>` (the last only matters in XHTML, included for safety). Replacing the
-/// `<` and `]` with their `\uXXXX` JSON escapes leaves the parsed JSON value
-/// identical while preventing premature script termination or comment-state
-/// confusion.
+/// Make a JSON string safe to embed inside `<script>...</script>`. `<`, `>`
+/// and `/` occur only inside JSON strings, so their JSON escapes leave the
+/// parsed value identical. Without a literal `<` there is no `</script>` and
+/// no `<!--` (which would put the HTML parser in a state where the page stays
+/// blank). The protocol also requires the `\/` escape.
 fn script_tag_escape(json: &str) -> String {
-    json.replace("</", "<\\/")
-        .replace("<!--", "\\u003c!--")
-        .replace("]]>", "]]\\u003e")
+    json.replace('<', "\\u003c")
+        .replace('>', "\\u003e")
+        .replace('/', "\\/")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::script_tag_escape;
+
+    #[test]
+    fn script_escape_keeps_the_json_value() {
+        let value = serde_json::json!({"a": "</script><!--<script>", "url": "/x"});
+        let escaped = script_tag_escape(&value.to_string());
+        assert!(!escaped.contains('<') && !escaped.contains('>'));
+        assert!(escaped.contains(r#""\/x""#));
+        let parsed: serde_json::Value = serde_json::from_str(&escaped).unwrap();
+        assert_eq!(parsed, value);
+    }
 }
diff --git a/src/bigint.rs b/src/bigint.rs
new file mode 100644
index 0000000..1d9fa6b
--- /dev/null
+++ b/src/bigint.rs
@@ -0,0 +1,52 @@
+//! Big-integer transport: integers outside the JavaScript safe range travel as
+//! `{"$bigint": "<digits>"}` markers, which the client revives as `BigInt`.
+
+use serde_json::{json, Value};
+
+const MAX_SAFE_INTEGER: u64 = 9_007_199_254_740_991;
+
+/// Replace each integer outside the JavaScript safe range with a `$bigint` marker.
+pub fn encode_big_integers(value: &mut Value) {
+    match value {
+        Value::Number(n) => {
+            let unsafe_int = match (n.as_u64(), n.as_i64()) {
+                (Some(u), _) => u > MAX_SAFE_INTEGER,
+                (None, Some(i)) => i.unsigned_abs() > MAX_SAFE_INTEGER,
+                (None, None) => false,
+            };
+            if unsafe_int {
+                *value = json!({ "$bigint": n.to_string() });
+            }
+        }
+        Value::Array(items) => items.iter_mut().for_each(encode_big_integers),
+        Value::Object(map) => map.values_mut().for_each(encode_big_integers),
+        _ => {}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn only_unsafe_integers_become_markers() {
+        let mut v = json!({
+            "safe": 9_007_199_254_740_991u64,
+            "big": 900_719_925_474_099_988u64,
+            "max": u64::MAX,
+            "neg": [-9_007_199_254_740_992i64],
+            "float": 1e300,
+        });
+        encode_big_integers(&mut v);
+        assert_eq!(
+            v,
+            json!({
+                "safe": 9_007_199_254_740_991u64,
+                "big": {"$bigint": "900719925474099988"},
+                "max": {"$bigint": "18446744073709551615"},
+                "neg": [{"$bigint": "-9007199254740992"}],
+                "float": 1e300,
+            })
+        );
+    }
+}
diff --git a/src/bindings/mod.rs b/src/bindings/mod.rs
index 0ddec98..5c93124 100644
--- a/src/bindings/mod.rs
+++ b/src/bindings/mod.rs
@@ -3,8 +3,8 @@
 //!
 //! Inspired by Laravel's Ziggy / Wayfinder: downstream apps mark their prop
 //! structs with [`register_page!`](crate::register_page) and register routes
-//! via [`register_routes!`](crate::register_routes), then a test calls
-//! [`generate`] to emit a single bundled TypeScript file the frontend imports.
+//! via [`crate::Router::named_route`], then a small binary calls [`generate`]
+//! to emit a single bundled TypeScript file the frontend imports.
 //!
 //! Gated behind the `ts` feature.
 //!
@@ -83,7 +83,11 @@ macro_rules! register_page {
         $crate::__private::inventory::submit! {
             $crate::bindings::PageEntry {
                 component: $component,
-                ts_name: || <$ty as $crate::__private::ts_rs::TS>::ident(),
+                ts_name: || {
+                    <$ty as $crate::__private::ts_rs::TS>::ident(
+                        &$crate::__private::ts_rs::Config::from_env(),
+                    )
+                },
                 collect_decls: |out| $crate::bindings::collect_decls::<$ty>(out),
             }
         }
@@ -117,7 +121,8 @@ pub fn collect_decls<T: ts_rs::TS + 'static + ?Sized>(out: &mut HashMap<TypeId,
         return;
     }
     if T::output_path().is_some() {
-        out.insert(id, (T::ident(), T::decl()));
+        let cfg = ts_rs::Config::from_env();
+        out.insert(id, (T::ident(&cfg), T::decl(&cfg)));
     } else {
         // mark seen so we don't loop, but don't emit a decl
         out.insert(id, (String::new(), String::new()));
@@ -363,15 +368,29 @@ export interface PageObject<P = Pages> {
   version: string;
   encryptHistory?: boolean;
   clearHistory?: boolean;
+  preserveFragment?: boolean;
+  preserveBigIntegers?: boolean;
+  sharedProps?: string[];
   mergeProps?: string[];
-  resetMergeProps?: string[];
+  prependProps?: string[];
+  deepMergeProps?: string[];
+  matchPropsOn?: string[];
   deferredProps?: Record<string, string[]>;
+  rescuedProps?: string[];
+  scrollProps?: Record<string, ScrollProp>;
+  onceProps?: Record<string, { prop: string; expiresAt: number | null }>;
+  flash?: Flash;
+}
+
+export interface ScrollProp {
+  pageName: string;
+  previousPage: number | string | null;
+  nextPage: number | string | null;
+  currentPage: number | string | null;
+  reset: boolean;
 }
 
 export type ErrorBag = Record<string, string>;
 
-export interface Flash {
-  errors: ErrorBag;
-  bags: Record<string, unknown>;
-}
+export type Flash = Record<string, unknown>;
 "#;
diff --git a/src/config.rs b/src/config.rs
index 31c62bd..b035cf4 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,12 +1,17 @@
 //! Configuration assembled at app startup.
 
+use crate::props::prop::BoxedJsonFuture;
+use crate::request::RequestInfo;
 use crate::root_view::{MinimalRootView, RootView};
 use crate::session::SessionStore;
 use crate::shared::SharedProps;
 use crate::ssr::SsrClient;
+use serde_json::Value;
 use std::borrow::Cow;
+use std::future::Future;
 use std::sync::Arc;
 
+pub(crate) type SharedOnceFn = Arc<dyn Fn(&RequestInfo) -> BoxedJsonFuture + Send + Sync>;
 type VersionFn = Arc<dyn Fn() -> Cow<'static, str> + Send + Sync>;
 
 /// Top-level app config. Built once at startup, cloned by Arc into each request.
@@ -19,6 +24,11 @@ pub struct InertiaConfig {
     pub(crate) ssr_required: bool,
     pub(crate) csr_only: bool,
     pub(crate) shared: Option<Arc<dyn SharedProps>>,
+    pub(crate) shared_once: Vec<(String, SharedOnceFn)>,
+    pub(crate) encrypt_history: bool,
+    pub(crate) preserve_big_integers: bool,
+    pub(crate) with_all_errors: bool,
+    pub(crate) devtools: Option<crate::devtools::DevTools>,
 }
 
 impl Default for InertiaConfig {
@@ -31,6 +41,11 @@ impl Default for InertiaConfig {
             ssr_required: false,
             csr_only: false,
             shared: None,
+            shared_once: Vec::new(),
+            encrypt_history: false,
+            preserve_big_integers: false,
+            with_all_errors: false,
+            devtools: None,
         }
     }
 }
@@ -85,6 +100,55 @@ impl InertiaConfig {
         self.shared = Some(Arc::new(p));
         self
     }
+
+    /// Share a once prop with every page. The closure runs only when the
+    /// client does not hold the value yet. A handler prop with the same key wins.
+    pub fn share_once<F, Fut>(mut self, key: impl Into<String>, f: F) -> Self
+    where
+        F: Fn(&RequestInfo) -> Fut + Send + Sync + 'static,
+        Fut: Future<Output = Value> + Send + 'static,
+    {
+        self.shared_once
+            .push((key.into(), Arc::new(move |req| Box::pin(f(req)))));
+        self
+    }
+
+    /// Set `encryptHistory: true` on every page.
+    pub fn encrypt_history(mut self, on: bool) -> Self {
+        self.encrypt_history = on;
+        self
+    }
+
+    /// Record each request for the Inertia DevTools browser extension. The
+    /// read API is open unless you set [`crate::DevTools::authorize`], so
+    /// enable this in development only:
+    ///
+    /// ```
+    /// # use veer::{DevTools, InertiaConfig};
+    /// let mut config = InertiaConfig::new();
+    /// if cfg!(debug_assertions) {
+    ///     config = config.devtools(DevTools::new());
+    /// }
+    /// ```
+    pub fn devtools(mut self, devtools: crate::devtools::DevTools) -> Self {
+        self.devtools = Some(devtools);
+        self
+    }
+
+    /// Send all validation messages of a field as an array in `props.errors`.
+    /// The default sends the first message as a string.
+    pub fn with_all_errors(mut self, on: bool) -> Self {
+        self.with_all_errors = on;
+        self
+    }
+
+    /// Send integers outside the JavaScript safe range as `$bigint` markers on
+    /// every page. [`crate::InertiaResponse::preserve_big_integers`] overrides
+    /// this for one response.
+    pub fn preserve_big_integers(mut self, on: bool) -> Self {
+        self.preserve_big_integers = on;
+        self
+    }
 }
 
 #[cfg(test)]
diff --git a/src/devtools.rs b/src/devtools.rs
new file mode 100644
index 0000000..db6805e
--- /dev/null
+++ b/src/devtools.rs
@@ -0,0 +1,536 @@
+//! Inertia DevTools protocol: records one entry per request for the Inertia
+//! DevTools browser extension.
+//!
+//! Spec: <https://inertiajs.com/docs/v3/advanced/devtools-protocol>. Enable it
+//! with [`crate::InertiaConfig::devtools`] in development only: the read API
+//! (`GET /_inertia/devtools/entries[/{id}]`) is open unless you set
+//! [`DevTools::authorize`].
+
+use crate::request::RequestInfo;
+use http::{request::Parts, HeaderMap, HeaderName, Method, StatusCode};
+use serde_json::{json, Map, Value};
+use std::collections::VecDeque;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+/// Set on every response: the id of the recorded entry.
+pub const X_INERTIA_DEVTOOLS_ID: HeaderName = HeaderName::from_static("x-inertia-devtools-id");
+/// Set on every response: the id of the entry that started the batch.
+pub const X_INERTIA_DEVTOOLS_PARENT_OUT: HeaderName =
+    HeaderName::from_static("x-inertia-devtools-parent-out");
+
+/// Path prefix of the read API.
+pub const ENTRIES_PATH: &str = "/_inertia/devtools/entries";
+
+/// JSON request bodies up to this size are recorded.
+pub const BODY_LIMIT: usize = 256_000;
+
+const REDACTED: &str = "[REDACTED]";
+const REDACT_HEADERS: [&str; 6] = [
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "set-cookie",
+    "x-csrf-token",
+    "x-xsrf-token",
+];
+const REDACT_KEYS: [&str; 10] = [
+    "password",
+    "password_confirmation",
+    "current_password",
+    "token",
+    "_token",
+    "access_token",
+    "refresh_token",
+    "secret",
+    "client_secret",
+    "api_key",
+];
+
+type Authorize = Arc<dyn Fn(&Parts) -> bool + Send + Sync>;
+
+/// In-memory store of recorded entries.
+#[derive(Clone)]
+pub struct DevTools {
+    entries: Arc<Mutex<VecDeque<Value>>>,
+    limit: usize,
+    authorize: Option<Authorize>,
+}
+
+impl Default for DevTools {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl DevTools {
+    /// A store that keeps the 100 newest entries of each browser tab.
+    pub fn new() -> Self {
+        Self {
+            entries: Default::default(),
+            limit: 100,
+            authorize: None,
+        }
+    }
+
+    /// Guard the read API: it answers `403` when `f` returns `false`. Use it if
+    /// the recorder runs where other people can reach the server.
+    pub fn authorize<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&Parts) -> bool + Send + Sync + 'static,
+    {
+        self.authorize = Some(Arc::new(f));
+        self
+    }
+
+    /// Set how many entries are kept for each browser tab.
+    pub fn limit(mut self, limit: usize) -> Self {
+        self.limit = limit.max(1);
+        self
+    }
+
+    /// The entry with this id.
+    pub fn entry(&self, id: &str) -> Option<Value> {
+        let entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
+        entries.iter().find(|e| e["__meta"]["id"] == id).cloned()
+    }
+
+    /// All stored entries, newest first.
+    pub fn entries(&self) -> Vec<Value> {
+        let entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
+        entries.iter().rev().cloned().collect()
+    }
+
+    /// Answer a read API request: `(status, JSON body)`. `None` if the request
+    /// is not for the read API.
+    pub fn read_api(&self, request: &Parts) -> Option<(StatusCode, String)> {
+        let rest = request.uri.path().strip_prefix(ENTRIES_PATH)?;
+        if request.method != Method::GET {
+            return None;
+        }
+        if self
+            .authorize
+            .as_ref()
+            .is_some_and(|allowed| !allowed(request))
+        {
+            return Some((StatusCode::FORBIDDEN, "null".to_string()));
+        }
+        Some(match rest.strip_prefix('/').filter(|id| !id.is_empty()) {
+            None if rest.is_empty() || rest == "/" => {
+                (StatusCode::OK, Value::Array(self.entries()).to_string())
+            }
+            None => return None,
+            Some(id) => match self.entry(id) {
+                Some(entry) => (StatusCode::OK, entry.to_string()),
+                None => (StatusCode::NOT_FOUND, "null".to_string()),
+            },
+        })
+    }
+
+    fn push(&self, entry: Value) {
+        let mut entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
+        let tab = &entry["__meta"]["tabUuid"];
+        let same_tab = |e: &Value| &e["__meta"]["tabUuid"] == tab;
+        if entries.iter().filter(|e| same_tab(e)).count() >= self.limit {
+            if let Some(oldest) = entries.iter().position(same_tab) {
+                entries.remove(oldest);
+            }
+        }
+        entries.push_back(entry);
+        // Tab ids come from the client, so the total is capped too.
+        while entries.len() > self.limit.saturating_mul(10) {
+            entries.pop_front();
+        }
+    }
+
+    /// Start the recording of one request.
+    pub fn start(&self, headers: &HeaderMap) -> Recording {
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let at = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default();
+        let id = format!(
+            "{:012x}{:08x}{:06x}",
+            at.as_millis(),
+            std::process::id(),
+            COUNTER.fetch_add(1, Ordering::Relaxed) & 0xff_ffff
+        );
+        let batch_id = text(headers, "x-inertia-devtools-parent");
+        Recording {
+            store: self.clone(),
+            started: Instant::now(),
+            at,
+            batch_id,
+            id,
+        }
+    }
+}
+
+/// One request that is being recorded.
+pub struct Recording {
+    store: DevTools,
+    started: Instant,
+    at: Duration,
+    batch_id: Option<String>,
+    /// The entry id (`X-Inertia-Devtools-Id`).
+    pub id: String,
+}
+
+/// What the adapter knows when the response is ready.
+pub struct Finished<'a> {
+    /// Parsed request info.
+    pub req: &'a RequestInfo,
+    /// Request headers.
+    pub request_headers: &'a HeaderMap,
+    /// Request body capture (see [`body_present`], [`body_empty`], [`body_omitted`]).
+    pub request_body: Value,
+    /// Response status.
+    pub status: StatusCode,
+    /// Response headers.
+    pub response_headers: &'a HeaderMap,
+    /// The rendered page object, if the response is an Inertia page.
+    pub page: Option<&'a Value>,
+    /// `true` if the response has no body.
+    pub response_is_empty: bool,
+    /// The matched route pattern, if known.
+    pub route: Option<&'a str>,
+}
+
+impl Recording {
+    /// The `<script>` tag that lets the extension find the entry of the first
+    /// page load.
+    pub fn script_tag(id: &str) -> String {
+        format!(
+            r#"<script data-inertia-devtools-id type="application/json">{}</script>"#,
+            Value::from(id)
+        )
+    }
+
+    /// The batch root: the client sends it back as `X-Inertia-Devtools-Parent`.
+    pub fn parent_out(&self, req: &RequestInfo) -> &str {
+        match &self.batch_id {
+            // A prefetch is speculative and must not move the batch cursor.
+            Some(batch) if !req.is_prefetch => batch,
+            _ => &self.id,
+        }
+    }
+
+    /// Build the entry and store it.
+    pub fn finish(self, f: Finished<'_>) {
+        let component = f.page.and_then(|p| p["component"].as_str());
+        let request_type = if f.req.is_precognition {
+            "precognition"
+        } else if !f.req.is_inertia {
+            if component.is_some() {
+                "initial"
+            } else {
+                "http"
+            }
+        } else if f
+            .request_headers
+            .contains_key("x-inertia-devtools-deferred")
+        {
+            "deferred"
+        } else if f.request_headers.contains_key("x-inertia-devtools-poll") {
+            "poll"
+        } else if f.req.partial_component.is_some() {
+            "partial"
+        } else if f.req.is_prefetch {
+            "prefetch"
+        } else {
+            "navigate"
+        };
+
+        let scheme = text(f.request_headers, "x-forwarded-proto").unwrap_or("http".into());
+        let host = text(f.request_headers, "host").unwrap_or("localhost".into());
+        let redirect_location = text(f.response_headers, "x-inertia-location")
+            .or_else(|| text(f.response_headers, "x-inertia-redirect"))
+            .or_else(|| text(f.response_headers, "location").filter(|_| f.status.is_redirection()))
+            .map(|url| redact_url(&url));
+        let response_body = match f.page {
+            Some(page) => body_present(page.clone()),
+            None if f.response_is_empty => body_empty(),
+            None => body_omitted("non-inertia-response"),
+        };
+        let mut prop_values = f.page.map_or(json!({}), |p| p["props"].clone());
+        redact(&mut prop_values);
+
+        self.store.push(json!({
+            "__meta": {
+                "id": self.id,
+                "tabUuid": text(f.request_headers, "x-inertia-devtools-tab"),
+                "batchId": self.batch_id,
+                "timestamp": iso_8601(self.at),
+                "utime": self.at.as_secs_f64(),
+                "method": f.req.method.as_str(),
+                "url": format!("{scheme}://{host}{}", redact_url(&f.req.url)),
+                "component": component,
+                "requestType": request_type,
+                "status": f.status.as_u16(),
+                "redirectLocation": redirect_location,
+                "serverTimingMs": self.started.elapsed().as_secs_f64() * 1000.0,
+                "visitId": text(f.request_headers, "x-inertia-devtools-visit"),
+            },
+            "http": {
+                "requestHeaders": headers_json(f.request_headers),
+                "responseHeaders": headers_json(f.response_headers),
+                "requestBody": f.request_body,
+                "responseBody": response_body,
+            },
+            "props": f.page.map_or(json!({}), prop_meta),
+            "propValues": prop_values,
+            "route": { "name": null, "uri": f.route.unwrap_or(""), "action": null },
+            "renderSource": null,
+            "componentPath": null,
+        }));
+    }
+}
+
+/// Body capture: no body.
+pub fn body_empty() -> Value {
+    json!({ "status": "empty" })
+}
+
+/// Body capture: a body that is not recorded, with the reason.
+pub fn body_omitted(reason: &str) -> Value {
+    json!({ "status": "omitted", "reason": reason })
+}
+
+/// Body capture: a JSON value, with sensitive keys redacted.
+pub fn body_present(mut value: Value) -> Value {
+    redact(&mut value);
+    json!({ "status": "present", "value": value })
+}
+
+fn text(headers: &HeaderMap, name: &str) -> Option<String> {
+    headers.get(name)?.to_str().ok().map(str::to_owned)
+}
+
+fn headers_json(headers: &HeaderMap) -> Value {
+    let mut map = Map::new();
+    for (name, value) in headers {
+        let value = if REDACT_HEADERS.contains(&name.as_str()) {
+            REDACTED.to_string()
+        } else {
+            redact_url(value.to_str().unwrap_or(""))
+        };
+        map.insert(name.to_string(), value.into());
+    }
+    map.into()
+}
+
+fn is_sensitive(key: &str) -> bool {
+    REDACT_KEYS.contains(&key.to_ascii_lowercase().as_str())
+}
+
+/// Redact the values of sensitive query parameters (`?token=…`).
+fn redact_url(url: &str) -> String {
+    let Some((before, query)) = url.split_once('?') else {
+        return url.to_string();
+    };
+    let (query, fragment) = query.split_once('#').unwrap_or((query, ""));
+    let query: Vec<String> = query
+        .split('&')
+        .map(|pair| match pair.split_once('=') {
+            Some((key, _)) if is_sensitive(key) => format!("{key}={REDACTED}"),
+            _ => pair.to_string(),
+        })
+        .collect();
+    let fragment = if fragment.is_empty() {
+        String::new()
+    } else {
+        format!("#{fragment}")
+    };
+    format!("{before}?{}{fragment}", query.join("&"))
+}
+
+fn redact(value: &mut Value) {
+    match value {
+        Value::Object(map) => {
+            for (key, value) in map {
+                if key == "url" && value.is_string() {
+                    *value = redact_url(value.as_str().unwrap_or_default()).into();
+                } else if is_sensitive(key) {
+                    *value = REDACTED.into();
+                } else {
+                    redact(value);
+                }
+            }
+        }
+        Value::Array(items) => items.iter_mut().for_each(redact),
+        _ => {}
+    }
+}
+
+/// Per-prop metadata, derived from the page object's own metadata fields.
+fn prop_meta(page: &Value) -> Value {
+    let mut props: Map<String, Value> = Map::new();
+    let mut set = |path: &str, key: &str, value: Value| {
+        if let Value::Object(meta) = props.entry(path).or_insert_with(|| json!({})) {
+            meta.insert(key.to_string(), value);
+        }
+    };
+    let strings = |field: &str| -> Vec<String> {
+        let list = page[field].as_array().into_iter().flatten();
+        list.filter_map(|v| v.as_str().map(str::to_owned)).collect()
+    };
+
+    let shared = strings("sharedProps");
+    for key in page["props"].as_object().into_iter().flat_map(Map::keys) {
+        set(key, "shared", shared.contains(key).into());
+    }
+    set("errors", "inertiaType", "always".into());
+    for (key, entry) in page["onceProps"].as_object().into_iter().flatten() {
+        let path = entry["prop"].as_str().unwrap_or(key);
+        set(path, "inertiaType", "once".into());
+        set(path, "once", true.into());
+    }
+    for (field, direction, deep) in [
+        ("mergeProps", "append", false),
+        ("prependProps", "prepend", false),
+        ("deepMergeProps", "append", true),
+    ] {
+        for path in strings(field) {
+            set(&path, "inertiaType", "merge".into());
+            set(&path, "mergeDirection", direction.into());
+            if deep {
+                set(&path, "deepMerge", true.into());
+            }
+        }
+    }
+    for (path, entry) in page["scrollProps"].as_object().into_iter().flatten() {
+        set(path, "inertiaType", "scroll".into());
+        set(path, "reset", entry["reset"].clone());
+    }
+    for (group, paths) in page["deferredProps"].as_object().into_iter().flatten() {
+        for path in paths
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter_map(Value::as_str)
+        {
+            set(path, "inertiaType", "defer".into());
+            set(path, "deferGroup", group.as_str().into());
+        }
+    }
+    for path in strings("rescuedProps") {
+        set(&path, "inertiaType", "defer".into());
+        set(&path, "rescued", true.into());
+    }
+    props.into()
+}
+
+/// UTC timestamp with milliseconds, e.g. `2026-07-09T10:00:00.000Z`.
+fn iso_8601(since_epoch: Duration) -> String {
+    let secs = since_epoch.as_secs();
+    // Civil date from days since the epoch (Howard Hinnant's algorithm).
+    let z = (secs / 86_400) as i64 + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097);
+    let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let day = doy - (153 * mp + 2) / 5 + 1;
+    let month = if mp < 10 { mp + 3 } else { mp - 9 };
+    let year = yoe + era * 400 + i64::from(month <= 2);
+    format!(
+        "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}.{:03}Z",
+        secs % 86_400 / 3_600,
+        secs % 3_600 / 60,
+        secs % 60,
+        since_epoch.subsec_millis()
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn iso_8601_matches_known_instants() {
+        assert_eq!(iso_8601(Duration::ZERO), "1970-01-01T00:00:00.000Z");
+        // The instant of the example entry in the protocol document.
+        assert_eq!(
+            iso_8601(Duration::from_millis(1_783_591_200_123)),
+            "2026-07-09T10:00:00.123Z"
+        );
+        assert_eq!(
+            iso_8601(Duration::from_secs(1_709_164_800)),
+            "2024-02-29T00:00:00.000Z"
+        );
+    }
+
+    #[test]
+    fn prop_meta_is_derived_from_the_page_object() {
+        let page = json!({
+            "props": {"errors": {}, "auth": 1, "posts": {"data": []}},
+            "sharedProps": ["auth", "errors"],
+            "mergeProps": ["posts.data"],
+            "scrollProps": {"posts": {"reset": false}},
+            "deferredProps": {"side": ["stats"]},
+            "onceProps": {"plans-key": {"prop": "plans", "expiresAt": null}},
+            "rescuedProps": ["perms"],
+        });
+        assert_eq!(
+            prop_meta(&page),
+            json!({
+                "errors": {"shared": true, "inertiaType": "always"},
+                "auth": {"shared": true},
+                "posts": {"shared": false, "inertiaType": "scroll", "reset": false},
+                "posts.data": {"inertiaType": "merge", "mergeDirection": "append"},
+                "stats": {"inertiaType": "defer", "deferGroup": "side"},
+                "plans": {"inertiaType": "once", "once": true},
+                "perms": {"inertiaType": "defer", "rescued": true},
+            })
+        );
+    }
+
+    #[test]
+    fn store_keeps_the_newest_entries_of_each_tab() {
+        let store = DevTools::new().limit(2);
+        for (id, tab) in [("a", "t1"), ("b", "t1"), ("c", "t2"), ("d", "t1")] {
+            store.push(json!({"__meta": {"id": id, "tabUuid": tab}}));
+        }
+        let ids: Vec<_> = store
+            .entries()
+            .iter()
+            .map(|e| e["__meta"]["id"].as_str().unwrap().to_string())
+            .collect();
+        assert_eq!(ids, ["d", "c", "b"]);
+        let parts = |method: &str, path: &str| {
+            let request = http::Request::builder().method(method).uri(path);
+            request.body(()).unwrap().into_parts().0
+        };
+        let status = |store: &DevTools, path| store.read_api(&parts("GET", path)).map(|r| r.0);
+        let entry = "/_inertia/devtools/entries/c";
+        assert_eq!(
+            status(&store, "/_inertia/devtools/entries/a"),
+            Some(StatusCode::NOT_FOUND)
+        );
+        assert_eq!(status(&store, entry), Some(StatusCode::OK));
+        assert_eq!(status(&store, "/_inertia/devtools/other"), None);
+        assert!(store.read_api(&parts("POST", entry)).is_none());
+
+        let guarded = store.clone().authorize(|r| r.headers.contains_key("x-dev"));
+        assert_eq!(status(&guarded, entry), Some(StatusCode::FORBIDDEN));
+    }
+
+    #[test]
+    fn sensitive_query_parameters_are_redacted() {
+        assert_eq!(
+            redact_url("/reset?token=abc&page=2#top"),
+            "/reset?token=[REDACTED]&page=2#top"
+        );
+        assert_eq!(redact_url("/plain"), "/plain");
+    }
+
+    #[test]
+    fn sensitive_values_are_redacted() {
+        let body = body_present(json!({"user": {"Password": "x", "name": "a"}, "token": 1}));
+        assert_eq!(
+            body["value"],
+            json!({"user": {"Password": REDACTED, "name": "a"}, "token": REDACTED})
+        );
+    }
+}
diff --git a/src/errors/garde.rs b/src/errors/garde.rs
index 9fb6727..446af39 100644
--- a/src/errors/garde.rs
+++ b/src/errors/garde.rs
@@ -9,6 +9,16 @@ impl IntoErrorBag for garde::Report {
             .map(|(path, error)| (path.to_string(), error.message().to_string()))
             .collect()
     }
+
+    fn into_all_errors(self) -> HashMap<String, Vec<String>> {
+        let mut all: HashMap<String, Vec<String>> = HashMap::new();
+        for (path, error) in self.iter() {
+            all.entry(path.to_string())
+                .or_default()
+                .push(error.message().to_string());
+        }
+        all
+    }
 }
 
 #[cfg(test)]
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index 6e1eb91..de973b7 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -11,6 +11,18 @@ pub mod validator;
 pub trait IntoErrorBag {
     /// Flatten into `{field: first_message}`.
     fn into_error_bag(self) -> HashMap<String, String>;
+
+    /// Flatten into `{field: [all messages]}`. The default has one message per
+    /// field; the `validator` and `garde` impls keep all of them.
+    fn into_all_errors(self) -> HashMap<String, Vec<String>>
+    where
+        Self: Sized,
+    {
+        self.into_error_bag()
+            .into_iter()
+            .map(|(field, message)| (field, vec![message]))
+            .collect()
+    }
 }
 
 impl IntoErrorBag for HashMap<String, String> {
diff --git a/src/errors/validator.rs b/src/errors/validator.rs
index fdfe5ff..3cd8f76 100644
--- a/src/errors/validator.rs
+++ b/src/errors/validator.rs
@@ -17,6 +17,23 @@ impl IntoErrorBag for validator::ValidationErrors {
             })
             .collect()
     }
+
+    fn into_all_errors(self) -> HashMap<String, Vec<String>> {
+        self.field_errors()
+            .into_iter()
+            .map(|(field, errs)| {
+                let messages = errs
+                    .iter()
+                    .map(|e| {
+                        e.message
+                            .as_ref()
+                            .map_or(e.code.to_string(), |m| m.to_string())
+                    })
+                    .collect();
+                (field.to_string(), messages)
+            })
+            .collect()
+    }
 }
 
 #[cfg(test)]
@@ -26,7 +43,10 @@ mod tests {
 
     #[derive(Validate)]
     struct NewUser {
-        #[validate(length(min = 1, message = "title is required"))]
+        #[validate(
+            length(min = 1, message = "title is required"),
+            email(message = "title is not an email")
+        )]
         title: String,
         #[validate(email)]
         email: String,
@@ -38,9 +58,13 @@ mod tests {
             title: String::new(),
             email: "not-an-email".into(),
         };
+        let mut all = bad.validate().unwrap_err().into_all_errors();
+        all.get_mut("title").unwrap().sort();
+        assert_eq!(all["title"], ["title is not an email", "title is required"]);
+
         let errors = bad.validate().unwrap_err();
         let bag = errors.into_error_bag();
-        assert_eq!(bag.get("title").unwrap(), "title is required");
+        assert!(bag.get("title").unwrap().starts_with("title is"));
         // `email` has no custom message; we fall back to the code.
         assert_eq!(bag.get("email").unwrap(), "email");
     }
diff --git a/src/headers.rs b/src/headers.rs
index 03c41b3..a67bb04 100644
--- a/src/headers.rs
+++ b/src/headers.rs
@@ -4,10 +4,12 @@ use http::HeaderName;
 
 /// Present (`true`) on Inertia XHR requests.
 pub const X_INERTIA: HeaderName = HeaderName::from_static("x-inertia");
-/// Asset version known to the client.
+/// Asset version known to the client. Echoed on a version-mismatch 409.
 pub const X_INERTIA_VERSION: HeaderName = HeaderName::from_static("x-inertia-version");
 /// Set on response when an external redirect must be performed (paired with 409).
 pub const X_INERTIA_LOCATION: HeaderName = HeaderName::from_static("x-inertia-location");
+/// Set on response when a redirect target has a URL fragment (paired with 409).
+pub const X_INERTIA_REDIRECT: HeaderName = HeaderName::from_static("x-inertia-redirect");
 /// Component name being partially reloaded.
 pub const X_INERTIA_PARTIAL_COMPONENT: HeaderName =
     HeaderName::from_static("x-inertia-partial-component");
@@ -18,5 +20,22 @@ pub const X_INERTIA_PARTIAL_EXCEPT: HeaderName =
     HeaderName::from_static("x-inertia-partial-except");
 /// Indicates the client wants the server to reset specific merged props.
 pub const X_INERTIA_RESET: HeaderName = HeaderName::from_static("x-inertia-reset");
-/// Set on JSON responses so caches vary correctly.
+/// Error bag that scopes the validation errors of this request.
+pub const X_INERTIA_ERROR_BAG: HeaderName = HeaderName::from_static("x-inertia-error-bag");
+/// Comma-separated once-prop keys that the client already holds.
+pub const X_INERTIA_EXCEPT_ONCE_PROPS: HeaderName =
+    HeaderName::from_static("x-inertia-except-once-props");
+/// `append` or `prepend`: how the client merges an infinite-scroll page.
+pub const X_INERTIA_INFINITE_SCROLL_MERGE_INTENT: HeaderName =
+    HeaderName::from_static("x-inertia-infinite-scroll-merge-intent");
+/// `prefetch` on prefetch requests.
+pub const PURPOSE: HeaderName = HeaderName::from_static("purpose");
+/// `true` on Precognition validation requests and responses.
+pub const PRECOGNITION: HeaderName = HeaderName::from_static("precognition");
+/// Comma-separated field names that a Precognition request validates.
+pub const PRECOGNITION_VALIDATE_ONLY: HeaderName =
+    HeaderName::from_static("precognition-validate-only");
+/// `true` on a Precognition response with no validation errors (paired with 204).
+pub const PRECOGNITION_SUCCESS: HeaderName = HeaderName::from_static("precognition-success");
+/// Set on responses so caches vary correctly.
 pub const VARY: HeaderName = HeaderName::from_static("vary");
diff --git a/src/inertia.rs b/src/inertia.rs
index fdc2ce1..338d063 100644
--- a/src/inertia.rs
+++ b/src/inertia.rs
@@ -66,7 +66,7 @@ impl Inertia {
     /// Typical usage: `inertia.with_errors(errors).redirect("/form")`.
     pub fn with_errors<E: crate::errors::IntoErrorBag>(&self, errors: E) -> InertiaResponse {
         let mut r = InertiaResponse::new(String::new(), serde_json::Value::Null);
-        r.pending_flash.errors.extend(errors.into_error_bag());
+        r.pending_flash.errors.extend(errors.into_all_errors());
         r
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index ca8645d..240f833 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,7 @@
 //! Build classic server-rendered apps that drive React, Vue, or Svelte frontends
 //! through the official Inertia.js client adapters — no separate JSON API needed.
 //!
-//! See <https://inertiajs.com/the-protocol> for the protocol spec.
+//! See <https://inertiajs.com/docs/v3/core-concepts/the-protocol> for the protocol spec.
 //!
 //! # Quick start (axum)
 //!
@@ -30,11 +30,14 @@
 //! |------|---------|---------|
 //! | `axum` | on | Axum extractor + tower layer |
 //! | `ssr` | off | HTTP SSR client backed by `reqwest` |
+//! | `multipart` | off | File upload support (`UploadedFile`, `MultipartStream`) |
 //! | `cookie-session` | off | Signed-cookie session store |
+//! | `tower-sessions` | off | Flash store backed by `tower-sessions` |
 //! | `validator` | off | `IntoErrorBag` impl for `validator::ValidationErrors` |
 //! | `garde` | off | `IntoErrorBag` impl for `garde::Report` |
 //! | `csrf` | off | Inertia/axios-compatible CSRF layer (`CsrfLayer`) |
 //! | `embed` | off | Embedded-asset serving service (`EmbeddedAssets`) |
+//! | `ts` | off | TypeScript bindings codegen (`ts-rs` + `inventory`) |
 //!
 //! # Architecture
 //!
@@ -46,17 +49,15 @@
 //!
 //! # Caveats
 //!
-//! - `Always<T>` and `Merge<T>` wrappers are detected at any depth inside a
-//!   typed `Serialize` value, but only top-level matches affect the Inertia
-//!   wire format (the protocol has no notion of "nested merge prop").
-//! - When building props with the `serde_json::json!` macro, wrappers are
-//!   collapsed into raw values before they reach `Inertia::render` — they
-//!   only survive via typed `#[derive(Serialize)]` structs. Use
-//!   [`InertiaResponse::merge`] to mark top-level keys built via `json!`.
+//! - `Always<T>` and `Merge<T>` wrappers are detected at any depth and through
+//!   any serialization path (typed structs, `serde_json::json!`, hand-built
+//!   `Value`s). A nested wrapper acts at its dot path (`posts.data`).
 #![warn(missing_docs)]
 #![warn(rust_2018_idioms)]
 
+pub mod bigint;
 pub mod config;
+pub mod devtools;
 pub mod error;
 pub mod errors;
 pub mod headers;
@@ -94,10 +95,11 @@ pub mod __private {
 pub use config::InertiaConfig;
 #[cfg(feature = "csrf")]
 pub use csrf::CsrfTokens;
+pub use devtools::DevTools;
 pub use error::VeerError;
 pub use inertia::Inertia;
 pub use page::PageObject;
-pub use props::{Always, Merge};
+pub use props::{Always, Merge, Prop, ScrollMetadata};
 pub use request::RequestInfo;
 pub use response::InertiaResponse;
 pub use root_view::{MinimalRootView, RootView, RootViewContext, ViteManifest, ViteRootView};
@@ -106,7 +108,9 @@ pub use shared::SharedProps;
 pub use ssr::{SsrClient, SsrPayload};
 
 #[cfg(feature = "axum")]
-pub use adapters::axum::{InertiaForm, InertiaFormRejection, InertiaLayer, Method, Router};
+pub use adapters::axum::{
+    InertiaForm, InertiaFormRejection, InertiaLayer, Method, Precognition, Router,
+};
 
 #[cfg(feature = "csrf")]
 pub use adapters::axum::CsrfLayer;
diff --git a/src/page.rs b/src/page.rs
index 05bb1e2..82201fe 100644
--- a/src/page.rs
+++ b/src/page.rs
@@ -1,13 +1,35 @@
 //! The Inertia "page object" — the JSON payload that drives the client adapter.
 
+use crate::props::ScrollMetadata;
 use serde::Serialize;
-use serde_json::Value;
+use serde_json::{Map, Value};
 use std::collections::BTreeMap;
 
+/// One entry of `onceProps`.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct OnceEntry {
+    /// The prop path that holds the value.
+    pub prop: String,
+    /// Expiry as a Unix timestamp in milliseconds; `null` means no expiry.
+    #[serde(rename = "expiresAt")]
+    pub expires_at: Option<u64>,
+}
+
+/// One entry of `scrollProps`.
+#[derive(Debug, Clone, Serialize)]
+pub struct ScrollEntry {
+    /// Cursor data for the page that this response carries.
+    #[serde(flatten)]
+    pub metadata: ScrollMetadata,
+    /// `true` when the client asked to reset this prop.
+    pub reset: bool,
+}
+
 /// The shape the Inertia JS client expects.
 ///
 /// Field order matches the protocol; serialized as snake/camelCase as required.
 #[derive(Debug, Clone, Serialize)]
+#[non_exhaustive]
 pub struct PageObject {
     /// Component name (e.g. `"Users/Index"`).
     pub component: String,
@@ -23,15 +45,42 @@ pub struct PageObject {
     /// Clear history flag (Inertia v2+).
     #[serde(rename = "clearHistory", skip_serializing_if = "is_false")]
     pub clear_history: bool,
-    /// Keys whose values should merge into the client's existing prop state.
+    /// Top-level keys of the shared props.
+    #[serde(rename = "sharedProps", skip_serializing_if = "Vec::is_empty")]
+    pub shared_props: Vec<String>,
+    /// Prop paths that the client appends to its existing state.
     #[serde(rename = "mergeProps", skip_serializing_if = "Vec::is_empty")]
     pub merge_props: Vec<String>,
-    /// Keys whose merge state the server is asking the client to reset.
-    #[serde(rename = "resetMergeProps", skip_serializing_if = "Vec::is_empty")]
-    pub reset_merge_props: Vec<String>,
+    /// Prop paths that the client prepends to its existing state.
+    #[serde(rename = "prependProps", skip_serializing_if = "Vec::is_empty")]
+    pub prepend_props: Vec<String>,
+    /// Prop paths that the client deep-merges into its existing state.
+    #[serde(rename = "deepMergeProps", skip_serializing_if = "Vec::is_empty")]
+    pub deep_merge_props: Vec<String>,
+    /// `<propPath>.<keyField>` entries that identify items during a merge.
+    #[serde(rename = "matchPropsOn", skip_serializing_if = "Vec::is_empty")]
+    pub match_props_on: Vec<String>,
     /// Deferred props grouped by group name (Inertia v2+).
     #[serde(rename = "deferredProps", skip_serializing_if = "BTreeMap::is_empty")]
     pub deferred_props: BTreeMap<String, Vec<String>>,
+    /// Deferred props that failed to resolve and were rescued.
+    #[serde(rename = "rescuedProps", skip_serializing_if = "Vec::is_empty")]
+    pub rescued_props: Vec<String>,
+    /// Infinite-scroll cursors by prop path.
+    #[serde(rename = "scrollProps", skip_serializing_if = "BTreeMap::is_empty")]
+    pub scroll_props: BTreeMap<String, ScrollEntry>,
+    /// Once props by once key.
+    #[serde(rename = "onceProps", skip_serializing_if = "BTreeMap::is_empty")]
+    pub once_props: BTreeMap<String, OnceEntry>,
+    /// `true` when integers outside the JavaScript safe range are sent as `$bigint` markers.
+    #[serde(rename = "preserveBigIntegers", skip_serializing_if = "is_false")]
+    pub preserve_big_integers: bool,
+    /// Flash data for this request. Not kept in the browser history state.
+    #[serde(skip_serializing_if = "Map::is_empty")]
+    pub flash: Map<String, Value>,
+    /// Keep the URL fragment of the original request across a redirect.
+    #[serde(rename = "preserveFragment", skip_serializing_if = "is_false")]
+    pub preserve_fragment: bool,
 }
 
 fn is_false(b: &bool) -> bool {
@@ -53,9 +102,18 @@ impl PageObject {
             version: version.into(),
             encrypt_history: false,
             clear_history: false,
+            shared_props: Vec::new(),
             merge_props: Vec::new(),
-            reset_merge_props: Vec::new(),
+            prepend_props: Vec::new(),
+            deep_merge_props: Vec::new(),
+            match_props_on: Vec::new(),
             deferred_props: BTreeMap::new(),
+            rescued_props: Vec::new(),
+            scroll_props: BTreeMap::new(),
+            once_props: BTreeMap::new(),
+            preserve_big_integers: false,
+            flash: Map::new(),
+            preserve_fragment: false,
         }
     }
 }
@@ -92,4 +150,38 @@ mod tests {
         assert_eq!(v["mergeProps"], json!(["notifications"]));
         assert_eq!(v["deferredProps"], json!({"dashboard": ["stats"]}));
     }
+
+    #[test]
+    fn once_and_scroll_entries_match_the_wire_format() {
+        let mut p = PageObject::new("Home", json!({}), "/", "v1");
+        p.once_props.insert(
+            "plans".into(),
+            OnceEntry {
+                prop: "plans".into(),
+                expires_at: None,
+            },
+        );
+        p.scroll_props.insert(
+            "posts".into(),
+            ScrollEntry {
+                metadata: ScrollMetadata::paged("page", 1, true),
+                reset: false,
+            },
+        );
+        let v = serde_json::to_value(&p).unwrap();
+        assert_eq!(
+            v["onceProps"],
+            json!({"plans": {"prop": "plans", "expiresAt": null}})
+        );
+        assert_eq!(
+            v["scrollProps"],
+            json!({"posts": {
+                "pageName": "page",
+                "previousPage": null,
+                "nextPage": 2,
+                "currentPage": 1,
+                "reset": false
+            }})
+        );
+    }
 }
diff --git a/src/props/always.rs b/src/props/always.rs
index c25ff6e..981f730 100644
--- a/src/props/always.rs
+++ b/src/props/always.rs
@@ -8,10 +8,8 @@ use serde::{Serialize, Serializer};
 /// Detected anywhere in the props tree, through any serialization path
 /// (typed `#[derive(Serialize)]` structs, `serde_json::json!`, hand-built
 /// `Value`s, etc.). The wrapper serializes as a single-key sentinel object
-/// that the Inertia resolver strips before sending to the client. The Inertia
-/// protocol only honors the rule at the top level of a render's props —
-/// wrappers at deeper paths are still detected and stripped but have no
-/// wire-format meaning.
+/// that the Inertia resolver strips before sending to the client. A nested
+/// wrapper keeps its value through partial-reload filters at that dot path.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Always<T>(pub T);
 
@@ -34,17 +32,17 @@ impl<T: Serialize> Serialize for Always<T> {
 impl<T: ts_rs::TS> ts_rs::TS for Always<T> {
     type WithoutGenerics = <T as ts_rs::TS>::WithoutGenerics;
     type OptionInnerType = <T as ts_rs::TS>::OptionInnerType;
-    fn ident() -> String {
-        <T as ts_rs::TS>::ident()
+    fn ident(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::ident(cfg)
     }
-    fn name() -> String {
-        <T as ts_rs::TS>::name()
+    fn name(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::name(cfg)
     }
-    fn inline() -> String {
-        <T as ts_rs::TS>::inline()
+    fn inline(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::inline(cfg)
     }
-    fn inline_flattened() -> String {
-        <T as ts_rs::TS>::inline_flattened()
+    fn inline_flattened(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::inline_flattened(cfg)
     }
     fn visit_dependencies(v: &mut impl ts_rs::TypeVisitor)
     where
@@ -58,11 +56,11 @@ impl<T: ts_rs::TS> ts_rs::TS for Always<T> {
     {
         <T as ts_rs::TS>::visit_generics(v);
     }
-    fn decl() -> String {
-        <T as ts_rs::TS>::decl()
+    fn decl(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::decl(cfg)
     }
-    fn decl_concrete() -> String {
-        <T as ts_rs::TS>::decl_concrete()
+    fn decl_concrete(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::decl_concrete(cfg)
     }
     fn output_path() -> Option<std::path::PathBuf> {
         <T as ts_rs::TS>::output_path()
diff --git a/src/props/closure.rs b/src/props/closure.rs
deleted file mode 100644
index 6f152c4..0000000
--- a/src/props/closure.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Internal types for closure-resolved props (`Lazy`, `Deferred`).
-//!
-//! These are not used directly in user props structs — they're built via the
-//! response builder (`InertiaResponse::lazy`/`optional`/`deferred`).
-
-use serde_json::Value;
-use std::future::Future;
-use std::pin::Pin;
-
-/// A boxed future returning a JSON value.
-pub type BoxedJsonFuture = Pin<Box<dyn Future<Output = Value> + Send>>;
-
-/// A closure that produces a prop value lazily.
-pub type LazyClosure = Box<dyn FnOnce() -> BoxedJsonFuture + Send>;
-
-/// Lazily-resolved prop attached via the response builder.
-///
-/// Backs both `InertiaResponse::lazy` and `InertiaResponse::optional` (the latter is an alias).
-pub struct LazyProp {
-    /// The closure that resolves the prop value.
-    pub closure: LazyClosure,
-}
-
-/// Deferred prop — first response advertises group; second response (when client asks) resolves.
-pub struct DeferredProp {
-    /// Group key under which this deferred prop is advertised in the page object.
-    pub group: &'static str,
-    /// The closure that resolves the prop value when requested.
-    pub closure: LazyClosure,
-}
diff --git a/src/props/merge.rs b/src/props/merge.rs
index 06ccd39..5b88c9c 100644
--- a/src/props/merge.rs
+++ b/src/props/merge.rs
@@ -8,10 +8,9 @@ use serde::{Serialize, Serializer};
 /// Detected anywhere in the props tree, through any serialization path
 /// (typed `#[derive(Serialize)]` structs, `serde_json::json!`, hand-built
 /// `Value`s, etc.). The wrapper serializes as a single-key sentinel object
-/// that the Inertia resolver strips before sending to the client. Top-level
-/// wrappers are recorded in `page.mergeProps` per the Inertia protocol;
-/// deeper-nested wrappers are detected and stripped, but the wire format has
-/// no notion of "nested merge prop" so they have no semantic effect today.
+/// that the Inertia resolver strips before sending to the client. The dot
+/// path of each wrapper is recorded in `page.mergeProps`, so a nested wrapper
+/// (`posts.data`) merges at that path.
 ///
 /// [`crate::response::InertiaResponse::merge`] provides the same effect via
 /// builder-style API.
@@ -37,17 +36,17 @@ impl<T: Serialize> Serialize for Merge<T> {
 impl<T: ts_rs::TS> ts_rs::TS for Merge<T> {
     type WithoutGenerics = <T as ts_rs::TS>::WithoutGenerics;
     type OptionInnerType = <T as ts_rs::TS>::OptionInnerType;
-    fn ident() -> String {
-        <T as ts_rs::TS>::ident()
+    fn ident(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::ident(cfg)
     }
-    fn name() -> String {
-        <T as ts_rs::TS>::name()
+    fn name(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::name(cfg)
     }
-    fn inline() -> String {
-        <T as ts_rs::TS>::inline()
+    fn inline(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::inline(cfg)
     }
-    fn inline_flattened() -> String {
-        <T as ts_rs::TS>::inline_flattened()
+    fn inline_flattened(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::inline_flattened(cfg)
     }
     fn visit_dependencies(v: &mut impl ts_rs::TypeVisitor)
     where
@@ -61,11 +60,11 @@ impl<T: ts_rs::TS> ts_rs::TS for Merge<T> {
     {
         <T as ts_rs::TS>::visit_generics(v);
     }
-    fn decl() -> String {
-        <T as ts_rs::TS>::decl()
+    fn decl(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::decl(cfg)
     }
-    fn decl_concrete() -> String {
-        <T as ts_rs::TS>::decl_concrete()
+    fn decl_concrete(cfg: &ts_rs::Config) -> String {
+        <T as ts_rs::TS>::decl_concrete(cfg)
     }
     fn output_path() -> Option<std::path::PathBuf> {
         <T as ts_rs::TS>::output_path()
diff --git a/src/props/mod.rs b/src/props/mod.rs
index 2ea9a31..6032cc6 100644
--- a/src/props/mod.rs
+++ b/src/props/mod.rs
@@ -1,12 +1,13 @@
 //! Prop wrappers and resolution machinery.
 
 pub mod always;
-pub mod closure;
 pub mod merge;
+pub mod prop;
 pub mod resolver;
 
 pub use always::Always;
 pub use merge::Merge;
+pub use prop::{Prop, ScrollMetadata};
 
 /// Sentinel object key that marks a value as wrapped in [`Always`].
 ///
diff --git a/src/props/prop.rs b/src/props/prop.rs
new file mode 100644
index 0000000..0ce27ec
--- /dev/null
+++ b/src/props/prop.rs
@@ -0,0 +1,279 @@
+//! `Prop` — a closure-resolved prop with composable Inertia behaviors.
+
+use serde::Serialize;
+use serde_json::Value;
+use std::fmt::Display;
+use std::future::Future;
+use std::pin::Pin;
+use std::time::Duration;
+
+/// A boxed future returning a JSON value.
+pub type BoxedJsonFuture = Pin<Box<dyn Future<Output = Value> + Send>>;
+
+pub(crate) struct Loaded {
+    pub value: Value,
+    pub scroll: Option<ScrollMetadata>,
+}
+
+type Loader =
+    Box<dyn FnOnce() -> Pin<Box<dyn Future<Output = Result<Loaded, String>> + Send>> + Send>;
+
+/// When a prop is resolved on a full (non-partial) visit.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum Load {
+    /// Resolved on each full visit.
+    Eager,
+    /// Never resolved on a full visit and never announced.
+    Optional,
+    /// Not resolved on a full visit; announced under `deferredProps[group]`.
+    Deferred(String),
+}
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct Once {
+    pub key: Option<String>,
+    pub ttl: Option<Duration>,
+    pub fresh: bool,
+}
+
+/// Merge labels relative to the prop. An empty path means the prop itself.
+#[derive(Debug, Clone, Default)]
+pub(crate) struct MergeSpec {
+    pub append: Vec<String>,
+    pub prepend: Vec<String>,
+    pub deep: bool,
+    pub match_on: Vec<String>,
+}
+
+/// Cursor data for an infinite-scroll prop (`scrollProps`).
+///
+/// Page values are JSON so that they can hold page numbers or cursor strings.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScrollMetadata {
+    /// Name of the query parameter that holds the page.
+    pub page_name: String,
+    /// Page before the current one, or `null`.
+    pub previous_page: Value,
+    /// Page after the current one, or `null`.
+    pub next_page: Value,
+    /// The page that this response carries.
+    pub current_page: Value,
+}
+
+impl ScrollMetadata {
+    /// Metadata with all pages set to `null`.
+    pub fn new(page_name: impl Into<String>) -> Self {
+        Self {
+            page_name: page_name.into(),
+            previous_page: Value::Null,
+            next_page: Value::Null,
+            current_page: Value::Null,
+        }
+    }
+
+    /// Metadata for 1-based numbered pages.
+    pub fn paged(page_name: impl Into<String>, current: u64, has_more: bool) -> Self {
+        Self::new(page_name)
+            .previous((current > 1).then(|| current - 1))
+            .current(current)
+            .next(has_more.then(|| current + 1))
+    }
+
+    /// Set the previous page.
+    pub fn previous(mut self, page: impl Into<Value>) -> Self {
+        self.previous_page = page.into();
+        self
+    }
+
+    /// Set the next page.
+    pub fn next(mut self, page: impl Into<Value>) -> Self {
+        self.next_page = page.into();
+        self
+    }
+
+    /// Set the current page.
+    pub fn current(mut self, page: impl Into<Value>) -> Self {
+        self.current_page = page.into();
+        self
+    }
+}
+
+/// A prop that a closure resolves only when the response needs it.
+///
+/// Attach it with [`crate::InertiaResponse::prop`]. The modifiers compose, as
+/// the Inertia categories do: `Prop::new(f).defer().once()` is a deferred once
+/// prop.
+pub struct Prop {
+    pub(crate) loader: Loader,
+    pub(crate) load: Load,
+    pub(crate) once: Option<Once>,
+    pub(crate) merge: MergeSpec,
+    /// Wrapper key of a scroll prop (the array that the client merges).
+    pub(crate) scroll_wrapper: Option<String>,
+    pub(crate) rescue: bool,
+}
+
+impl Prop {
+    fn from_loader(loader: Loader) -> Self {
+        Self {
+            loader,
+            load: Load::Eager,
+            once: None,
+            merge: MergeSpec::default(),
+            scroll_wrapper: None,
+            rescue: false,
+        }
+    }
+
+    /// A prop resolved on each full visit, and on partial reloads that select it.
+    pub fn new<F, Fut>(f: F) -> Self
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = Value> + Send + 'static,
+    {
+        Self::from_loader(Box::new(|| {
+            Box::pin(async {
+                Ok(Loaded {
+                    value: f().await,
+                    scroll: None,
+                })
+            })
+        }))
+    }
+
+    /// A prop that can fail. On `Err` the response is a `500`, unless the prop
+    /// has [`Self::rescue`].
+    pub fn try_new<F, Fut, E>(f: F) -> Self
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = Result<Value, E>> + Send + 'static,
+        E: Display,
+    {
+        Self::from_loader(Box::new(|| {
+            Box::pin(async {
+                match f().await {
+                    Ok(value) => Ok(Loaded {
+                        value,
+                        scroll: None,
+                    }),
+                    Err(e) => Err(e.to_string()),
+                }
+            })
+        }))
+    }
+
+    /// An infinite-scroll prop. The closure returns the page value (an object
+    /// that holds the items under the wrapper key, `data` by default) and its
+    /// cursor metadata.
+    pub fn scroll<F, Fut>(f: F) -> Self
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = (Value, ScrollMetadata)> + Send + 'static,
+    {
+        let mut prop = Self::from_loader(Box::new(|| {
+            Box::pin(async {
+                let (value, metadata) = f().await;
+                Ok(Loaded {
+                    value,
+                    scroll: Some(metadata),
+                })
+            })
+        }));
+        prop.scroll_wrapper = Some("data".into());
+        prop
+    }
+
+    /// Rescue a failure of a [`Self::try_new`] prop: the error is logged, the
+    /// prop is left out of `props`, and its key is listed in `rescuedProps`, so
+    /// that the client shows the `rescue` slot of `<Deferred>`.
+    pub fn rescue(mut self) -> Self {
+        self.rescue = true;
+        self
+    }
+
+    /// Resolve only when a partial reload selects the prop.
+    pub fn optional(mut self) -> Self {
+        self.load = Load::Optional;
+        self
+    }
+
+    /// Defer the prop: the client fetches it after the first render (group `default`).
+    pub fn defer(self) -> Self {
+        self.group("default")
+    }
+
+    /// Defer the prop in a named group. The client makes one request per group.
+    pub fn group(mut self, group: impl Into<String>) -> Self {
+        self.load = Load::Deferred(group.into());
+        self
+    }
+
+    /// Resolve once; the client remembers the value across pages.
+    pub fn once(mut self) -> Self {
+        self.once.get_or_insert_with(Once::default);
+        self
+    }
+
+    /// Resolve once under a custom key, shared by all pages that use the key.
+    pub fn once_as(mut self, key: impl Into<String>) -> Self {
+        self.once.get_or_insert_with(Once::default).key = Some(key.into());
+        self
+    }
+
+    /// Resolve once; the remembered value expires after `ttl`.
+    pub fn until(mut self, ttl: Duration) -> Self {
+        self.once.get_or_insert_with(Once::default).ttl = Some(ttl);
+        self
+    }
+
+    /// Send a fresh value although the client already holds this once prop.
+    pub fn fresh(mut self) -> Self {
+        self.once.get_or_insert_with(Once::default).fresh = true;
+        self
+    }
+
+    /// The client appends the value to its existing state (`mergeProps`).
+    pub fn merge(self) -> Self {
+        self.append_at("")
+    }
+
+    /// The client prepends the value to its existing state (`prependProps`).
+    pub fn prepend(self) -> Self {
+        self.prepend_at("")
+    }
+
+    /// The client deep-merges the value into its existing state (`deepMergeProps`).
+    pub fn deep_merge(mut self) -> Self {
+        self.merge.deep = true;
+        self
+    }
+
+    /// The client appends at a nested path, e.g. `data`.
+    pub fn append_at(mut self, path: impl Into<String>) -> Self {
+        self.merge.append.push(path.into());
+        self
+    }
+
+    /// The client prepends at a nested path, e.g. `data`.
+    pub fn prepend_at(mut self, path: impl Into<String>) -> Self {
+        self.merge.prepend.push(path.into());
+        self
+    }
+
+    /// Field that identifies an item during a merge, relative to the prop
+    /// (`id`, or `data.id` for a nested array).
+    pub fn match_on(mut self, field: impl Into<String>) -> Self {
+        self.merge.match_on.push(field.into());
+        self
+    }
+
+    /// Wrapper key of a [`Self::scroll`] prop (default `data`). No effect on
+    /// other props.
+    pub fn wrapper(mut self, wrapper: impl Into<String>) -> Self {
+        if let Some(current) = &mut self.scroll_wrapper {
+            *current = wrapper.into();
+        }
+        self
+    }
+}
diff --git a/src/props/resolver.rs b/src/props/resolver.rs
index 43a9635..d5142a2 100644
--- a/src/props/resolver.rs
+++ b/src/props/resolver.rs
@@ -1,19 +1,62 @@
 //! Resolve a serialized props tree against request partial-reload rules.
+//!
+//! Follows the prop evaluation model of the Inertia v3 protocol; prop paths are
+//! dot paths (`posts.data`), as on the wire.
 
-use crate::props::closure::{DeferredProp, LazyProp};
+use crate::page::{OnceEntry, ScrollEntry};
+use crate::props::prop::{Load, Prop};
 use crate::request::RequestInfo;
 use serde::Serialize;
 use serde_json::{Map, Value};
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 /// Output of resolving a props tree.
+#[derive(Debug, Default)]
+#[non_exhaustive]
 pub struct ResolvedProps {
     /// The final props JSON sent to the client.
     pub props: Value,
-    /// Keys to record under `page.mergeProps`.
+    /// `page.mergeProps`.
     pub merge_props: Vec<String>,
-    /// Deferred groups → key list (only populated on first/non-partial responses).
+    /// `page.prependProps`.
+    pub prepend_props: Vec<String>,
+    /// `page.deepMergeProps`.
+    pub deep_merge_props: Vec<String>,
+    /// `page.matchPropsOn`.
+    pub match_props_on: Vec<String>,
+    /// Deferred groups → key list (only populated on full visits).
     pub deferred_props: BTreeMap<String, Vec<String>>,
+    /// `page.rescuedProps`.
+    pub rescued_props: Vec<String>,
+    /// `page.scrollProps`.
+    pub scroll_props: BTreeMap<String, ScrollEntry>,
+    /// `page.onceProps`.
+    pub once_props: BTreeMap<String, OnceEntry>,
+}
+
+/// A [`Prop::try_new`] closure failed and the prop has no [`Prop::rescue`].
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[error("prop `{prop}` failed to resolve: {message}")]
+pub struct PropError {
+    /// The prop key.
+    pub prop: String,
+    /// The error that the closure returned.
+    pub message: String,
+}
+
+/// Merge labels attached by path through the response builder.
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct MergeLabels {
+    /// Paths for `mergeProps`.
+    pub append: BTreeSet<String>,
+    /// Paths for `prependProps`.
+    pub prepend: BTreeSet<String>,
+    /// Paths for `deepMergeProps`.
+    pub deep: BTreeSet<String>,
+    /// Entries for `matchPropsOn`.
+    pub match_on: BTreeSet<String>,
 }
 
 /// Inputs to the resolver.
@@ -24,52 +67,48 @@ pub struct ResolveInput<'a> {
     pub component: &'a str,
     /// Already-serialized base props from the user's struct (via custom serializer that records tags).
     pub base: SerializedBase,
-    /// Builder-attached lazy/optional props by top-level key (both routes share this map).
-    pub lazies: HashMap<String, LazyProp>,
-    /// Builder-attached deferred props by top-level key.
-    pub deferreds: HashMap<String, DeferredProp>,
-    /// Builder-attached merge props by top-level key (already serialized).
-    pub merges: HashSet<String>,
     /// Shared props (serialized via same tag-aware serializer).
     pub shared: Option<SerializedBase>,
+    /// Closure-resolved props by top-level key.
+    pub props: HashMap<String, Prop>,
+    /// Merge labels for values in `base`.
+    pub merge: MergeLabels,
 }
 
 /// Result of serializing user props through the tag-aware serializer.
+#[derive(Debug, Default)]
+#[non_exhaustive]
 pub struct SerializedBase {
     /// The serialized JSON value.
     pub value: Value,
-    /// JSON-pointer-ish path strings (e.g. `"/notifs"`) that came from `Always` wrappers.
+    /// Dot paths (e.g. `"auth.user"`) that came from `Always` wrappers.
     pub always_paths: HashSet<String>,
     /// Same for `Merge` wrappers.
     pub merge_paths: HashSet<String>,
 }
 
-/// Serialize a `Serialize` value while collecting the JSON-pointer paths of any
+/// Serialize a `Serialize` value while collecting the dot paths of any
 /// [`crate::props::Always`] and [`crate::props::Merge`] wrappers in the tree.
 ///
 /// `Always<T>` and `Merge<T>` serialize as single-key sentinel objects under
-/// standard serde (see [`crate::props::ALWAYS_SENTINEL`] /
-/// [`crate::props::MERGE_SENTINEL`]). This function runs `serde_json::to_value`
+/// standard serde. This function runs `serde_json::to_value`
 /// then walks the resulting tree once, recording each sentinel's path and
 /// replacing it with its inner value. Because the markers live in the JSON
 /// tree itself, this works through any pathway — typed structs, `json!`,
 /// hand-built `Value`s, mixed maps, etc.
 pub fn serialize_tag_aware<T: Serialize>(value: &T) -> Result<SerializedBase, serde_json::Error> {
-    let mut json_value = serde_json::to_value(value)?;
-    let mut always_paths = HashSet::new();
-    let mut merge_paths = HashSet::new();
+    let mut base = SerializedBase {
+        value: serde_json::to_value(value)?,
+        ..Default::default()
+    };
     let mut path = String::new();
     strip_sentinels(
-        &mut json_value,
+        &mut base.value,
         &mut path,
-        &mut always_paths,
-        &mut merge_paths,
+        &mut base.always_paths,
+        &mut base.merge_paths,
     );
-    Ok(SerializedBase {
-        value: json_value,
-        always_paths,
-        merge_paths,
-    })
+    Ok(base)
 }
 
 /// Walk `value`, recording the path of each [`Always`]/[`Merge`] sentinel and
@@ -111,498 +150,736 @@ fn strip_sentinels(
         }
     }
 
+    let mut descend = |segment: &str, v: &mut Value| {
+        let prev_len = path.len();
+        if prev_len > 0 {
+            path.push('.');
+        }
+        path.push_str(segment);
+        strip_sentinels(v, path, always_paths, merge_paths);
+        path.truncate(prev_len);
+    };
     match value {
         Value::Object(map) => {
             for (k, v) in map.iter_mut() {
-                let prev_len = path.len();
-                path.push('/');
-                escape_pointer_segment(path, k);
-                strip_sentinels(v, path, always_paths, merge_paths);
-                path.truncate(prev_len);
+                descend(k, v);
             }
         }
         Value::Array(arr) => {
             for (i, v) in arr.iter_mut().enumerate() {
-                let prev_len = path.len();
-                use std::fmt::Write;
-                let _ = write!(path, "/{i}");
-                strip_sentinels(v, path, always_paths, merge_paths);
-                path.truncate(prev_len);
+                descend(&i.to_string(), v);
             }
         }
         _ => {}
     }
 }
 
-/// Append a key to a JSON-pointer path, escaping `~` and `/` per RFC 6901.
-/// We don't strictly need RFC compliance internally, but it keeps paths
-/// unambiguous when a key contains a `/`.
-fn escape_pointer_segment(buf: &mut String, segment: &str) {
-    for ch in segment.chars() {
-        match ch {
-            '~' => buf.push_str("~0"),
-            '/' => buf.push_str("~1"),
-            c => buf.push(c),
-        }
+/// `true` if `path` is `prefix` or lies below it.
+fn is_at_or_below(path: &str, prefix: &str) -> bool {
+    path.strip_prefix(prefix)
+        .is_some_and(|rest| rest.is_empty() || rest.starts_with('.'))
+}
+
+/// Partial-reload filters of one request. An empty header counts as absent.
+struct Filter<'a> {
+    partial: bool,
+    only: Option<&'a HashSet<String>>,
+    except: Option<&'a HashSet<String>>,
+    reset: &'a HashSet<String>,
+}
+
+impl Filter<'_> {
+    fn matches_only(&self, path: &str) -> bool {
+        self.only
+            .is_none_or(|only| only.iter().any(|o| is_at_or_below(path, o)))
+    }
+
+    fn matches_except(&self, path: &str) -> bool {
+        self.except
+            .is_some_and(|except| except.iter().any(|e| is_at_or_below(path, e)))
+    }
+
+    /// Whether a value at `path` is part of a partial response. A path that
+    /// leads to an `only` entry (`user` for `user.name`) is kept as a container.
+    fn includes(&self, path: &str) -> bool {
+        let leads_to_only = || {
+            self.only
+                .is_some_and(|only| only.iter().any(|o| o != path && is_at_or_below(o, path)))
+        };
+        (self.matches_only(path) || leads_to_only()) && !self.matches_except(path)
+    }
+
+    /// Whether merge/once metadata for `path` is part of this response.
+    fn emits_metadata(&self, path: &str) -> bool {
+        !self.partial || (self.matches_only(path) && !self.matches_except(path))
+    }
+
+    /// Whether the client asked to reset `path` or one of its parents.
+    fn is_reset(&self, path: &str) -> bool {
+        self.reset.iter().any(|r| is_at_or_below(path, r))
+    }
+
+    fn prune(&self, map: &mut Map<String, Value>, prefix: &str, always: &HashSet<String>) {
+        map.retain(|key, value| {
+            let path = join(prefix, key);
+            if always.contains(&path) {
+                return true;
+            }
+            if !self.includes(&path) {
+                return false;
+            }
+            if let Value::Object(child) = value {
+                self.prune(child, &path, always);
+            }
+            true
+        });
+    }
+}
+
+fn join(prefix: &str, segment: &str) -> String {
+    if prefix.is_empty() {
+        segment.to_string()
+    } else if segment.is_empty() {
+        prefix.to_string()
+    } else {
+        format!("{prefix}.{segment}")
     }
 }
 
-/// Apply partial-reload rules to the base value, drop/keep keys, and return.
-pub async fn resolve(input: ResolveInput<'_>) -> ResolvedProps {
+/// Apply the prop evaluation model: filter the tree, run the closures that
+/// this response needs, and collect the page-object metadata.
+pub async fn resolve(input: ResolveInput<'_>) -> Result<ResolvedProps, PropError> {
     let ResolveInput {
         req,
         component,
         base,
-        lazies,
-        deferreds,
-        merges,
         shared,
+        props,
+        merge,
     } = input;
 
-    // 1) merge shared under base
-    let mut tree = match shared {
-        Some(s) => merge_objects(s.value, base.value),
-        None => base.value,
+    let filter = Filter {
+        partial: req.partial_component.as_deref() == Some(component),
+        only: Some(&req.partial_only).filter(|s| !s.is_empty()),
+        except: Some(&req.partial_except).filter(|s| !s.is_empty()),
+        reset: &req.reset,
     };
 
-    // 2) Insert builder-attached lazies/optionals/deferreds where appropriate.
-    let partial_for_this_component =
-        req.is_partial() && req.partial_component.as_deref() == Some(component);
-
-    let only: &HashSet<String> = &req.partial_only;
-    let except: &HashSet<String> = &req.partial_except;
-
-    let mut deferred_groups: BTreeMap<String, Vec<String>> = BTreeMap::new();
-
-    for (key, prop) in lazies {
-        let include = if partial_for_this_component {
-            only.contains(&key)
-        } else {
-            false // Lazy/Optional default to "not included" outside partials
-        };
-        if include && !except.contains(&key) {
-            let v = (prop.closure)().await;
-            set_top(&mut tree, &key, v);
-        } else {
-            remove_top(&mut tree, &key);
+    // 1) Merge shared under base. `errors` is an always prop by protocol.
+    let mut map = match base.value {
+        Value::Object(map) => map,
+        Value::Null => Map::new(),
+        other => {
+            tracing::error!(props = %other, "veer: page props must serialize to an object; ignored");
+            Map::new()
         }
+    };
+    // A wrapper label is void when another value replaces the wrapped one: a
+    // page prop over a shared prop, or a closure prop over a plain value.
+    let prop_keys: Vec<String> = props.keys().cloned().collect();
+    let replaced_by_prop = |path: &String| prop_keys.iter().any(|key| is_at_or_below(path, key));
+    let mut always = base.always_paths;
+    let mut wrapper_merges = base.merge_paths;
+    if let Some(Value::Object(mut shared_map)) = shared.as_ref().map(|s| s.value.clone()) {
+        let shared = shared.unwrap_or_default();
+        let overridden = |path: &String| map.contains_key(path.split('.').next().unwrap_or(""));
+        always.extend(shared.always_paths.into_iter().filter(|p| !overridden(p)));
+        wrapper_merges.extend(shared.merge_paths.into_iter().filter(|p| !overridden(p)));
+        shared_map.append(&mut map);
+        map = shared_map;
+    }
+    always.retain(|p| !replaced_by_prop(p));
+    always.insert("errors".to_string());
+    let mut labels = merge;
+    labels
+        .append
+        .extend(wrapper_merges.into_iter().filter(|p| !replaced_by_prop(p)));
+    let map = &mut map;
+
+    // 2) A closure prop replaces a plain value under the same key.
+    for key in props.keys() {
+        remove_path(map, key);
+    }
+    if filter.partial {
+        filter.prune(map, "", &always);
     }
 
-    for (key, prop) in deferreds {
-        if partial_for_this_component && only.contains(&key) {
-            // Second pass: resolve.
-            let v = (prop.closure)().await;
-            set_top(&mut tree, &key, v);
-        } else if !partial_for_this_component {
-            // First pass: advertise.
-            deferred_groups
-                .entry(prop.group.to_string())
-                .or_default()
-                .push(key.clone());
-            remove_top(&mut tree, &key); // do not send a value
-        } else {
-            // Partial but not requested: drop.
-            remove_top(&mut tree, &key);
-        }
+    let mut out = ResolvedProps::default();
+
+    // 3) Labels for plain values.
+    for (paths, target) in [
+        (&labels.append, &mut out.merge_props),
+        (&labels.prepend, &mut out.prepend_props),
+        (&labels.deep, &mut out.deep_merge_props),
+        (&labels.match_on, &mut out.match_props_on),
+    ] {
+        target.extend(
+            paths
+                .iter()
+                .filter(|p| !filter.is_reset(p) && filter.emits_metadata(p))
+                .cloned(),
+        );
     }
 
-    // 3) Apply only/except to non-special keys (only when this is a partial for THIS component).
-    if partial_for_this_component {
-        let always = &base.always_paths;
-        // Keep keys that are either in `only` or marked Always; drop others.
-        // Then apply except (Always survives except, by spec).
-        if let Value::Object(map) = &mut tree {
-            let keys: Vec<String> = map.keys().cloned().collect();
-            for k in keys {
-                let path = format!("/{k}");
-                let is_always = always.contains(&path);
-                let allowed = is_always || only.contains(&k);
-                let excluded = !is_always && except.contains(&k);
-                if !allowed || excluded {
-                    map.remove(&k);
+    // 4) Closure props, in key order so that the metadata is deterministic.
+    let mut props: Vec<(String, Prop)> = props.into_iter().collect();
+    props.sort_by(|a, b| a.0.cmp(&b.0));
+    for (key, prop) in props {
+        let Prop {
+            loader,
+            load,
+            once,
+            merge,
+            scroll_wrapper,
+            rescue,
+        } = prop;
+
+        let emits = filter.emits_metadata(&key);
+        let collect_merge = |out: &mut ResolvedProps| {
+            if filter.is_reset(&key) || !emits {
+                return;
+            }
+            let mut merge = merge.clone();
+            if let Some(wrapper) = &scroll_wrapper {
+                if req.scroll_prepend {
+                    merge.prepend.push(wrapper.clone());
+                } else {
+                    merge.append.push(wrapper.clone());
+                }
+            }
+            if !merge.deep && merge.append.is_empty() && merge.prepend.is_empty() {
+                return;
+            }
+            // A nested path replaces the label of the prop itself.
+            if merge
+                .append
+                .iter()
+                .chain(&merge.prepend)
+                .any(|p| !p.is_empty())
+            {
+                merge.append.retain(|p| !p.is_empty());
+                merge.prepend.retain(|p| !p.is_empty());
+            }
+            if merge.deep {
+                out.deep_merge_props.push(key.clone());
+            } else {
+                out.merge_props
+                    .extend(merge.append.iter().map(|p| join(&key, p)));
+                out.prepend_props
+                    .extend(merge.prepend.iter().map(|p| join(&key, p)));
+            }
+            out.match_props_on
+                .extend(merge.match_on.iter().map(|f| join(&key, f)));
+        };
+        let once_key = once
+            .as_ref()
+            .map(|o| o.key.clone().unwrap_or_else(|| key.clone()));
+        let collect_once = |out: &mut ResolvedProps| {
+            if let (Some(once), Some(once_key), true) = (&once, &once_key, emits) {
+                out.once_props.insert(
+                    once_key.clone(),
+                    OnceEntry {
+                        prop: key.clone(),
+                        expires_at: once.ttl.map(|ttl| {
+                            let now = SystemTime::now()
+                                .duration_since(UNIX_EPOCH)
+                                .unwrap_or_default();
+                            (now + ttl).as_millis() as u64
+                        }),
+                    },
+                );
+            }
+        };
+        // The client lists the once props that it holds; a partial reload ignores the list.
+        let client_has_it = req.is_inertia
+            && once_key.as_ref().is_some_and(|k| {
+                req.except_once_props.contains(k) && !once.as_ref().is_some_and(|o| o.fresh)
+            });
+
+        if filter.partial {
+            if !filter.includes(&key) {
+                continue;
+            }
+        } else {
+            match &load {
+                Load::Optional => {
+                    collect_merge(&mut out);
+                    collect_once(&mut out);
+                    continue;
+                }
+                Load::Deferred(group) => {
+                    if !client_has_it {
+                        out.deferred_props
+                            .entry(group.clone())
+                            .or_default()
+                            .push(key.clone());
+                    }
+                    collect_merge(&mut out);
+                    collect_once(&mut out);
+                    continue;
                 }
+                Load::Eager if client_has_it => {
+                    collect_once(&mut out);
+                    continue;
+                }
+                Load::Eager => {}
             }
         }
-    }
 
-    // 4) Collect merge keys. Inertia's `mergeProps` is a list of top-level keys
-    //    in the protocol wire format, so we only honor paths at depth 1.
-    let mut merge_props: Vec<String> = merges.into_iter().collect();
-    for path in &base.merge_paths {
-        if let Some(k) = path.strip_prefix('/') {
-            if !k.contains('/') {
-                merge_props.push(k.to_string());
+        match loader().await {
+            Ok(loaded) => {
+                insert_path(map, &key, loaded.value);
+                collect_merge(&mut out);
+                if let Some(metadata) = loaded.scroll {
+                    out.scroll_props.insert(
+                        key.clone(),
+                        ScrollEntry {
+                            metadata,
+                            reset: req.reset.contains(&key),
+                        },
+                    );
+                }
+                collect_once(&mut out);
             }
+            Err(error) if rescue => {
+                tracing::error!(prop = %key, %error, "veer: prop failed to resolve; rescued");
+                out.rescued_props.push(key);
+            }
+            Err(message) => return Err(PropError { prop: key, message }),
         }
     }
-    merge_props.sort();
-    merge_props.dedup();
 
-    ResolvedProps {
-        props: tree,
-        merge_props,
-        deferred_props: deferred_groups,
+    for list in [
+        &mut out.merge_props,
+        &mut out.prepend_props,
+        &mut out.deep_merge_props,
+        &mut out.match_props_on,
+    ] {
+        list.sort();
+        list.dedup();
     }
+    out.props = Value::Object(std::mem::take(map));
+    Ok(out)
 }
 
-fn merge_objects(mut a: Value, b: Value) -> Value {
-    match (&mut a, b) {
-        (Value::Object(ao), Value::Object(bo)) => {
-            for (k, v) in bo {
-                ao.insert(k, v);
+fn remove_path(map: &mut Map<String, Value>, path: &str) {
+    match path.split_once('.') {
+        None => {
+            map.remove(path);
+        }
+        Some((head, rest)) => {
+            if let Some(Value::Object(child)) = map.get_mut(head) {
+                remove_path(child, rest);
             }
-            a
         }
-        (_, b) => b,
     }
 }
 
-fn set_top(tree: &mut Value, key: &str, v: Value) {
-    if !tree.is_object() {
-        *tree = Value::Object(Map::new());
-    }
-    if let Value::Object(map) = tree {
-        map.insert(key.to_string(), v);
-    }
-}
-
-fn remove_top(tree: &mut Value, key: &str) {
-    if let Value::Object(map) = tree {
-        map.remove(key);
+/// Insert at a dot path. A parent that is not an object is replaced by one.
+fn insert_path(map: &mut Map<String, Value>, path: &str, value: Value) {
+    match path.split_once('.') {
+        None => {
+            map.insert(path.to_string(), value);
+        }
+        Some((head, rest)) => {
+            let child = map.entry(head).or_insert_with(|| Value::Object(Map::new()));
+            if !child.is_object() {
+                *child = Value::Object(Map::new());
+            }
+            if let Value::Object(child) = child {
+                insert_path(child, rest, value);
+            }
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::props::closure::{DeferredProp, LazyProp};
+    use crate::props::{Always, Merge, ScrollMetadata};
     use serde_json::json;
-
-    fn empty_base(v: Value) -> SerializedBase {
-        SerializedBase {
-            value: v,
-            always_paths: HashSet::new(),
-            merge_paths: HashSet::new(),
-        }
-    }
+    use std::time::Duration;
 
     fn req_full() -> RequestInfo {
         RequestInfo::from_parts(http::Method::GET, "/".into(), &http::HeaderMap::new())
     }
 
-    fn req_partial(component: &str, only: &[&str], except: &[&str]) -> RequestInfo {
+    fn req_inertia() -> RequestInfo {
         let mut r = req_full();
         r.is_inertia = true;
-        r.partial_component = Some(component.into());
+        r
+    }
+
+    fn req_partial(only: &[&str], except: &[&str]) -> RequestInfo {
+        let mut r = req_inertia();
+        r.partial_component = Some("Page".into());
         r.partial_only = only.iter().map(|s| s.to_string()).collect();
         r.partial_except = except.iter().map(|s| s.to_string()).collect();
         r
     }
 
-    #[tokio::test]
-    async fn full_request_excludes_lazy() {
-        let req = req_full();
-        let mut lazies = HashMap::new();
-        lazies.insert(
-            "stats".into(),
-            LazyProp {
-                closure: Box::new(|| Box::pin(async { json!({"hits": 1}) })),
-            },
-        );
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "Users/Index",
-            base: empty_base(json!({"users": [1,2]})),
-            lazies,
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
-            shared: None,
-        })
-        .await;
-        assert_eq!(resolved.props, json!({"users": [1,2]}));
+    fn value(v: Value) -> Prop {
+        Prop::new(move || async move { v })
     }
 
-    #[tokio::test]
-    async fn partial_request_resolves_only_requested_lazy() {
-        let req = req_partial("Users/Index", &["stats"], &[]);
-        let mut lazies = HashMap::new();
-        lazies.insert(
-            "stats".into(),
-            LazyProp {
-                closure: Box::new(|| Box::pin(async { json!({"hits": 1}) })),
-            },
-        );
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "Users/Index",
-            base: empty_base(json!({"users": [1,2]})),
-            lazies,
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
+    async fn run(req: &RequestInfo, base: Value, props: Vec<(&str, Prop)>) -> ResolvedProps {
+        resolve(ResolveInput {
+            req,
+            component: "Page",
+            base: serialize_tag_aware(&base).unwrap(),
             shared: None,
+            props: props.into_iter().map(|(k, p)| (k.to_string(), p)).collect(),
+            merge: MergeLabels::default(),
         })
-        .await;
-        // base "users" key dropped (not in only); lazy stats included.
-        assert_eq!(resolved.props, json!({"stats": {"hits": 1}}));
+        .await
+        .unwrap()
     }
 
     #[tokio::test]
-    async fn deferred_first_pass_advertises_group_drops_value() {
-        let req = req_full();
-        let mut deferreds = HashMap::new();
-        deferreds.insert(
-            "expensive".into(),
-            DeferredProp {
-                group: "dashboard",
-                closure: Box::new(|| Box::pin(async { json!("never") })),
-            },
-        );
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "Users/Index",
-            base: empty_base(json!({"users": []})),
-            lazies: HashMap::new(),
-            deferreds,
-            merges: HashSet::new(),
-            shared: None,
-        })
+    async fn full_visit_skips_optional_and_announces_deferred() {
+        let r = run(
+            &req_full(),
+            json!({"users": [1, 2]}),
+            vec![
+                ("stats", value(json!(1)).optional()),
+                ("comments", value(json!(2)).defer()),
+                ("related", value(json!(3)).group("sidebar")),
+                ("now", value(json!(4))),
+            ],
+        )
         .await;
-        assert_eq!(resolved.props, json!({"users": []}));
+        assert_eq!(r.props, json!({"users": [1, 2], "now": 4}));
         assert_eq!(
-            resolved.deferred_props.get("dashboard"),
-            Some(&vec!["expensive".to_string()])
+            serde_json::to_value(&r.deferred_props).unwrap(),
+            json!({"default": ["comments"], "sidebar": ["related"]})
         );
     }
 
     #[tokio::test]
-    async fn deferred_second_pass_resolves() {
-        let req = req_partial("Users/Index", &["expensive"], &[]);
-        let mut deferreds = HashMap::new();
-        deferreds.insert(
-            "expensive".into(),
-            DeferredProp {
-                group: "dashboard",
-                closure: Box::new(|| Box::pin(async { json!(42) })),
-            },
-        );
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "Users/Index",
-            base: empty_base(json!({"users": []})),
-            lazies: HashMap::new(),
-            deferreds,
-            merges: HashSet::new(),
-            shared: None,
-        })
+    async fn partial_reload_resolves_selected_props_only() {
+        let r = run(
+            &req_partial(&["stats", "comments"], &[]),
+            json!({"users": [1, 2], "errors": {}}),
+            vec![
+                ("stats", value(json!(1)).optional()),
+                ("comments", value(json!(2)).defer()),
+                ("other", value(json!(3)).optional()),
+            ],
+        )
         .await;
-        assert_eq!(resolved.props, json!({"expensive": 42}));
-        assert!(resolved.deferred_props.is_empty());
+        // `errors` is an always prop.
+        assert_eq!(r.props, json!({"stats": 1, "comments": 2, "errors": {}}));
+        assert!(r.deferred_props.is_empty());
     }
 
     #[tokio::test]
-    async fn shared_props_merge_under_base() {
-        let req = req_full();
-        let shared = empty_base(json!({"app_name": "Acme", "users": "shared-wins-no"}));
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "X",
-            base: empty_base(json!({"users": "base-wins"})),
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
-            shared: Some(shared),
-        })
+    async fn partial_for_another_component_is_a_full_visit() {
+        let mut req = req_partial(&["stats"], &[]);
+        req.partial_component = Some("Other".into());
+        let r = run(&req, json!({"users": 1}), vec![]).await;
+        assert_eq!(r.props, json!({"users": 1}));
+    }
+
+    #[tokio::test]
+    async fn except_only_partial_keeps_all_other_props() {
+        let r = run(
+            &req_partial(&[], &["b"]),
+            json!({"a": 1, "b": 2}),
+            vec![("lazy", value(json!(3)).optional())],
+        )
         .await;
-        assert_eq!(
-            resolved.props,
-            json!({"app_name": "Acme", "users": "base-wins"})
-        );
+        assert_eq!(r.props, json!({"a": 1, "lazy": 3}));
     }
 
     #[tokio::test]
-    async fn merges_recorded() {
-        let req = req_full();
-        let mut merges = HashSet::new();
-        merges.insert("notifications".to_string());
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "X",
-            base: empty_base(json!({"notifications": ["a"]})),
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges,
-            shared: None,
-        })
+    async fn only_and_except_on_same_key_drops_it() {
+        let r = run(
+            &req_partial(&["a", "b"], &["b"]),
+            json!({"a": 1, "b": 2}),
+            vec![],
+        )
         .await;
-        assert_eq!(resolved.merge_props, vec!["notifications"]);
+        assert_eq!(r.props, json!({"a": 1}));
     }
 
     #[tokio::test]
-    async fn struct_wrappers_detected_via_serialize_tag_aware() {
-        use crate::props::{Always, Merge};
-        use serde::Serialize;
-
-        #[derive(Serialize)]
-        struct Page {
-            users: Vec<&'static str>,
-            cached: Always<i64>,
-            notifs: Merge<Vec<&'static str>>,
-        }
+    async fn dot_paths_filter_nested_values() {
+        let base = json!({"user": {"name": "A", "email": "E", "meta": {"x": 1, "y": 2}}, "z": 1});
+        let r = run(
+            &req_partial(&["user.name", "user.meta"], &["user.meta.y"]),
+            base,
+            vec![],
+        )
+        .await;
+        assert_eq!(r.props, json!({"user": {"name": "A", "meta": {"x": 1}}}));
+    }
 
-        let p = Page {
-            users: vec!["a", "b"],
-            cached: Always(42),
-            notifs: Merge(vec!["x"]),
-        };
-        let base = serialize_tag_aware(&p).unwrap();
-        assert!(base.always_paths.contains("/cached"));
-        assert!(base.merge_paths.contains("/notifs"));
-
-        // Partial reload that asks only for "users" — without Always, "cached" would be dropped.
-        let req = req_partial("Users/Index", &["users"], &[]);
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "Users/Index",
+    #[tokio::test]
+    async fn always_survives_only_and_except_at_any_depth() {
+        let base = json!({"a": 1, "flag": Always(true), "auth": {"user": Always("u"), "x": 1}});
+        let r = run(&req_partial(&["a"], &["flag", "auth"]), base, vec![]).await;
+        assert_eq!(r.props, json!({"a": 1, "flag": true}));
+
+        let base = json!({"a": 1, "auth": {"user": Always("u"), "x": 1}});
+        let r = run(
+            &req_partial(&["auth.x", "auth.user"], &["auth.user"]),
             base,
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
+            vec![],
+        )
+        .await;
+        assert_eq!(r.props, json!({"auth": {"user": "u", "x": 1}}));
+    }
+
+    #[tokio::test]
+    async fn shared_props_merge_under_base_and_wrappers_are_stripped() {
+        let r = resolve(ResolveInput {
+            req: &req_partial(&["users"], &[]),
+            component: "Page",
+            base: serialize_tag_aware(&json!({"users": [1]})).unwrap(),
+            shared: Some(
+                serialize_tag_aware(&json!({"users": [], "auth": Always("me"), "x": 1})).unwrap(),
+            ),
+            props: HashMap::new(),
+            merge: MergeLabels::default(),
+        })
+        .await
+        .unwrap();
+        assert_eq!(r.props, json!({"users": [1], "auth": "me"}));
+    }
+
+    #[tokio::test]
+    async fn merge_labels_from_wrappers_builder_and_props() {
+        let mut merge = MergeLabels::default();
+        merge.prepend.insert("notifications".into());
+        merge.match_on.insert("notifications.id".into());
+        let r = resolve(ResolveInput {
+            req: &req_full(),
+            component: "Page",
+            base: serialize_tag_aware(
+                &json!({"posts": Merge(vec![1]), "feed": {"data": Merge(vec![2])}, "notifications": []}),
+            )
+            .unwrap(),
             shared: None,
+            props: HashMap::from([
+                ("chat".to_string(), value(json!({})).deep_merge().match_on("data.id")),
+                ("log".to_string(), value(json!([])).defer().merge()),
+            ]),
+            merge,
         })
-        .await;
+        .await
+        .unwrap();
+        assert_eq!(r.props["posts"], json!([1]));
+        assert_eq!(r.merge_props, ["feed.data", "log", "posts"]);
+        assert_eq!(r.prepend_props, ["notifications"]);
+        assert_eq!(r.deep_merge_props, ["chat"]);
+        assert_eq!(r.match_props_on, ["chat.data.id", "notifications.id"]);
+    }
 
-        // `cached` survives because it's tagged Always; `users` is included via `only`;
-        // `notifs` is dropped (Merge does not imply Always-survival of partial filters).
-        assert_eq!(resolved.props, json!({"users": ["a", "b"], "cached": 42}));
-        // The merge path is reported in mergeProps regardless of whether the value
-        // was sent this response (clients use it to decide merge semantics if/when
-        // the value is sent).
-        assert!(resolved.merge_props.contains(&"notifs".to_string()));
+    #[tokio::test]
+    async fn reset_and_partial_filters_remove_merge_labels() {
+        let base =
+            json!({"posts": Merge(vec![1]), "tags": Merge(vec![2]), "users": Merge(vec![3])});
+        let mut req = req_partial(&["posts", "tags"], &[]);
+        req.reset.insert("posts".into());
+        let r = run(&req, base, vec![]).await;
+        assert_eq!(r.props, json!({"posts": [1], "tags": [2]}));
+        assert_eq!(r.merge_props, ["tags"]);
     }
 
     #[tokio::test]
-    async fn json_macro_wrappers_are_detected_and_stripped() {
-        // The headline fix: wrappers survive a trip through `serde_json::json!`.
-        use crate::props::{Always, Merge};
-
-        let value = json!({
-            "users": ["a", "b"],
-            "cached": Always(42),
-            "notifs": Merge(["x"]),
-        });
-        let base = serialize_tag_aware(&value).unwrap();
+    async fn once_prop_is_skipped_when_client_holds_it() {
+        let mut req = req_inertia();
+        req.except_once_props.insert("plans".into());
+        req.except_once_props.insert("shared-roles".into());
+        let props = || {
+            vec![
+                ("plans", value(json!([1])).once()),
+                ("roles", value(json!([2])).once_as("shared-roles")),
+                ("rates", value(json!([3])).once().fresh()),
+                ("zones", value(json!([4])).until(Duration::from_secs(60))),
+            ]
+        };
+        let r = run(&req, json!({}), props()).await;
+        assert_eq!(r.props, json!({"rates": [3], "zones": [4]}));
+        assert_eq!(
+            r.once_props["shared-roles"],
+            OnceEntry {
+                prop: "roles".into(),
+                expires_at: None
+            }
+        );
+        assert_eq!(r.once_props["plans"].prop, "plans");
+        assert!(r.once_props["zones"].expires_at.unwrap() > 1_700_000_000_000);
 
-        assert!(base.always_paths.contains("/cached"));
-        assert!(base.merge_paths.contains("/notifs"));
-        // Sentinels are stripped — the JSON sent to the client is clean.
+        // First page load (not an Inertia request): the header is not trusted.
+        let mut first = req_full();
+        first.except_once_props.insert("plans".into());
         assert_eq!(
-            base.value,
-            json!({"users": ["a", "b"], "cached": 42, "notifs": ["x"]})
+            run(&first, json!({}), props()).await.props["plans"],
+            json!([1])
         );
+
+        // A partial reload that selects the prop always resolves it.
+        let mut partial = req_partial(&["plans"], &[]);
+        partial.except_once_props.insert("plans".into());
+        let r = run(&partial, json!({}), props()).await;
+        assert_eq!(r.props, json!({"plans": [1]}));
+        assert_eq!(r.once_props.keys().collect::<Vec<_>>(), ["plans"]);
     }
 
     #[tokio::test]
-    async fn stacked_wrappers_record_both_paths_at_the_same_key() {
-        use crate::props::{Always, Merge};
-
-        #[derive(serde::Serialize)]
-        struct Page {
-            // Top-level key wrapped in both — wire format should treat it as
-            // both always-on and merge.
-            feed: Always<Merge<Vec<&'static str>>>,
-        }
+    async fn deferred_once_prop_is_not_announced_when_client_holds_it() {
+        let mut req = req_inertia();
+        req.except_once_props.insert("plans".into());
+        let r = run(
+            &req,
+            json!({}),
+            vec![("plans", value(json!(1)).defer().once())],
+        )
+        .await;
+        assert!(r.deferred_props.is_empty());
+        assert!(r.once_props.contains_key("plans"));
+    }
 
-        let p = Page {
-            feed: Always(Merge(vec!["a", "b"])),
+    #[tokio::test]
+    async fn failed_prop_is_rescued() {
+        let failing = || {
+            Prop::try_new(|| async { Err::<Value, _>("boom") })
+                .defer()
+                .rescue()
         };
-        let base = serialize_tag_aware(&p).unwrap();
-        assert!(base.always_paths.contains("/feed"));
-        assert!(base.merge_paths.contains("/feed"));
-        assert_eq!(base.value, json!({"feed": ["a", "b"]}));
+        let r = run(
+            &req_partial(&["perms"], &[]),
+            json!({"a": 1}),
+            vec![("perms", failing())],
+        )
+        .await;
+        assert_eq!(r.props, json!({}));
+        assert_eq!(r.rescued_props, ["perms"]);
+        let r = run(&req_full(), json!({}), vec![("perms", failing())]).await;
+        assert!(r.rescued_props.is_empty());
     }
 
     #[tokio::test]
-    async fn nested_wrappers_are_stripped_but_do_not_affect_wire_format() {
-        // Per the Inertia v3 protocol, only top-level keys can be merge/always.
-        // Nested wrappers must still be stripped from the JSON so the client
-        // never sees our sentinel, but they don't contribute to mergeProps.
-        use crate::props::Merge;
-
-        #[derive(serde::Serialize)]
-        struct Page {
-            user: User,
-        }
-        #[derive(serde::Serialize)]
-        struct User {
-            posts: Merge<Vec<&'static str>>,
-        }
+    async fn prop_at_a_nested_path() {
+        let props = || vec![("auth.perms", value(json!(["edit"])).defer())];
+        let base = json!({"auth": {"user": "me", "perms": "stale"}});
 
-        let p = Page {
-            user: User {
-                posts: Merge(vec!["a"]),
-            },
-        };
-        let base = serialize_tag_aware(&p).unwrap();
-        // Path is recorded for diagnostic completeness, but the resolver only
-        // promotes depth-1 paths into mergeProps.
-        assert!(base.merge_paths.contains("/user/posts"));
-        // Sentinel is gone from the wire value.
-        assert_eq!(base.value, json!({"user": {"posts": ["a"]}}));
-
-        let req = req_full();
-        let resolved = resolve(ResolveInput {
-            req: &req,
-            component: "X",
-            base,
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
+        let r = run(&req_full(), base.clone(), props()).await;
+        assert_eq!(r.props, json!({"auth": {"user": "me"}}));
+        assert_eq!(r.deferred_props["default"], ["auth.perms"]);
+
+        let r = run(&req_partial(&["auth.perms"], &[]), base, props()).await;
+        assert_eq!(r.props, json!({"auth": {"perms": ["edit"]}}));
+    }
+
+    #[tokio::test]
+    async fn failed_prop_without_rescue_is_an_error() {
+        let failing = Prop::try_new(|| async { Err::<Value, _>("boom") });
+        let error = resolve(ResolveInput {
+            req: &req_full(),
+            component: "Page",
+            base: SerializedBase::default(),
             shared: None,
+            props: HashMap::from([("perms".to_string(), failing)]),
+            merge: MergeLabels::default(),
         })
-        .await;
-        // No top-level merge keys despite the nested wrapper.
-        assert!(resolved.merge_props.is_empty());
+        .await
+        .unwrap_err();
+        assert_eq!(error.prop, "perms");
     }
 
     #[tokio::test]
-    async fn always_survives_partial_except() {
-        // Always wrappers must survive `X-Inertia-Except` per spec.
-        let req = req_partial("Page", &[], &["cached", "users"]);
-        let base = SerializedBase {
-            value: json!({"cached": 42, "users": [1,2]}),
-            always_paths: ["/cached".to_string()].into_iter().collect(),
-            merge_paths: HashSet::new(),
-        };
-        let resolved = resolve(ResolveInput {
-            req: &req,
+    async fn replaced_values_lose_their_wrapper_labels() {
+        let r = resolve(ResolveInput {
+            req: &req_partial(&["a"], &[]),
             component: "Page",
-            base,
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
-            shared: None,
+            base: serialize_tag_aware(&json!({"notes": [1], "old": Merge(vec![1])})).unwrap(),
+            shared: Some(
+                serialize_tag_aware(&json!({"notes": Merge(vec![0]), "auth": Always(1)})).unwrap(),
+            ),
+            props: HashMap::from([("old".to_string(), value(json!([2])))]),
+            merge: MergeLabels::default(),
         })
-        .await;
-        // `cached` survives (Always); `users` excluded.
-        assert_eq!(resolved.props, json!({"cached": 42}));
+        .await
+        .unwrap();
+        assert!(r.merge_props.is_empty());
+        assert_eq!(r.props, json!({"auth": 1}));
     }
 
     #[tokio::test]
-    async fn only_and_except_collision_on_same_key_drops_it() {
-        // When a key appears in BOTH `only` and `except`, except wins — the key is dropped.
-        // Inertia treats `except` as a strict filter applied after `only`.
-        let req = req_partial("Page", &["a", "b"], &["b"]);
-        let resolved = resolve(ResolveInput {
-            req: &req,
+    async fn non_object_props_keep_shared_props() {
+        let r = resolve(ResolveInput {
+            req: &req_full(),
             component: "Page",
-            base: empty_base(json!({"a": 1, "b": 2, "c": 3})),
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
-            shared: None,
+            base: serialize_tag_aware(&json!([1, 2])).unwrap(),
+            shared: Some(serialize_tag_aware(&json!({"errors": {}})).unwrap()),
+            props: HashMap::new(),
+            merge: MergeLabels::default(),
         })
-        .await;
-        // a: in `only` → kept. b: in both → dropped (except wins). c: not in `only` → dropped.
-        assert_eq!(resolved.props, json!({"a": 1}));
+        .await
+        .unwrap();
+        assert_eq!(r.props, json!({"errors": {}}));
+    }
+
+    #[tokio::test]
+    async fn nested_merge_path_replaces_the_root_label() {
+        let props = vec![
+            (
+                "a",
+                value(json!({}))
+                    .merge()
+                    .append_at("data")
+                    .match_on("data.id"),
+            ),
+            ("b", value(json!([])).match_on("id")),
+        ];
+        let r = run(&req_full(), json!({}), props).await;
+        assert_eq!(r.merge_props, ["a.data"]);
+        assert_eq!(r.match_props_on, ["a.data.id"]);
+    }
+
+    fn scroll() -> Prop {
+        Prop::scroll(|| async {
+            (
+                json!({"data": [1, 2]}),
+                ScrollMetadata::paged("page", 2, true),
+            )
+        })
+    }
+
+    #[tokio::test]
+    async fn scroll_prop_emits_cursor_and_merge_label() {
+        let r = run(&req_full(), json!({}), vec![("posts", scroll())]).await;
+        assert_eq!(r.props, json!({"posts": {"data": [1, 2]}}));
+        assert_eq!(r.merge_props, ["posts.data"]);
+        assert_eq!(
+            serde_json::to_value(&r.scroll_props).unwrap(),
+            json!({"posts": {"pageName": "page", "previousPage": 1, "nextPage": 3, "currentPage": 2, "reset": false}})
+        );
+    }
+
+    #[tokio::test]
+    async fn scroll_prop_honors_prepend_intent_and_reset() {
+        let mut req = req_partial(&["posts"], &[]);
+        req.scroll_prepend = true;
+        let r = run(&req, json!({}), vec![("posts", scroll())]).await;
+        assert_eq!(r.prepend_props, ["posts.data"]);
+        assert!(r.merge_props.is_empty());
+
+        let mut req = req_partial(&["posts"], &[]);
+        req.reset.insert("posts".into());
+        let r = run(&req, json!({}), vec![("posts", scroll())]).await;
+        assert!(r.merge_props.is_empty());
+        assert!(r.scroll_props["posts"].reset);
+    }
+
+    #[tokio::test]
+    async fn deferred_scroll_prop_has_no_cursor_on_full_visit() {
+        let r = run(&req_full(), json!({}), vec![("posts", scroll().defer())]).await;
+        assert_eq!(r.props, json!({}));
+        assert!(r.scroll_props.is_empty());
+        assert_eq!(r.deferred_props["default"], ["posts"]);
+        assert_eq!(r.merge_props, ["posts.data"]);
     }
 }
diff --git a/src/protocol.rs b/src/protocol.rs
index 9a7dc5c..297ae9a 100644
--- a/src/protocol.rs
+++ b/src/protocol.rs
@@ -15,11 +15,26 @@ pub enum ResponseShape {
         /// Redirect destination URL.
         location: String,
     },
-    /// 409 with `X-Inertia-Location` (asset version mismatch or external redirect).
+    /// 302 redirect (external redirect on a non-Inertia request).
+    Found {
+        /// Redirect destination URL.
+        location: String,
+    },
+    /// 409 with `X-Inertia-Location` (external redirect).
     InertiaLocation {
         /// URL sent back in the `X-Inertia-Location` header.
         location: String,
     },
+    /// 409 with `X-Inertia-Location` and `X-Inertia-Version` (asset version mismatch).
+    VersionMismatch {
+        /// URL sent back in the `X-Inertia-Location` header.
+        location: String,
+    },
+    /// 409 with `X-Inertia-Redirect` (redirect whose target has a URL fragment).
+    InertiaRedirect {
+        /// URL sent back in the `X-Inertia-Redirect` header.
+        location: String,
+    },
 }
 
 /// Decision inputs.
@@ -44,31 +59,39 @@ pub enum Redirect {
     External(String),
 }
 
+/// `true` if an Inertia `GET` carries an asset version that is not the server's.
+pub fn is_version_mismatch(req: &RequestInfo, server_version: &str) -> bool {
+    req.is_inertia
+        && req.method == Method::GET
+        && req.client_version.as_deref().unwrap_or("") != server_version
+}
+
 /// Pure decision function. No I/O. No serialization. Just rules.
 pub fn decide(input: DecisionInputs<'_>) -> ResponseShape {
     if let Some(r) = input.redirect {
         return match r {
-            Redirect::External(loc) => ResponseShape::InertiaLocation { location: loc },
-            Redirect::Internal(loc) => {
-                if matches!(
-                    input.req.method,
-                    Method::POST | Method::PUT | Method::PATCH | Method::DELETE
-                ) {
-                    ResponseShape::SeeOther { location: loc }
-                } else {
-                    // GET redirect (e.g. signed-route auth flow). Use 302 semantics via SeeOther.
-                    ResponseShape::SeeOther { location: loc }
-                }
+            // Inertia headers do not survive a hop to another origin, so an XHR
+            // visit gets a 409; a plain browser request follows a normal redirect.
+            Redirect::External(location) if input.req.is_inertia => {
+                ResponseShape::InertiaLocation { location }
+            }
+            Redirect::External(location) => ResponseShape::Found { location },
+            // XHR drops the fragment of a followed redirect, so the client must
+            // make the visit itself.
+            Redirect::Internal(location)
+                if input.req.is_inertia && !input.req.is_prefetch && location.contains('#') =>
+            {
+                ResponseShape::InertiaRedirect { location }
             }
+            // 303 makes the browser follow with a GET after any method.
+            Redirect::Internal(location) => ResponseShape::SeeOther { location },
         };
     }
 
     if input.req.is_inertia {
         // XHR: version mismatch on a GET → 409 reload at same URL.
-        if input.req.method == Method::GET
-            && input.req.client_version.as_deref() != Some(input.server_version)
-        {
-            return ResponseShape::InertiaLocation {
+        if is_version_mismatch(input.req, input.server_version) {
+            return ResponseShape::VersionMismatch {
                 location: input.req.url.clone(),
             };
         }
@@ -142,12 +165,57 @@ mod tests {
         });
         assert_eq!(
             d,
-            ResponseShape::InertiaLocation {
+            ResponseShape::VersionMismatch {
                 location: "/users".into()
             }
         );
     }
 
+    #[test]
+    fn external_redirect_on_plain_request_is_a_302() {
+        let r = req(Method::GET, "/oauth", false, None);
+        let d = decide(DecisionInputs {
+            req: &r,
+            server_version: "v1",
+            redirect: Some(Redirect::External("https://example.com/".into())),
+            csr_only: false,
+        });
+        assert_eq!(
+            d,
+            ResponseShape::Found {
+                location: "https://example.com/".into()
+            }
+        );
+    }
+
+    #[test]
+    fn fragment_redirect_is_an_inertia_redirect_unless_prefetch_or_plain() {
+        let decide_for = |r: &RequestInfo| {
+            decide(DecisionInputs {
+                req: r,
+                server_version: "v1",
+                redirect: Some(Redirect::Internal("/docs#install".into())),
+                csr_only: false,
+            })
+        };
+        let see_other = ResponseShape::SeeOther {
+            location: "/docs#install".into(),
+        };
+        let mut r = req(Method::POST, "/docs", true, Some("v1"));
+        assert_eq!(
+            decide_for(&r),
+            ResponseShape::InertiaRedirect {
+                location: "/docs#install".into()
+            }
+        );
+        r.is_prefetch = true;
+        assert_eq!(decide_for(&r), see_other);
+        assert_eq!(
+            decide_for(&req(Method::POST, "/docs", false, None)),
+            see_other
+        );
+    }
+
     #[test]
     fn xhr_post_with_stale_version_still_returns_json() {
         // POSTs are not subject to the version check — only GETs would force a reload.
diff --git a/src/request.rs b/src/request.rs
index 7e65612..74b9fdb 100644
--- a/src/request.rs
+++ b/src/request.rs
@@ -5,6 +5,7 @@ use std::collections::HashSet;
 
 /// Request information needed to drive the Inertia protocol.
 #[derive(Debug, Clone)]
+#[non_exhaustive]
 pub struct RequestInfo {
     /// HTTP method.
     pub method: Method,
@@ -27,6 +28,18 @@ pub struct RequestInfo {
     pub partial_except: HashSet<String>,
     /// Keys the client wants reset (clear merge state for these).
     pub reset: HashSet<String>,
+    /// Error bag name from `X-Inertia-Error-Bag`, if any.
+    pub error_bag: Option<String>,
+    /// Once-prop keys the client already holds (`X-Inertia-Except-Once-Props`).
+    pub except_once_props: HashSet<String>,
+    /// `true` iff `X-Inertia-Infinite-Scroll-Merge-Intent: prepend` was set.
+    pub scroll_prepend: bool,
+    /// `true` iff `Purpose: prefetch` was set.
+    pub is_prefetch: bool,
+    /// `true` iff `Precognition: true` was set.
+    pub is_precognition: bool,
+    /// Fields from `Precognition-Validate-Only`. Empty means all fields.
+    pub validate_only: HashSet<String>,
 }
 
 impl RequestInfo {
@@ -44,22 +57,12 @@ impl RequestInfo {
                 })
                 .unwrap_or_default()
         }
-        let is_inertia = headers
-            .get(&crate::headers::X_INERTIA)
-            .and_then(|v| v.to_str().ok())
-            == Some("true");
-        let client_version = headers
-            .get(&crate::headers::X_INERTIA_VERSION)
-            .and_then(|v| v.to_str().ok())
-            .map(str::to_owned);
-        let partial_component = headers
-            .get(&crate::headers::X_INERTIA_PARTIAL_COMPONENT)
-            .and_then(|v| v.to_str().ok())
-            .map(str::to_owned);
-        let referer = headers
-            .get(http::header::REFERER)
-            .and_then(|v| v.to_str().ok())
-            .map(str::to_owned);
+        let text = |name: &http::HeaderName| headers.get(name).and_then(|v| v.to_str().ok());
+        let is_inertia = text(&crate::headers::X_INERTIA) == Some("true");
+        let client_version = text(&crate::headers::X_INERTIA_VERSION).map(str::to_owned);
+        let partial_component =
+            text(&crate::headers::X_INERTIA_PARTIAL_COMPONENT).map(str::to_owned);
+        let referer = text(&http::header::REFERER).map(str::to_owned);
         Self {
             method,
             url,
@@ -70,6 +73,15 @@ impl RequestInfo {
             partial_only: split_csv(headers, &crate::headers::X_INERTIA_PARTIAL_DATA),
             partial_except: split_csv(headers, &crate::headers::X_INERTIA_PARTIAL_EXCEPT),
             reset: split_csv(headers, &crate::headers::X_INERTIA_RESET),
+            error_bag: text(&crate::headers::X_INERTIA_ERROR_BAG)
+                .filter(|s| !s.is_empty())
+                .map(str::to_owned),
+            except_once_props: split_csv(headers, &crate::headers::X_INERTIA_EXCEPT_ONCE_PROPS),
+            scroll_prepend: text(&crate::headers::X_INERTIA_INFINITE_SCROLL_MERGE_INTENT)
+                == Some("prepend"),
+            is_prefetch: text(&crate::headers::PURPOSE) == Some("prefetch"),
+            is_precognition: text(&crate::headers::PRECOGNITION) == Some("true"),
+            validate_only: split_csv(headers, &crate::headers::PRECOGNITION_VALIDATE_ONLY),
         }
     }
 
@@ -126,6 +138,30 @@ mod tests {
         assert_eq!(info.client_version.as_deref(), Some("abc123"));
     }
 
+    #[test]
+    fn v3_headers_parsed() {
+        let mut h = HeaderMap::new();
+        h.insert(&crate::headers::X_INERTIA_ERROR_BAG, hv("login"));
+        h.insert(
+            &crate::headers::X_INERTIA_EXCEPT_ONCE_PROPS,
+            hv("plans,roles"),
+        );
+        h.insert(
+            &crate::headers::X_INERTIA_INFINITE_SCROLL_MERGE_INTENT,
+            hv("prepend"),
+        );
+        h.insert(&crate::headers::PURPOSE, hv("prefetch"));
+        h.insert(&crate::headers::PRECOGNITION, hv("true"));
+        h.insert(&crate::headers::PRECOGNITION_VALIDATE_ONLY, hv("email"));
+        let info = RequestInfo::from_parts(Method::POST, "/".into(), &h);
+        assert_eq!(info.error_bag.as_deref(), Some("login"));
+        assert!(info.except_once_props.contains("roles"));
+        assert!(info.scroll_prepend);
+        assert!(info.is_prefetch);
+        assert!(info.is_precognition);
+        assert!(info.validate_only.contains("email"));
+    }
+
     #[test]
     fn partial_reload_parses_only_and_except() {
         let mut h = HeaderMap::new();
diff --git a/src/response.rs b/src/response.rs
index f4ba216..a3b8d16 100644
--- a/src/response.rs
+++ b/src/response.rs
@@ -1,20 +1,21 @@
 //! The response value handlers return.
 
-use crate::props::closure::{DeferredProp, LazyProp};
+use crate::props::resolver::MergeLabels;
+use crate::props::Prop;
 use serde_json::Value;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::future::Future;
 
 /// The mutable response builder returned by `Inertia::render`.
 pub struct InertiaResponse {
     pub(crate) component: String,
     pub(crate) base_props: Value,
-    pub(crate) lazies: HashMap<String, LazyProp>,
-    pub(crate) deferreds: HashMap<String, DeferredProp>,
-    pub(crate) merges: HashSet<String>,
+    pub(crate) props: HashMap<String, Prop>,
+    pub(crate) merge: MergeLabels,
     pub(crate) encrypt_history: bool,
     pub(crate) clear_history: bool,
-    pub(crate) reset_merge_props: Vec<String>,
+    pub(crate) preserve_fragment: bool,
+    pub(crate) preserve_big_integers: Option<bool>,
     pub(crate) skip_ssr: bool,
     pub(crate) redirect: Option<crate::protocol::Redirect>,
     pub(crate) pending_flash: crate::session::Flash,
@@ -25,34 +26,35 @@ impl InertiaResponse {
         Self {
             component: component.into(),
             base_props,
-            lazies: HashMap::new(),
-            deferreds: HashMap::new(),
-            merges: HashSet::new(),
+            props: HashMap::new(),
+            merge: MergeLabels::default(),
             encrypt_history: false,
             clear_history: false,
-            reset_merge_props: Vec::new(),
+            preserve_fragment: false,
+            preserve_big_integers: None,
             skip_ssr: false,
             redirect: None,
             pending_flash: Default::default(),
         }
     }
 
+    /// Attach a closure-resolved [`Prop`] under a key. A dot path (`auth.perms`)
+    /// puts it inside a nested object. It replaces a plain value at the same path.
+    pub fn prop(mut self, key: impl Into<String>, prop: Prop) -> Self {
+        self.props.insert(key.into(), prop);
+        self
+    }
+
     /// Attach a lazy prop (default-excluded; included only on partial reload that names it).
     ///
     /// Inertia v3 calls this concept "optional". `lazy()` is the preferred method name in
     /// this crate; `optional()` is provided as a direct alias for ergonomics.
-    pub fn lazy<F, Fut>(mut self, key: impl Into<String>, f: F) -> Self
+    pub fn lazy<F, Fut>(self, key: impl Into<String>, f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
         Fut: Future<Output = Value> + Send + 'static,
     {
-        self.lazies.insert(
-            key.into(),
-            LazyProp {
-                closure: Box::new(|| Box::pin(f())),
-            },
-        );
-        self
+        self.prop(key, Prop::new(f).optional())
     }
 
     /// Attach an optional prop (default-excluded; included only on partial reload that names it).
@@ -68,24 +70,46 @@ impl InertiaResponse {
     }
 
     /// Attach a deferred prop.
-    pub fn deferred<F, Fut>(mut self, key: impl Into<String>, group: &'static str, f: F) -> Self
+    pub fn deferred<F, Fut>(self, key: impl Into<String>, group: impl Into<String>, f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
         Fut: Future<Output = Value> + Send + 'static,
     {
-        self.deferreds.insert(
-            key.into(),
-            DeferredProp {
-                group,
-                closure: Box::new(|| Box::pin(f())),
-            },
-        );
+        self.prop(key, Prop::new(f).group(group))
+    }
+
+    /// Attach a once prop: resolved one time, then remembered by the client
+    /// across pages. Use [`Self::prop`] for a custom key or an expiry.
+    pub fn once<F, Fut>(self, key: impl Into<String>, f: F) -> Self
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = Value> + Send + 'static,
+    {
+        self.prop(key, Prop::new(f).once())
+    }
+
+    /// Mark a prop path as merge-mode: the client appends to its existing state.
+    /// A dot path merges a nested array (`posts.data`).
+    pub fn merge(mut self, path: impl Into<String>) -> Self {
+        self.merge.append.insert(path.into());
+        self
+    }
+
+    /// Mark a prop path as prepend-mode: the client prepends to its existing state.
+    pub fn prepend(mut self, path: impl Into<String>) -> Self {
+        self.merge.prepend.insert(path.into());
+        self
+    }
+
+    /// Mark a prop path as deep-merge: the client merges objects recursively.
+    pub fn deep_merge(mut self, path: impl Into<String>) -> Self {
+        self.merge.deep.insert(path.into());
         self
     }
 
-    /// Mark a top-level key as merge-mode (client merges into existing state).
-    pub fn merge(mut self, key: impl Into<String>) -> Self {
-        self.merges.insert(key.into());
+    /// Identify items during a merge: `<propPath>.<keyField>`, e.g. `posts.id`.
+    pub fn match_on(mut self, path: impl Into<String>) -> Self {
+        self.merge.match_on.insert(path.into());
         self
     }
 
@@ -95,16 +119,24 @@ impl InertiaResponse {
         self
     }
 
-    /// Set `clearHistory: true`.
+    /// Set `clearHistory: true`. On a redirect, the flag travels with the flash
+    /// data to the page that the redirect lands on.
     pub fn clear_history(mut self) -> Self {
         self.clear_history = true;
         self
     }
 
-    /// Reset merge state for specific keys.
-    pub fn reset_merge(mut self, keys: impl IntoIterator<Item = impl Into<String>>) -> Self {
-        self.reset_merge_props
-            .extend(keys.into_iter().map(Into::into));
+    /// Keep the URL fragment of the original request. On a redirect, the flag
+    /// travels with the flash data to the page that the redirect lands on.
+    pub fn preserve_fragment(mut self) -> Self {
+        self.preserve_fragment = true;
+        self
+    }
+
+    /// Send integers outside the JavaScript safe range as `$bigint` markers,
+    /// which the client revives as `BigInt`. Overrides the config default.
+    pub fn preserve_big_integers(mut self, preserve: bool) -> Self {
+        self.preserve_big_integers = Some(preserve);
         self
     }
 
@@ -116,23 +148,26 @@ impl InertiaResponse {
 
     /// Attach validation errors to be flashed for the next request.
     pub fn with_errors<E: crate::errors::IntoErrorBag>(mut self, errors: E) -> Self {
-        self.pending_flash.errors.extend(errors.into_error_bag());
+        self.pending_flash.errors.extend(errors.into_all_errors());
         self
     }
 
-    /// Attach a named flash bag entry.
+    /// Attach flash data. On a redirect it goes to the next page; on a render it
+    /// goes into the `flash` of this page.
     pub fn with_flash(mut self, key: impl Into<String>, value: impl Into<Value>) -> Self {
         self.pending_flash.bags.insert(key.into(), value.into());
         self
     }
 
-    /// Set an internal redirect destination (303 SeeOther on POST/PUT/PATCH/DELETE).
+    /// Set an internal redirect destination (303 See Other). A target with a
+    /// URL fragment becomes 409 + `X-Inertia-Redirect` for Inertia requests.
     pub fn redirect(mut self, location: impl Into<String>) -> Self {
         self.redirect = Some(crate::protocol::Redirect::Internal(location.into()));
         self
     }
 
-    /// Set an external redirect destination (409 + `X-Inertia-Location`).
+    /// Set an external redirect destination (409 + `X-Inertia-Location` for
+    /// Inertia requests, a plain 302 otherwise).
     pub fn location(mut self, location: impl Into<String>) -> Self {
         self.redirect = Some(crate::protocol::Redirect::External(location.into()));
         self
diff --git a/src/session/cookie.rs b/src/session/cookie.rs
index 3e07c3c..c58d809 100644
--- a/src/session/cookie.rs
+++ b/src/session/cookie.rs
@@ -69,11 +69,7 @@ impl CookieSessionStore {
     }
 
     fn encode(&self, flash: &Flash) -> String {
-        let payload = serde_json::to_vec(&serde_json::json!({
-            "errors": flash.errors,
-            "bags": flash.bags,
-        }))
-        .unwrap();
+        let payload = serde_json::to_vec(flash).unwrap();
         let b64 = URL_SAFE_NO_PAD.encode(&payload);
         let sig = self.sign(b64.as_bytes());
         format!("{b64}.{sig}")
@@ -85,17 +81,7 @@ impl CookieSessionStore {
             return None;
         }
         let bytes = URL_SAFE_NO_PAD.decode(b64).ok()?;
-        let parsed: serde_json::Value = serde_json::from_slice(&bytes).ok()?;
-        Some(Flash {
-            errors: parsed
-                .get("errors")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default(),
-            bags: parsed
-                .get("bags")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default(),
-        })
+        serde_json::from_slice(&bytes).ok()
     }
 
     fn clear_cookie(&self) -> Cookie<'static> {
@@ -164,7 +150,7 @@ mod tests {
     async fn roundtrip_encode_decode_via_cookie() {
         let store = CookieSessionStore::new(vec![0u8; 32]).secure(false);
         let mut flash = Flash::default();
-        flash.errors.insert("name".into(), "required".into());
+        flash.errors.insert("name".into(), vec!["required".into()]);
 
         let mut headers = HeaderMap::new();
         let exts = Extensions::new();
@@ -180,7 +166,7 @@ mod tests {
 
         let req = parts(Some(v));
         let read = store.read_and_clear(&req).await;
-        assert_eq!(read.errors.get("name").unwrap(), "required");
+        assert_eq!(read.errors["name"], ["required"]);
     }
 
     #[tokio::test]
diff --git a/src/session/mod.rs b/src/session/mod.rs
index f4c7161..0f62e17 100644
--- a/src/session/mod.rs
+++ b/src/session/mod.rs
@@ -8,22 +8,32 @@ pub mod tower;
 
 use async_trait::async_trait;
 use http::{request::Parts as RequestParts, Extensions, HeaderMap};
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
 
 /// One-shot flash data carried between two requests via the session store.
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+#[serde(default)]
+#[non_exhaustive]
 pub struct Flash {
-    /// Validation errors keyed by field name.
-    pub errors: HashMap<String, String>,
-    /// Other named flash bags (`success`, `info`, etc.).
+    /// Validation error messages keyed by field name.
+    pub errors: HashMap<String, Vec<String>>,
+    /// Flash data (`success`, `info`, etc.), sent as the page object's `flash`.
     pub bags: HashMap<String, Value>,
+    /// The next page must set `clearHistory`.
+    pub clear_history: bool,
+    /// The next page must set `preserveFragment`.
+    pub preserve_fragment: bool,
 }
 
 impl Flash {
     /// `true` if there's nothing to write.
     pub fn is_empty(&self) -> bool {
-        self.errors.is_empty() && self.bags.is_empty()
+        self.errors.is_empty()
+            && self.bags.is_empty()
+            && !self.clear_history
+            && !self.preserve_fragment
     }
 }
 
diff --git a/src/session/tower.rs b/src/session/tower.rs
index c64f5f9..0bb489a 100644
--- a/src/session/tower.rs
+++ b/src/session/tower.rs
@@ -31,38 +31,10 @@
 use super::{Flash, SessionStore};
 use async_trait::async_trait;
 use http::{request::Parts as RequestParts, Extensions, HeaderMap};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use tower_sessions::Session;
 
 const DEFAULT_KEY: &str = "_veer_flash";
 
-#[derive(Default, Serialize, Deserialize)]
-struct StoredFlash {
-    #[serde(default)]
-    errors: HashMap<String, String>,
-    #[serde(default)]
-    bags: HashMap<String, serde_json::Value>,
-}
-
-impl From<StoredFlash> for Flash {
-    fn from(s: StoredFlash) -> Self {
-        Flash {
-            errors: s.errors,
-            bags: s.bags,
-        }
-    }
-}
-
-impl From<&Flash> for StoredFlash {
-    fn from(f: &Flash) -> Self {
-        StoredFlash {
-            errors: f.errors.clone(),
-            bags: f.bags.clone(),
-        }
-    }
-}
-
 /// One-shot flash store backed by `tower-sessions`.
 #[derive(Clone, Debug)]
 pub struct TowerSessionStore {
@@ -104,8 +76,8 @@ impl SessionStore for TowerSessionStore {
             missing_session_warning();
             return Flash::default();
         };
-        match session.remove::<StoredFlash>(&self.key).await {
-            Ok(Some(stored)) => stored.into(),
+        match session.remove::<Flash>(&self.key).await {
+            Ok(Some(stored)) => stored,
             Ok(None) => Flash::default(),
             Err(e) => {
                 tracing::error!(error = %e, "veer: failed to read flash from tower-sessions");
@@ -123,8 +95,7 @@ impl SessionStore for TowerSessionStore {
             missing_session_warning();
             return;
         };
-        let stored = StoredFlash::from(&flash);
-        if let Err(e) = session.insert(&self.key, stored).await {
+        if let Err(e) = session.insert(&self.key, flash).await {
             tracing::error!(error = %e, "veer: failed to write flash to tower-sessions");
         }
     }
@@ -153,7 +124,7 @@ mod tests {
         let store = TowerSessionStore::new();
 
         let mut flash = Flash::default();
-        flash.errors.insert("email".into(), "invalid".into());
+        flash.errors.insert("email".into(), vec!["invalid".into()]);
         flash.bags.insert("success".into(), serde_json::json!("ok"));
 
         let mut headers = HeaderMap::new();
@@ -165,8 +136,8 @@ mod tests {
         let parts = parts_with_session(session);
         let read = store.read_and_clear(&parts).await;
         assert_eq!(
-            read.errors.get("email").map(String::as_str),
-            Some("invalid")
+            read.errors.get("email").map(Vec::as_slice),
+            Some(&["invalid".to_string()][..])
         );
         assert_eq!(read.bags.get("success"), Some(&serde_json::json!("ok")));
 
diff --git a/src/ssr/http.rs b/src/ssr/http.rs
index e4e2608..ff3cc8e 100644
--- a/src/ssr/http.rs
+++ b/src/ssr/http.rs
@@ -11,6 +11,7 @@ use std::time::Duration;
 pub struct HttpSsrClient {
     client: reqwest::Client,
     url: String,
+    timeout: Option<Duration>,
 }
 
 impl HttpSsrClient {
@@ -20,10 +21,7 @@ impl HttpSsrClient {
             .timeout(Duration::from_secs(5))
             .build()
             .expect("reqwest client");
-        Self {
-            client,
-            url: url.into(),
-        }
+        Self::with_client(client, url)
     }
 
     /// Construct with a custom `reqwest::Client`.
@@ -31,7 +29,26 @@ impl HttpSsrClient {
         Self {
             client,
             url: url.into(),
+            timeout: None,
+        }
+    }
+
+    /// Set the timeout of each request to the SSR server (default 5 seconds
+    /// with [`Self::new`]).
+    pub fn timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(timeout);
+        self
+    }
+
+    /// `true` if the SSR server answers `GET /health`. Use it to wait for the
+    /// server at startup.
+    pub async fn health(&self) -> bool {
+        let base = self.url.strip_suffix("/render").unwrap_or(&self.url);
+        let mut request = self.client.get(format!("{base}/health"));
+        if let Some(timeout) = self.timeout {
+            request = request.timeout(timeout);
         }
+        request.send().await.is_ok_and(|r| r.status().is_success())
     }
 }
 
@@ -46,15 +63,19 @@ struct WireResponse {
 #[async_trait]
 impl SsrClient for HttpSsrClient {
     async fn render(&self, page: &Value) -> Result<SsrPayload, SsrError> {
-        let resp = self
-            .client
-            .post(&self.url)
-            .json(page)
+        let mut request = self.client.post(&self.url).json(page);
+        if let Some(timeout) = self.timeout {
+            request = request.timeout(timeout);
+        }
+        let resp = request
             .send()
             .await
             .map_err(|e| SsrError::Transport(e.to_string()))?;
         if !resp.status().is_success() {
-            return Err(SsrError::Transport(format!("status {}", resp.status())));
+            // A failed render returns JSON with `error`, `type` and `hint`.
+            let status = resp.status();
+            let detail = resp.text().await.unwrap_or_default();
+            return Err(SsrError::Transport(format!("status {status}: {detail}")));
         }
         let body: WireResponse = resp
             .json()
diff --git a/tests/axum_integration.rs b/tests/axum_integration.rs
index 6774ce7..48d411e 100644
--- a/tests/axum_integration.rs
+++ b/tests/axum_integration.rs
@@ -99,7 +99,7 @@ async fn post_redirect_is_303_and_flashes_errors() {
 
     // session now holds the flash
     let g = session.store.lock().await;
-    assert_eq!(g.errors.get("name").unwrap(), "is required");
+    assert_eq!(g.errors["name"], ["is required"]);
 }
 
 #[tokio::test]
@@ -118,9 +118,9 @@ async fn partial_reload_returns_only_requested_lazy() {
     assert_eq!(resp.status(), 200);
     let body = resp.into_body().collect().await.unwrap().to_bytes();
     let page: serde_json::Value = serde_json::from_slice(&body).unwrap();
-    // Partial reload requested only "stats" → base props ("users") + auto-shared
-    // (errors/flash) are stripped by the partial filter; only "stats" remains.
-    assert_eq!(page["props"], json!({"stats": {"hits": 99}}));
+    // Partial reload requested only "stats" → base props ("users") are stripped
+    // by the partial filter; `errors` is an always prop.
+    assert_eq!(page["props"], json!({"stats": {"hits": 99}, "errors": {}}));
 }
 
 #[tokio::test]
diff --git a/tests/fixtures/conformance.json b/tests/fixtures/conformance.json
index 7ebbf71..e6530c7 100644
--- a/tests/fixtures/conformance.json
+++ b/tests/fixtures/conformance.json
@@ -52,7 +52,7 @@
       "request": {
         "method": "GET",
         "uri": "/oauth",
-        "headers": {}
+        "headers": { "x-inertia": "true", "x-inertia-version": "v1" }
       },
       "expect": {
         "status": 409,
diff --git a/tests/spec_coverage.rs b/tests/spec_coverage.rs
index 6226843..fb3075b 100644
--- a/tests/spec_coverage.rs
+++ b/tests/spec_coverage.rs
@@ -63,26 +63,16 @@ async fn encrypt_and_clear_history_flags_serialize_on_wire() {
 }
 
 #[tokio::test]
-async fn reset_merge_props_from_builder_serialize_on_wire() {
+async fn x_inertia_reset_request_header_removes_the_merge_label() {
     let cfg = InertiaConfig::new().version(|| "v1".into());
     let app = Router::new()
         .route(
             "/",
-            get(|i: Inertia| async move { i.render("Home", json!({})).reset_merge(["notifs"]) }),
-        )
-        .layer(InertiaLayer::new(cfg));
-    let resp = app.oneshot(req_inertia("GET", "/", "v1")).await.unwrap();
-    let page = body_json(resp).await;
-    assert_eq!(page["resetMergeProps"], json!(["notifs"]));
-}
-
-#[tokio::test]
-async fn x_inertia_reset_request_header_propagates_to_reset_merge_props() {
-    let cfg = InertiaConfig::new().version(|| "v1".into());
-    let app = Router::new()
-        .route(
-            "/",
-            get(|i: Inertia| async move { i.render("Home", json!({})) }),
+            get(|i: Inertia| async move {
+                i.render("Home", json!({"alpha": [1], "beta": [2]}))
+                    .merge("alpha")
+                    .merge("beta")
+            }),
         )
         .layer(InertiaLayer::new(cfg));
     let r = http::Request::builder()
@@ -90,13 +80,14 @@ async fn x_inertia_reset_request_header_propagates_to_reset_merge_props() {
         .uri("/")
         .header("x-inertia", "true")
         .header("x-inertia-version", "v1")
-        .header("x-inertia-reset", "alpha,beta")
+        .header("x-inertia-reset", "alpha")
         .body(axum::body::Body::empty())
         .unwrap();
     let resp = app.oneshot(r).await.unwrap();
     let page = body_json(resp).await;
-    // Sorted by finalize().
-    assert_eq!(page["resetMergeProps"], json!(["alpha", "beta"]));
+    // A reset prop is sent, but without a merge label, so the client replaces it.
+    assert_eq!(page["props"]["alpha"], json!([1]));
+    assert_eq!(page["mergeProps"], json!(["beta"]));
 }
 
 // =============================================================================
@@ -112,12 +103,27 @@ async fn external_redirect_via_location_returns_409_with_inertia_location_header
             get(|i: Inertia| async move { i.location("https://accounts.example.com/auth") }),
         )
         .layer(InertiaLayer::new(cfg));
-    let resp = app.oneshot(req("GET", "/oauth")).await.unwrap();
+    let resp = app
+        .clone()
+        .oneshot(req_inertia("GET", "/oauth", "v1"))
+        .await
+        .unwrap();
     assert_eq!(resp.status(), 409);
+    // A manual location carries no version header; that is how the client
+    // tells it apart from an asset version change.
+    assert!(resp.headers().get("x-inertia-version").is_none());
     assert_eq!(
         resp.headers().get("x-inertia-location").unwrap(),
         "https://accounts.example.com/auth"
     );
+
+    // A plain browser request follows a normal redirect.
+    let resp = app.oneshot(req("GET", "/oauth")).await.unwrap();
+    assert_eq!(resp.status(), 302);
+    assert_eq!(
+        resp.headers().get("location").unwrap(),
+        "https://accounts.example.com/auth"
+    );
 }
 
 #[tokio::test]
@@ -129,7 +135,10 @@ async fn external_redirect_works_from_post_too() {
             post(|i: Inertia| async move { i.location("https://stripe.example.com/session") }),
         )
         .layer(InertiaLayer::new(cfg));
-    let resp = app.oneshot(req("POST", "/checkout")).await.unwrap();
+    let resp = app
+        .oneshot(req_inertia("POST", "/checkout", "v1"))
+        .await
+        .unwrap();
     assert_eq!(resp.status(), 409);
     assert!(resp
         .headers()
@@ -293,7 +302,7 @@ async fn flashed_errors_appear_as_shared_prop_on_next_get() {
     // Pre-seed the mock session as if a previous request flashed errors.
     {
         let mut g = session.store.lock().await;
-        g.errors.insert("name".into(), "is required".into());
+        g.errors.insert("name".into(), vec!["is required".into()]);
     }
     let cfg = InertiaConfig::new()
         .version(|| "v1".into())
@@ -313,7 +322,7 @@ async fn flashed_errors_appear_as_shared_prop_on_next_get() {
 }
 
 #[tokio::test]
-async fn flashed_messages_appear_under_flash_prop() {
+async fn flashed_messages_appear_under_page_flash() {
     let session = MockSession::default();
     {
         let mut g = session.store.lock().await;
@@ -333,7 +342,8 @@ async fn flashed_messages_appear_under_flash_prop() {
         .await
         .unwrap();
     let page = body_json(resp).await;
-    assert_eq!(page["props"]["flash"]["success"], "Created");
+    assert_eq!(page["flash"]["success"], "Created");
+    assert!(page["props"].get("flash").is_none());
 }
 
 #[cfg(feature = "cookie-session")]
diff --git a/tests/v3_protocol.rs b/tests/v3_protocol.rs
new file mode 100644
index 0000000..d2c2d63
--- /dev/null
+++ b/tests/v3_protocol.rs
@@ -0,0 +1,593 @@
+//! Inertia v3 protocol behavior on the wire. Spec:
+//! <https://inertiajs.com/docs/v3/core-concepts/the-protocol>
+
+mod common;
+
+use axum::response::Redirect;
+use axum::routing::{get, post};
+use axum::Router;
+use common::{req, req_inertia, MockSession};
+use http_body_util::BodyExt;
+use serde_json::{json, Value};
+use tower::ServiceExt;
+use veer::{Inertia, InertiaConfig, InertiaLayer, Prop, ScrollMetadata};
+
+async fn body_string(resp: axum::response::Response) -> String {
+    let bytes = resp.into_body().collect().await.unwrap().to_bytes();
+    String::from_utf8(bytes.to_vec()).unwrap()
+}
+
+async fn page(resp: axum::response::Response) -> Value {
+    assert_eq!(resp.status(), 200);
+    serde_json::from_str(&body_string(resp).await).unwrap()
+}
+
+fn with_headers(
+    method: &str,
+    uri: &str,
+    headers: &[(&str, &str)],
+) -> http::Request<axum::body::Body> {
+    let mut b = http::Request::builder()
+        .method(method)
+        .uri(uri)
+        .header("x-inertia", "true")
+        .header("x-inertia-version", "v1");
+    for (k, v) in headers {
+        b = b.header(*k, *v);
+    }
+    b.body(axum::body::Body::empty()).unwrap()
+}
+
+fn config() -> InertiaConfig {
+    InertiaConfig::new().version(|| "v1".into())
+}
+
+fn home(cfg: InertiaConfig) -> Router {
+    Router::new()
+        .route(
+            "/",
+            get(|i: Inertia| async move { i.render("Home", json!({})) }),
+        )
+        .layer(InertiaLayer::new(cfg))
+}
+
+#[tokio::test]
+async fn version_mismatch_409_echoes_the_version_and_keeps_the_flash() {
+    let session = MockSession::default();
+    session
+        .store
+        .lock()
+        .await
+        .bags
+        .insert("success".into(), json!("Saved"));
+    session
+        .store
+        .lock()
+        .await
+        .errors
+        .insert("name".into(), vec!["bad".into()]);
+    let app = home(config().session(session.clone()));
+
+    let resp = app
+        .oneshot(req_inertia("GET", "/?a=1", "stale"))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 409);
+    assert_eq!(resp.headers().get("x-inertia-location").unwrap(), "/?a=1");
+    assert_eq!(resp.headers().get("x-inertia-version").unwrap(), "v1");
+    assert!(resp.headers().get("x-inertia").is_none());
+    let flash = session.store.lock().await;
+    assert_eq!(flash.bags["success"], "Saved");
+    assert_eq!(flash.errors["name"], ["bad"]);
+}
+
+#[tokio::test]
+async fn plain_handler_responses_follow_the_protocol_too() {
+    let session = MockSession::default();
+    session
+        .store
+        .lock()
+        .await
+        .bags
+        .insert("success".into(), json!("Saved"));
+    let app = Router::new()
+        .route("/text", get(|| async { "plain" }))
+        .route("/empty", post(|| async {}))
+        .route("/go", post(|| async { Redirect::to("/done") }))
+        .route("/anchor", post(|| async { Redirect::to("/docs#install") }))
+        .layer(InertiaLayer::new(config().session(session.clone())));
+
+    let resp = app
+        .clone()
+        .oneshot(req_inertia("GET", "/text", "stale"))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 409);
+    assert_eq!(resp.headers().get("x-inertia-version").unwrap(), "v1");
+
+    // A redirect does not use up the flash data.
+    let resp = app
+        .clone()
+        .oneshot(req_inertia("POST", "/go", "v1"))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 303);
+    assert_eq!(session.store.lock().await.bags["success"], "Saved");
+
+    let resp = app
+        .clone()
+        .oneshot(req_inertia("POST", "/anchor", "v1"))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 409);
+    assert_eq!(
+        resp.headers().get("x-inertia-redirect").unwrap(),
+        "/docs#install"
+    );
+
+    // An empty 200 is not a page: the client goes back.
+    let r = with_headers("POST", "/empty", &[("referer", "/form")]);
+    let resp = app.clone().oneshot(r).await.unwrap();
+    assert_eq!(resp.status(), 303);
+    assert_eq!(resp.headers().get("location").unwrap(), "/form");
+    assert_eq!(
+        app.clone()
+            .oneshot(req("POST", "/empty"))
+            .await
+            .unwrap()
+            .status(),
+        200
+    );
+
+    // A browser keeps the fragment of a normal redirect.
+    let resp = app.oneshot(req("POST", "/anchor")).await.unwrap();
+    assert_eq!(resp.status(), 303);
+}
+
+#[tokio::test]
+async fn fragment_redirect_returns_409_with_inertia_redirect() {
+    let app = Router::new()
+        .route(
+            "/go",
+            post(|i: Inertia| async move { i.redirect("/docs#install") }),
+        )
+        .layer(InertiaLayer::new(config()));
+
+    let resp = app
+        .clone()
+        .oneshot(req_inertia("POST", "/go", "v1"))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 409);
+    assert_eq!(
+        resp.headers().get("x-inertia-redirect").unwrap(),
+        "/docs#install"
+    );
+
+    let prefetch = with_headers("POST", "/go", &[("purpose", "prefetch")]);
+    assert_eq!(app.oneshot(prefetch).await.unwrap().status(), 303);
+}
+
+#[tokio::test]
+async fn html_response_varies_on_x_inertia_and_escapes_the_page_json() {
+    let app = Router::new()
+        .route(
+            "/",
+            get(|i: Inertia| async move {
+                i.render(
+                    "Home",
+                    json!({"html": "<!--<script></script>", "path": "/a"}),
+                )
+            }),
+        )
+        .layer(InertiaLayer::new(config()));
+    let resp = app.oneshot(req("GET", "/")).await.unwrap();
+    assert_eq!(resp.headers().get("vary").unwrap(), "X-Inertia");
+    let html = body_string(resp).await;
+    let start = html.find(r#"type="application/json">"#).unwrap() + 24;
+    let json_text = &html[start..start + html[start..].find("</script>").unwrap()];
+    assert!(!json_text.contains('<'), "{json_text}");
+    let page: Value = serde_json::from_str(json_text).unwrap();
+    assert_eq!(page["props"]["html"], "<!--<script></script>");
+    assert_eq!(page["props"]["path"], "/a");
+}
+
+#[tokio::test]
+async fn errors_default_to_empty_and_nest_under_the_error_bag() {
+    let session = MockSession::default();
+    let app = home(config().session(session.clone()));
+
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("GET", "/", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["props"]["errors"], json!({}));
+
+    session
+        .store
+        .lock()
+        .await
+        .errors
+        .insert("email".into(), vec!["taken".into()]);
+    let r = with_headers("GET", "/", &[("x-inertia-error-bag", "signup")]);
+    let p = page(app.oneshot(r).await.unwrap()).await;
+    assert_eq!(p["props"]["errors"], json!({"signup": {"email": "taken"}}));
+}
+
+#[tokio::test]
+async fn with_all_errors_sends_each_message() {
+    let session = MockSession::default();
+    let messages = vec!["too short".to_string(), "no digit".to_string()];
+    session
+        .store
+        .lock()
+        .await
+        .errors
+        .insert("password".into(), messages.clone());
+    let app = home(config().session(session.clone()));
+    let p = page(app.oneshot(req_inertia("GET", "/", "v1")).await.unwrap()).await;
+    assert_eq!(p["props"]["errors"], json!({"password": "too short"}));
+
+    session
+        .store
+        .lock()
+        .await
+        .errors
+        .insert("password".into(), messages);
+    let app = home(config().session(session.clone()).with_all_errors(true));
+    let p = page(app.oneshot(req_inertia("GET", "/", "v1")).await.unwrap()).await;
+    assert_eq!(
+        p["props"]["errors"],
+        json!({"password": ["too short", "no digit"]})
+    );
+}
+
+#[tokio::test]
+async fn shared_props_are_listed_and_share_once_is_skipped_when_loaded() {
+    let cfg = config()
+        .shared(veer::shared::FnSharedProps(|_: &veer::RequestInfo| async {
+            json!({"auth": {"user": "me"}})
+        }))
+        .share_once("countries", |_| async { json!(["NL"]) });
+    let app = home(cfg);
+
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("GET", "/", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["sharedProps"], json!(["auth", "countries", "errors"]));
+    assert_eq!(p["props"]["countries"], json!(["NL"]));
+    assert_eq!(
+        p["onceProps"],
+        json!({"countries": {"prop": "countries", "expiresAt": null}})
+    );
+
+    let r = with_headers("GET", "/", &[("x-inertia-except-once-props", "countries")]);
+    let p = page(app.oneshot(r).await.unwrap()).await;
+    assert!(p["props"].get("countries").is_none());
+    assert!(p["onceProps"].get("countries").is_some());
+}
+
+#[tokio::test]
+async fn flash_and_history_flags_travel_across_redirects() {
+    let session = MockSession::default();
+    let app = Router::new()
+        .route(
+            "/save",
+            post(|i: Inertia| async move {
+                i.redirect("/hop")
+                    .with_flash("success", json!("Saved"))
+                    .clear_history()
+                    .preserve_fragment()
+            }),
+        )
+        .route("/hop", get(|i: Inertia| async move { i.redirect("/") }))
+        .route(
+            "/",
+            get(
+                |i: Inertia| async move { i.render("Home", json!({})).with_flash("now", json!(1)) },
+            ),
+        )
+        .layer(InertiaLayer::new(config().session(session.clone())));
+
+    assert_eq!(
+        app.clone()
+            .oneshot(req_inertia("POST", "/save", "v1"))
+            .await
+            .unwrap()
+            .status(),
+        303
+    );
+    assert_eq!(
+        app.clone()
+            .oneshot(req_inertia("GET", "/hop", "v1"))
+            .await
+            .unwrap()
+            .status(),
+        303
+    );
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("GET", "/", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["flash"], json!({"success": "Saved", "now": 1}));
+    assert_eq!(p["clearHistory"], true);
+    assert_eq!(p["preserveFragment"], true);
+
+    // One-shot: the next page has only the data that its handler flashes.
+    let p = page(app.oneshot(req_inertia("GET", "/", "v1")).await.unwrap()).await;
+    assert_eq!(p["flash"], json!({"now": 1}));
+    assert!(p.get("clearHistory").is_none());
+}
+
+#[tokio::test]
+async fn big_integers_become_markers_when_enabled() {
+    let app = Router::new()
+        .route(
+            "/",
+            get(|i: Inertia| async move { i.render("Home", json!({"id": u64::MAX, "n": 1})) }),
+        )
+        .route(
+            "/off",
+            get(|i: Inertia| async move {
+                i.render("Home", json!({"id": u64::MAX}))
+                    .preserve_big_integers(false)
+            }),
+        )
+        .layer(InertiaLayer::new(config().preserve_big_integers(true)));
+
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("GET", "/", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["preserveBigIntegers"], true);
+    assert_eq!(p["props"]["id"], json!({"$bigint": "18446744073709551615"}));
+    assert_eq!(p["props"]["n"], 1);
+
+    let p = page(app.oneshot(req_inertia("GET", "/off", "v1")).await.unwrap()).await;
+    assert!(p.get("preserveBigIntegers").is_none());
+    assert_eq!(p["props"]["id"], json!(u64::MAX));
+}
+
+#[tokio::test]
+async fn infinite_scroll_and_rescued_props_on_the_wire() {
+    let app = Router::new()
+        .route(
+            "/posts",
+            get(|i: Inertia| async move {
+                i.render("Posts", json!({}))
+                    .prop(
+                        "posts",
+                        Prop::scroll(|| async {
+                            (json!({"data": [1]}), ScrollMetadata::paged("page", 1, true))
+                        }),
+                    )
+                    .prop(
+                        "perms",
+                        Prop::try_new(|| async { Err::<Value, _>("db down") })
+                            .defer()
+                            .rescue(),
+                    )
+            }),
+        )
+        .layer(InertiaLayer::new(config().encrypt_history(true)));
+
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("GET", "/posts", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["encryptHistory"], true);
+    assert_eq!(p["mergeProps"], json!(["posts.data"]));
+    assert_eq!(p["scrollProps"]["posts"]["nextPage"], 2);
+    assert_eq!(p["deferredProps"], json!({"default": ["perms"]}));
+
+    let r = with_headers(
+        "GET",
+        "/posts",
+        &[
+            ("x-inertia-partial-component", "Posts"),
+            ("x-inertia-partial-data", "perms,posts"),
+            ("x-inertia-infinite-scroll-merge-intent", "prepend"),
+        ],
+    );
+    let p = page(app.oneshot(r).await.unwrap()).await;
+    assert_eq!(p["rescuedProps"], json!(["perms"]));
+    assert!(p["props"].get("perms").is_none());
+    assert_eq!(p["prependProps"], json!(["posts.data"]));
+}
+
+#[tokio::test]
+async fn failed_prop_without_rescue_is_a_500() {
+    let app = Router::new()
+        .route(
+            "/",
+            get(|i: Inertia| async move {
+                i.render("Home", json!({}))
+                    .prop("x", Prop::try_new(|| async { Err::<Value, _>("db down") }))
+            }),
+        )
+        .layer(InertiaLayer::new(config()));
+    let resp = app.oneshot(req_inertia("GET", "/", "v1")).await.unwrap();
+    assert_eq!(resp.status(), 500);
+    assert!(!body_string(resp).await.contains("db down"));
+}
+
+#[tokio::test]
+async fn errors_on_a_render_show_on_that_page_and_flash_survives_plain_responses() {
+    let session = MockSession::default();
+    let app = Router::new()
+        .route(
+            "/form",
+            post(|i: Inertia| async move {
+                i.render("Form", json!({}))
+                    .with_errors(vec![("name", "is required")])
+            }),
+        )
+        .route("/api", get(|| async { "plain" }))
+        .route(
+            "/",
+            get(|i: Inertia| async move { i.render("Home", json!({})) }),
+        )
+        .layer(InertiaLayer::new(config().session(session.clone())));
+
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("POST", "/form", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["props"]["errors"], json!({"name": "is required"}));
+    assert!(session.store.lock().await.is_empty());
+
+    // A plain response between a redirect and its page does not use up the flash.
+    session
+        .store
+        .lock()
+        .await
+        .bags
+        .insert("success".into(), json!("Saved"));
+    app.clone()
+        .oneshot(req_inertia("GET", "/api", "v1"))
+        .await
+        .unwrap();
+    let p = page(app.oneshot(req_inertia("GET", "/", "v1")).await.unwrap()).await;
+    assert_eq!(p["flash"], json!({"success": "Saved"}));
+}
+
+#[tokio::test]
+async fn precognition_answers_204_or_422() {
+    let app = Router::new()
+        .route(
+            "/users",
+            post(|i: Inertia| async move {
+                let p = i.precognition().expect("precognition request");
+                p.respond(Err(vec![("email", "is taken"), ("name", "is required")]))
+            }),
+        )
+        .layer(InertiaLayer::new(config()));
+
+    let r = with_headers(
+        "POST",
+        "/users",
+        &[
+            ("precognition", "true"),
+            ("precognition-validate-only", "email"),
+        ],
+    );
+    let resp = app.clone().oneshot(r).await.unwrap();
+    assert_eq!(resp.status(), 422);
+    assert_eq!(resp.headers().get("precognition").unwrap(), "true");
+    let body: Value = serde_json::from_str(&body_string(resp).await).unwrap();
+    assert_eq!(
+        body,
+        json!({"message": "is taken", "errors": {"email": ["is taken"]}})
+    );
+
+    let r = with_headers(
+        "POST",
+        "/users",
+        &[
+            ("precognition", "true"),
+            ("precognition-validate-only", "phone"),
+        ],
+    );
+    let resp = app.oneshot(r).await.unwrap();
+    assert_eq!(resp.status(), 204);
+    assert_eq!(resp.headers().get("precognition-success").unwrap(), "true");
+}
+
+#[tokio::test]
+async fn devtools_records_entries_and_serves_the_read_api() {
+    let app = Router::new()
+        .route(
+            "/users/{id}",
+            get(|i: Inertia| async move {
+                i.render("Users/Show", json!({"name": "A", "token": "t"}))
+                    .deferred("stats", "side", || async { json!(1) })
+            })
+            .post(|i: Inertia| async move { i.redirect("/users/1") }),
+        )
+        .layer(InertiaLayer::new(config().devtools(veer::DevTools::new())));
+
+    // First page load: the id is in a header and in a script tag.
+    let resp = app.clone().oneshot(req("GET", "/users/1")).await.unwrap();
+    let id = resp.headers()["x-inertia-devtools-id"]
+        .to_str()
+        .unwrap()
+        .to_string();
+    assert_eq!(resp.headers()["x-inertia-devtools-parent-out"], id.as_str());
+    let html = body_string(resp).await;
+    assert!(html.contains(&format!(
+        r#"<script data-inertia-devtools-id type="application/json">"{id}"</script></body>"#
+    )));
+
+    let read = |path: String| {
+        let app = app.clone();
+        async move {
+            let resp = app.oneshot(req("GET", &path)).await.unwrap();
+            let status = resp.status();
+            let body: Value = serde_json::from_str(&body_string(resp).await).unwrap();
+            (status, body)
+        }
+    };
+    let (status, entry) = read(format!("/_inertia/devtools/entries/{id}")).await;
+    assert_eq!(status, 200);
+    let meta = &entry["__meta"];
+    assert_eq!(meta["requestType"], "initial");
+    assert_eq!(meta["component"], "Users/Show");
+    assert_eq!(meta["url"], "http://localhost/users/1");
+    assert_eq!(entry["route"]["uri"], "/users/{id}");
+    assert_eq!(entry["propValues"]["token"], "[REDACTED]");
+    assert_eq!(entry["props"]["stats"]["deferGroup"], "side");
+    assert_eq!(
+        entry["http"]["responseBody"]["value"]["component"],
+        "Users/Show"
+    );
+
+    // An Inertia POST: the JSON body reaches the handler and is recorded.
+    let r = http::Request::builder()
+        .method("POST")
+        .uri("/users/1")
+        .header("x-inertia", "true")
+        .header("content-type", "application/json")
+        .header("content-length", "29")
+        .header("x-inertia-devtools-parent", "root")
+        .header("x-inertia-devtools-tab", "tab-1")
+        .body(axum::body::Body::from(r#"{"name":"B","password":"pw1"}"#))
+        .unwrap();
+    let resp = app.clone().oneshot(r).await.unwrap();
+    assert_eq!(resp.status(), 303);
+    assert_eq!(resp.headers()["x-inertia-devtools-parent-out"], "root");
+
+    let (_, entries) = read("/_inertia/devtools/entries".into()).await;
+    assert_eq!(entries.as_array().unwrap().len(), 2);
+    let post = &entries[0];
+    assert_eq!(post["__meta"]["requestType"], "navigate");
+    assert_eq!(post["__meta"]["redirectLocation"], "/users/1");
+    assert_eq!(post["__meta"]["tabUuid"], "tab-1");
+    assert_eq!(
+        post["http"]["requestBody"],
+        json!({"status": "present", "value": {"name": "B", "password": "[REDACTED]"}})
+    );
+    assert_eq!(read("/_inertia/devtools/entries/nope".into()).await.0, 404);
+
+    // Without the recorder there are no DevTools headers and no read API.
+    let resp = home(config()).oneshot(req("GET", "/")).await.unwrap();
+    assert!(resp.headers().get("x-inertia-devtools-id").is_none());
+}

From deae81e0db10d7d9fe47245d98d87b13a2462753 Mon Sep 17 00:00:00 2001
From: Aditya Tripathi <aditya@climactic.co>
Date: Sat, 3 Oct 2026 22:02:01 +0000
Subject: [PATCH 2/5] feat: typed closure props, session previous URL, devtools
 feature, hardening

- closure props return any `Serialize` value; `register_page!` takes a third
  argument that gives closure props their TypeScript types
- `InertiaConfig::store_previous_url`: `Inertia::back` uses the session's
  previous URL when the request has no `Referer`
- DevTools recorder is behind the `devtools` Cargo feature; entries carry the
  source location of the `render` call
- wrapper marker keys get a random suffix per process, so user data cannot
  name them
- `veer::Head` for the client's `serverHead` option
- a Precognition request with a rejected body still gets a Precognition
  response
- example: typed closure props, a big-integer prop, Inertia client 3.8.0;
  the CSR bootstrap lets the client parse the first page itself
---
 CHANGELOG.md                                  | 11 ++-
 Cargo.toml                                    |  1 +
 README.md                                     | 32 ++++++-
 examples/axum-react-todo/Cargo.toml           |  2 +-
 examples/axum-react-todo/frontend/app.tsx     | 32 +++----
 .../axum-react-todo/frontend/gen/index.ts     | 28 +++++-
 .../frontend/pages/showcase.tsx               | 17 ++--
 examples/axum-react-todo/package.json         |  2 +-
 examples/axum-react-todo/src/lib.rs           | 33 ++++---
 examples/axum-react-todo/src/main.rs          |  4 +-
 examples/axum-react-todo/src/todos.rs         | 43 +++++++++-
 src/adapters/axum/layer.rs                    | 40 ++++++++-
 src/adapters/axum/response.rs                 | 36 ++++++--
 src/bindings/mod.rs                           | 39 +++++++++
 src/config.rs                                 | 29 +++++--
 src/devtools.rs                               | 13 +--
 src/head.rs                                   | 62 +++++++++++++
 src/inertia.rs                                | 13 ++-
 src/lib.rs                                    |  5 ++
 src/props/always.rs                           |  2 +-
 src/props/merge.rs                            |  2 +-
 src/props/mod.rs                              | 35 +++++---
 src/props/prop.rs                             | 32 +++++--
 src/props/resolver.rs                         | 14 ++-
 src/response.rs                               | 24 ++++--
 src/session/mod.rs                            |  5 ++
 tests/v3_protocol.rs                          | 86 +++++++++++++++++++
 27 files changed, 531 insertions(+), 111 deletions(-)
 create mode 100644 src/head.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c56bede..d031bdb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,7 +31,14 @@ Brings the protocol surface up to Inertia client 3.8.0 / `inertia-laravel` 3.5.1
 - Precognition: `Inertia::precognition()` and `Precognition::respond`.
 - `RequestInfo` fields `error_bag`, `except_once_props`, `scroll_prepend`,
   `is_prefetch`, `is_precognition`, `validate_only`.
-- Inertia DevTools protocol: `InertiaConfig::devtools(DevTools::new())` records
+- Closure props return any `Serialize` value, and `register_page!` takes a
+  third argument that gives closure props their TypeScript types.
+- `InertiaConfig::store_previous_url`: `Inertia::back` uses the session's
+  previous URL when the request has no `Referer`.
+- `veer::Head`: escaped `<head>` elements for the client's `serverHead` option.
+- A Precognition request whose body an extractor rejects still gets a
+  Precognition response.
+- Inertia DevTools protocol (`devtools` feature): `InertiaConfig::devtools(DevTools::new())` records
   each request, sets the `X-Inertia-Devtools-*` headers and serves the read API.
 - All validation messages per field: `IntoErrorBag::into_all_errors`,
   `InertiaConfig::with_all_errors`.
@@ -73,6 +80,8 @@ Brings the protocol surface up to Inertia client 3.8.0 / `inertia-laravel` 3.5.1
   `<!--<script>` gave a blank page.
 - Flash data survives a version-mismatch 409 and redirect chains.
 - `Always` / `Merge` wrappers inside shared props are stripped.
+- The wrapper marker keys have a random suffix for each process, so user data
+  cannot name them.
 - Redirect responses no longer run shared props and prop closures.
 - SSR errors include the error body of the SSR server.
 
diff --git a/Cargo.toml b/Cargo.toml
index fd46677..0e51196 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,6 +22,7 @@ validator = ["dep:validator"]
 garde = ["dep:garde"]
 csrf = ["axum", "dep:cookie", "dep:hmac", "dep:sha2", "dep:base64", "dep:getrandom", "dep:subtle"]
 embed = ["axum"]
+devtools = ["axum"]
 ts = ["dep:ts-rs", "dep:inventory"]
 
 [dependencies]
diff --git a/README.md b/README.md
index 29528c2..6569213 100644
--- a/README.md
+++ b/README.md
@@ -207,17 +207,19 @@ An Inertia request gets 409 + `X-Inertia-Location`, which the client honors with
 inertia
     .render("Users/Index", serde_json::json!({ "users": users, "notifications": notifications }))
     .lazy("stats", || async { json!({ "hits": load_stats().await }) })
-    .deferred("expensive", "dashboard", || async { json!(load_expensive().await) })
-    .once("plans", || async { json!(load_plans().await) })
+    .deferred("expensive", "dashboard", || async { load_expensive().await })
+    .once("plans", || async { load_plans().await })
     .prepend("notifications")
     .match_on("notifications.id")
     .prop("posts", Prop::scroll(move || async move {
         let page = load_posts(page_no).await;
         (json!({ "data": page.items }), ScrollMetadata::paged("page", page_no, page.has_more))
     }))
-    .prop("permissions", Prop::try_new(|| async { load_permissions().await.map(|p| json!(p)) }).defer().rescue())
+    .prop("permissions", Prop::try_new(|| async { load_permissions().await }).defer().rescue())
 ```
 
+A closure returns any `Serialize` value (a struct, a `Vec`, or `json!`).
+
 | Method | Behavior |
 |---|---|
 | `lazy(key, closure)` (alias `optional`) | Closure only runs when the client requests this key via a partial reload |
@@ -230,6 +232,10 @@ inertia
 | `preserve_big_integers(bool)` | Send integers outside the JavaScript safe range as `{"$bigint": "…"}`, which the client (3.8+) revives as `BigInt`. `InertiaConfig::preserve_big_integers(true)` sets the default |
 | `no_ssr()` | Skip SSR for this response only |
 
+`inertia.back()` redirects to the `Referer`. With `InertiaConfig::store_previous_url(true)` and a session store, veer also keeps the URL of the last Inertia page visit in the session, and `back()` uses it when the request has no `Referer`.
+
+`veer::Head` builds the prop for the client's `serverHead` option and escapes its values: `Head::new().title("Users").meta("description", "…")`, passed as the `head` prop.
+
 `inertia.with_errors(errors)` keeps all messages of a field. `props.errors` has the first message as a string by default; `InertiaConfig::with_all_errors(true)` sends all of them as an array.
 
 `Prop` composes the Inertia categories the way the protocol does. A dot path as key (`.prop("auth.permissions", …)`) puts the prop inside a nested object:
@@ -337,6 +343,8 @@ For SSR in production, build the sidecar with `vite build --ssr frontend/ssr.tsx
 
 veer implements the [DevTools protocol](https://inertiajs.com/docs/v3/advanced/devtools-protocol), so the Inertia DevTools browser extension shows each request with its props, headers and route.
 
+Enable the `devtools` Cargo feature, then turn the recorder on in development:
+
 ```rust,ignore
 let mut cfg = InertiaConfig::new();
 if cfg!(debug_assertions) {
@@ -344,7 +352,9 @@ if cfg!(debug_assertions) {
 }
 ```
 
-`InertiaLayer` then records one entry for each request (in memory, the 100 newest for each browser tab), adds the `X-Inertia-Devtools-Id` headers, and serves `GET /_inertia/devtools/entries[/{id}]`. Sensitive keys (`password`, `token`, …) and headers (`Cookie`, `Authorization`, …) are redacted. The read API is open by default, so enable the recorder in development only; `DevTools::new().authorize(|request| …)` adds a guard. Source-location links ("open in editor") are not available.
+Without the feature, the recorder is not compiled into the binary.
+
+`InertiaLayer` then records one entry for each request (in memory, the 100 newest for each browser tab), adds the `X-Inertia-Devtools-Id` headers, and serves `GET /_inertia/devtools/entries[/{id}]`. Sensitive keys (`password`, `token`, …) and headers (`Cookie`, `Authorization`, …) are redacted. The read API is open by default, so enable the recorder in development only; `DevTools::new().authorize(|request| …)` adds a guard. The entry has the source location of the `inertia.render` call; the other "open in editor" links (handler, component file) are not available.
 
 </details>
 
@@ -474,6 +484,19 @@ let app = router().build().with_state(state).layer(InertiaLayer::new(cfg));
 
 `build()` returns a regular `axum::Router`, so `.with_state` / `.layer` / `.merge` / anything else just works. Same-path multi-method calls (GET + POST on `/users`) are merged into a single `MethodRouter` automatically — no panic on duplicate paths.
 
+Props that the handler attaches as closures (`once`, `deferred`, `lazy`, `Prop::scroll`, …) are not fields of the props struct. Describe them in a second struct and pass it as the third argument; the page's TS type is then `UsersIndexProps & UsersIndexClosureProps`:
+
+```rust,ignore
+#[derive(TS)]
+#[ts(export)]
+struct UsersIndexClosureProps {
+    plans: Vec<Plan>,        // once prop
+    #[ts(optional)]
+    stats: Option<Stats>,    // deferred prop: absent on the first render
+}
+veer::register_page!(UsersIndexProps, "Users/Index", UsersIndexClosureProps);
+```
+
 `ts-rs` mirrors `#[serde(rename_all)]` into the generated TypeScript, so the same struct drives both wire format and type. Route names follow the Laravel resource convention (`index`/`show`/`create`/`store`/`update`/`destroy`) so they don't collide with JavaScript reserved words.
 
 Add a tiny binary that builds the router (so the runtime route registry populates) and then emits the bundle. Drop this in `src/bin/gen-bindings.rs` inside your app crate — `cargo` auto-discovers it:
@@ -616,6 +639,7 @@ Flash is stored under a single key (`_veer_flash` by default; override with `Tow
 | `garde` | off | `IntoErrorBag` impl for `garde::Report` |
 | `csrf` | off | Inertia/axios-compatible CSRF protection (`CsrfLayer`) |
 | `embed` | off | Embedded-asset serving for single-binary deploys (`EmbeddedAssets`) |
+| `devtools` | off | Recorder + read API for the Inertia DevTools browser extension |
 | `ts` | off | End-to-end TypeScript bindings codegen (`ts-rs` + `inventory`) |
 
 Disabling a feature drops its transitive deps entirely.
diff --git a/examples/axum-react-todo/Cargo.toml b/examples/axum-react-todo/Cargo.toml
index 5fa7d6c..9497ee8 100644
--- a/examples/axum-react-todo/Cargo.toml
+++ b/examples/axum-react-todo/Cargo.toml
@@ -8,7 +8,7 @@ publish = false
 default-run = "axum-react-todo"
 
 [dependencies]
-veer = { path = "../..", features = ["axum", "cookie-session", "csrf", "validator", "ssr", "ts"] }
+veer = { path = "../..", features = ["axum", "cookie-session", "csrf", "validator", "ssr", "ts", "devtools"] }
 axum = "0.8"
 tokio = { version = "1", features = ["full"] }
 serde = { version = "1", features = ["derive"] }
diff --git a/examples/axum-react-todo/frontend/app.tsx b/examples/axum-react-todo/frontend/app.tsx
index 2691e5a..da5b8e8 100644
--- a/examples/axum-react-todo/frontend/app.tsx
+++ b/examples/axum-react-todo/frontend/app.tsx
@@ -12,30 +12,30 @@ import "./app.css";
 //   `#app` mount node already has SSR'd children.
 //
 // - Vite-served index.html (CSR-only mode at :5173): no script tag exists, so
-//   we fetch the page object from the backend (proxied by Vite) and pass it
-//   via `page:`.
-const inertiaScript = document.querySelector(
-  'script[data-page="app"][type="application/json"]',
-);
+//   we fetch the page object from the backend (proxied by Vite) and add the
+//   same script tag. The client then parses it with its own parser, which
+//   also revives big integers.
+const pageScript = 'script[data-page="app"][type="application/json"]';
 
-const initialPageOverride = inertiaScript
-  ? undefined
-  : await fetch(window.location.pathname + window.location.search, {
-      headers: {
-        "X-Inertia": "true",
-        "X-Inertia-Version": "dev",
-        Accept: "application/json",
-      },
-    }).then((r) => r.json());
+if (!document.querySelector(pageScript)) {
+  const response = await fetch(
+    window.location.pathname + window.location.search,
+    { headers: { "X-Inertia": "true", "X-Inertia-Version": "dev" } },
+  );
+  const script = document.createElement("script");
+  script.dataset.page = "app";
+  script.type = "application/json";
+  script.textContent = await response.text();
+  document.body.appendChild(script);
+}
 
 createInertiaApp({
-  ...(initialPageOverride ? { page: initialPageOverride } : {}),
   resolve: (name) =>
     import.meta.glob<{ default: React.ComponentType }>("./pages/**/*.tsx", {
       eager: true,
     })[`./pages/${name}.tsx`].default,
   setup({ el, App, props }) {
-    if (inertiaScript && el.childNodes.length > 0) {
+    if (el.childNodes.length > 0) {
       hydrateRoot(el, <App {...props} />);
     } else {
       createRoot(el).render(<App {...props} />);
diff --git a/examples/axum-react-todo/frontend/gen/index.ts b/examples/axum-react-todo/frontend/gen/index.ts
index 2a6b361..a798e11 100644
--- a/examples/axum-react-todo/frontend/gen/index.ts
+++ b/examples/axum-react-todo/frontend/gen/index.ts
@@ -35,9 +35,33 @@ export type ErrorBag = Record<string, string>;
 
 export type Flash = Record<string, unknown>;
 
+export type Feed = { data: Array<FeedItem>, };
+
+export type FeedItem = { id: number, title: string, };
+
 export type HomeProps = Record<symbol, never>;
 
-export type ShowcaseProps = Record<symbol, never>;
+export type ShowcaseClosureProps = { 
+/**
+ * Once prop.
+ */
+plans: Array<string>, 
+/**
+ * Deferred prop: absent on the first render.
+ */
+stats?: Stats, 
+/**
+ * Infinite-scroll prop.
+ */
+feed: Feed, };
+
+export type ShowcaseProps = { 
+/**
+ * Larger than JavaScript's safe integer range: sent as a `BigInt`.
+ */
+orderId: bigint, };
+
+export type Stats = { todos: number, };
 
 export type Todo = { id: bigint, title: string, done: boolean, };
 
@@ -47,7 +71,7 @@ export type TodosIndexProps = { todos: Array<Todo>, };
 
 export type Pages =
   | { component: "home"; props: HomeProps }
-  | { component: "showcase"; props: ShowcaseProps }
+  | { component: "showcase"; props: ShowcaseProps & ShowcaseClosureProps }
   | { component: "todos/create"; props: TodosCreateProps }
   | { component: "todos/index"; props: TodosIndexProps };
 
diff --git a/examples/axum-react-todo/frontend/pages/showcase.tsx b/examples/axum-react-todo/frontend/pages/showcase.tsx
index f2ff8b1..4f0643d 100644
--- a/examples/axum-react-todo/frontend/pages/showcase.tsx
+++ b/examples/axum-react-todo/frontend/pages/showcase.tsx
@@ -1,16 +1,10 @@
 import { Deferred, InfiniteScroll, router, usePage } from "@inertiajs/react";
 import Button from "../components/Button";
 import Layout from "../components/Layout";
-import { showcase } from "../gen";
+import { showcase, type Pages } from "../gen";
 
-type Item = { id: number; title: string };
-
-// The closure props that the handler attaches (see `showcase` in src/lib.rs).
-type Props = {
-  plans: string[];
-  stats?: { todos: number };
-  feed: { data: Item[] };
-};
+// Generated from `ShowcaseProps & ShowcaseClosureProps` (see src/todos.rs).
+type Props = Extract<Pages, { component: "showcase" }>["props"];
 
 export default function Showcase() {
   const { props } = usePage<Props>();
@@ -19,6 +13,11 @@ export default function Showcase() {
     <Layout>
       <h1>Showcase</h1>
 
+      <h2>Big integer</h2>
+      <p id="order">
+        Order {String(props.orderId)} ({typeof props.orderId})
+      </p>
+
       <h2>Once prop</h2>
       <p id="plans">Plans: {props.plans.join(", ")}</p>
 
diff --git a/examples/axum-react-todo/package.json b/examples/axum-react-todo/package.json
index e79a18b..f12d55f 100644
--- a/examples/axum-react-todo/package.json
+++ b/examples/axum-react-todo/package.json
@@ -9,7 +9,7 @@
     "ssr:dev": "bun frontend/ssr.tsx"
   },
   "dependencies": {
-    "@inertiajs/react": "^3.7.1",
+    "@inertiajs/react": "^3.8.0",
     "react": "^19.3.0",
     "react-dom": "^19.3.0"
   },
diff --git a/examples/axum-react-todo/src/lib.rs b/examples/axum-react-todo/src/lib.rs
index 1b4e423..0b239e4 100644
--- a/examples/axum-react-todo/src/lib.rs
+++ b/examples/axum-react-todo/src/lib.rs
@@ -4,7 +4,10 @@ use axum::extract::{Path, Query, State};
 use axum::response::IntoResponse;
 use serde_json::{json, Value};
 use std::time::Duration;
-use todos::{HomeProps, NewTodo, ShowcaseProps, TodoStore, TodosCreateProps, TodosIndexProps};
+use todos::{
+    Feed, FeedItem, HomeProps, NewTodo, ShowcaseProps, Stats, TodoStore, TodosCreateProps,
+    TodosIndexProps,
+};
 use validator::Validate;
 use veer::{Inertia, InertiaForm, Method::*, Prop, ScrollMetadata};
 
@@ -35,11 +38,19 @@ async fn showcase(
 ) -> impl IntoResponse {
     let page = query.page.unwrap_or(1).clamp(1, 3);
     inertia
-        .render("showcase", ShowcaseProps {})
-        .once("plans", || async { json!(["Free", "Pro", "Team"]) })
+        .render(
+            "showcase",
+            ShowcaseProps {
+                order_id: 900_719_925_474_099_988,
+            },
+        )
+        .preserve_big_integers(true)
+        .once("plans", || async { vec!["Free", "Pro", "Team"] })
         .deferred("stats", "default", move || async move {
             tokio::time::sleep(Duration::from_millis(300)).await;
-            json!({ "todos": store.all().len() })
+            Stats {
+                todos: store.all().len(),
+            }
         })
         .prop(
             "broken",
@@ -50,14 +61,14 @@ async fn showcase(
         .prop(
             "feed",
             Prop::scroll(move || async move {
-                let first = (page - 1) * 20;
-                let items: Vec<Value> = (first + 1..=first + 20)
-                    .map(|n| json!({ "id": n, "title": format!("Item {n}") }))
+                let first = (page as u32 - 1) * 20;
+                let data = (first + 1..=first + 20)
+                    .map(|id| FeedItem {
+                        id,
+                        title: format!("Item {id}"),
+                    })
                     .collect();
-                (
-                    json!({ "data": items }),
-                    ScrollMetadata::paged("page", page, page < 3),
-                )
+                (Feed { data }, ScrollMetadata::paged("page", page, page < 3))
             })
             .match_on("data.id"),
         )
diff --git a/examples/axum-react-todo/src/main.rs b/examples/axum-react-todo/src/main.rs
index 7cfc1d6..e41f8e6 100644
--- a/examples/axum-react-todo/src/main.rs
+++ b/examples/axum-react-todo/src/main.rs
@@ -29,8 +29,8 @@ async fn main() {
     let mut cfg = InertiaConfig::new().version(|| "dev".into()).session(
         CookieSessionStore::new(b"01234567890123456789012345678901".to_vec()).secure(false),
     );
-    // Record requests for the Inertia DevTools browser extension. The read
-    // API has no authorization, so this is for debug builds only.
+    // Record requests for the Inertia DevTools browser extension (`devtools`
+    // feature). The read API is open, so this is for debug builds only.
     if cfg!(debug_assertions) {
         cfg = cfg.devtools(DevTools::new());
     }
diff --git a/examples/axum-react-todo/src/todos.rs b/examples/axum-react-todo/src/todos.rs
index ecade24..290d803 100644
--- a/examples/axum-react-todo/src/todos.rs
+++ b/examples/axum-react-todo/src/todos.rs
@@ -54,12 +54,47 @@ impl TodoStore {
 pub struct HomeProps {}
 veer::register_page!(HomeProps, "home");
 
-/// The closure props of the showcase page (`plans`, `stats`, `broken`, `feed`)
-/// are attached in the handler, so they are not part of this type.
 #[derive(Serialize, TS)]
 #[ts(export)]
-pub struct ShowcaseProps {}
-veer::register_page!(ShowcaseProps, "showcase");
+#[serde(rename_all = "camelCase")]
+pub struct ShowcaseProps {
+    /// Larger than JavaScript's safe integer range: sent as a `BigInt`.
+    pub order_id: u64,
+}
+
+#[derive(Serialize, TS)]
+#[ts(export)]
+pub struct Stats {
+    pub todos: usize,
+}
+
+#[derive(Serialize, TS)]
+#[ts(export)]
+pub struct FeedItem {
+    pub id: u32,
+    pub title: String,
+}
+
+#[derive(Serialize, TS)]
+#[ts(export)]
+pub struct Feed {
+    pub data: Vec<FeedItem>,
+}
+
+/// The props that the `showcase` handler attaches as closures. This type
+/// gives them TypeScript types; the handler's closures return the same types.
+#[derive(TS)]
+#[ts(export)]
+pub struct ShowcaseClosureProps {
+    /// Once prop.
+    pub plans: Vec<String>,
+    /// Deferred prop: absent on the first render.
+    #[ts(optional)]
+    pub stats: Option<Stats>,
+    /// Infinite-scroll prop.
+    pub feed: Feed,
+}
+veer::register_page!(ShowcaseProps, "showcase", ShowcaseClosureProps);
 
 #[derive(Serialize, TS)]
 #[ts(export)]
diff --git a/src/adapters/axum/layer.rs b/src/adapters/axum/layer.rs
index 59d608c..36d4c11 100644
--- a/src/adapters/axum/layer.rs
+++ b/src/adapters/axum/layer.rs
@@ -2,10 +2,13 @@
 //! finalizes any `InertiaResponseMarker` produced by handlers.
 
 use super::extractor::PerRequest;
+#[cfg(feature = "devtools")]
+use super::response::RecordedPage;
 use super::response::{
-    finalize, finish_with_flash, redirect, version_mismatch, InertiaResponseMarker, RecordedPage,
+    finalize, finish_with_flash, redirect, version_mismatch, InertiaResponseMarker,
 };
 use crate::config::InertiaConfig;
+#[cfg(feature = "devtools")]
 use crate::devtools::{self, Finished};
 use crate::headers as veer_headers;
 use crate::protocol::is_version_mismatch;
@@ -69,11 +72,15 @@ where
         let cfg = self.config.clone();
         let mut inner = self.inner.clone();
         Box::pin(async move {
+            #[cfg_attr(not(feature = "devtools"), allow(unused_mut))]
             let (mut parts, mut body) = req.into_parts();
 
             // DevTools: answer the read API, or start a recording.
+            #[cfg(feature = "devtools")]
             let mut recording = None;
+            #[cfg(feature = "devtools")]
             let mut request_body = devtools::body_empty();
+            #[cfg(feature = "devtools")]
             if let Some(devtools) = &cfg.devtools {
                 if let Some((status, json)) = devtools.read_api(&parts) {
                     let mut resp = Response::new(Body::from(json));
@@ -111,7 +118,10 @@ where
                 config: cfg.clone(),
                 flash: Arc::new(flash),
                 req_extensions: extensions_snapshot.clone(),
+                #[cfg(feature = "devtools")]
                 devtools_id: recording.as_ref().map(|r| r.id.clone()),
+                #[cfg(not(feature = "devtools"))]
+                devtools_id: None,
             };
             parts.extensions.insert(per_request.clone());
 
@@ -147,6 +157,30 @@ where
                     .append(&veer_headers::VARY, HeaderValue::from_static("X-Inertia"));
             }
 
+            // A validation request must get a Precognition response, also when
+            // an extractor rejected the body before the handler ran.
+            if req_info.is_precognition && !resp.headers().contains_key(&veer_headers::PRECOGNITION)
+            {
+                if resp.status() == StatusCode::UNPROCESSABLE_ENTITY {
+                    let body = r#"{"message":"The given data was invalid.","errors":{}}"#;
+                    *resp.body_mut() = Body::from(body);
+                    resp.headers_mut().remove(http::header::CONTENT_LENGTH);
+                    resp.headers_mut().insert(
+                        http::header::CONTENT_TYPE,
+                        HeaderValue::from_static("application/json"),
+                    );
+                }
+                resp.headers_mut().insert(
+                    &veer_headers::PRECOGNITION,
+                    HeaderValue::from_static("true"),
+                );
+                resp.headers_mut().append(
+                    &veer_headers::VARY,
+                    HeaderValue::from_static("Precognition"),
+                );
+            }
+
+            #[cfg(feature = "devtools")]
             if let Some(recording) = recording {
                 let page = resp.extensions_mut().remove::<RecordedPage>();
                 for (name, value) in [
@@ -166,7 +200,8 @@ where
                     request_body,
                     status: resp.status(),
                     response_headers: resp.headers(),
-                    page: page.as_ref().map(|p| &*p.0),
+                    page: page.as_ref().map(|p| &*p.page),
+                    render_source: page.as_ref().and_then(|p| p.source),
                     response_is_empty: http_body::Body::size_hint(resp.body()).exact() == Some(0),
                     route: extensions_snapshot
                         .get::<axum::extract::MatchedPath>()
@@ -179,6 +214,7 @@ where
     }
 }
 
+#[cfg(feature = "devtools")]
 /// Capture the request body for a DevTools entry. Only a JSON body of a known,
 /// small size is read; it is then handed on unchanged.
 async fn capture_request_body(
diff --git a/src/adapters/axum/response.rs b/src/adapters/axum/response.rs
index 05dec5a..27ae441 100644
--- a/src/adapters/axum/response.rs
+++ b/src/adapters/axum/response.rs
@@ -179,6 +179,16 @@ pub(crate) async fn finalize(
     // Flash data from the previous request, then data flashed by this handler.
     page.flash = incoming.bags.clone().into_iter().collect();
     page.flash.extend(std::mem::take(&mut pending.bags));
+    // As the Laravel adapter: page visits by XHR, not partial reloads or prefetches.
+    let is_partial = req_info.partial_component.as_deref() == Some(builder.component.as_str());
+    if cfg.store_previous_url
+        && req_info.is_inertia
+        && req_info.method == http::Method::GET
+        && !req_info.is_prefetch
+        && !is_partial
+    {
+        pending.previous_url = Some(req_info.url.clone());
+    }
     if builder
         .preserve_big_integers
         .unwrap_or(cfg.preserve_big_integers)
@@ -189,10 +199,10 @@ pub(crate) async fn finalize(
     }
 
     // The DevTools recorder reads the page from the response extensions.
-    let recorded = per
-        .devtools_id
-        .as_ref()
-        .map(|_| RecordedPage(Arc::new(serde_json::to_value(&page).unwrap_or_default())));
+    let recorded = per.devtools_id.as_ref().map(|_| RecordedPage {
+        page: Arc::new(serde_json::to_value(&page).unwrap_or_default()),
+        source: builder.render_source,
+    });
 
     let mut response = if decision == ResponseShape::Json {
         let body = serde_json::to_vec(&page).unwrap_or_else(|e| {
@@ -244,7 +254,11 @@ pub(crate) async fn finalize(
             .unwrap_or_else(|e| format!("root view error: {e}"));
         // The extension sees the first page load through the DOM only.
         if let (Some(id), Some(at)) = (&per.devtools_id, html.rfind("</body>")) {
-            html.insert_str(at, &crate::devtools::Recording::script_tag(id));
+            let tag = format!(
+                r#"<script data-inertia-devtools-id type="application/json">{}</script>"#,
+                Value::from(id.as_str())
+            );
+            html.insert_str(at, &tag);
         }
         let mut r = Response::new(Body::from(html));
         r.headers_mut().insert(
@@ -262,7 +276,11 @@ pub(crate) async fn finalize(
 
 /// The rendered page object, for the DevTools recorder.
 #[derive(Clone)]
-pub(crate) struct RecordedPage(pub Arc<Value>);
+#[cfg_attr(not(feature = "devtools"), allow(dead_code))]
+pub(crate) struct RecordedPage {
+    pub page: Arc<Value>,
+    pub source: Option<&'static std::panic::Location<'static>>,
+}
 
 /// An empty response that points the client at `location` through `header`.
 pub(crate) fn redirect(status: StatusCode, header: HeaderName, location: &str) -> Response<Body> {
@@ -291,10 +309,14 @@ pub(crate) fn version_mismatch(location: &str, version: &str) -> Response<Body>
 
 pub(crate) async fn finish_with_flash(
     mut response: Response<Body>,
-    pending: crate::session::Flash,
+    mut pending: crate::session::Flash,
     per: &PerRequest,
 ) -> Response<Body> {
     if let Some(session) = &per.config.session {
+        // The previous URL is not one-shot: carry it on.
+        if pending.previous_url.is_none() {
+            pending.previous_url = per.flash.previous_url.clone();
+        }
         session
             .write(response.headers_mut(), &per.req_extensions, pending)
             .await;
diff --git a/src/bindings/mod.rs b/src/bindings/mod.rs
index 5c93124..f67a4fb 100644
--- a/src/bindings/mod.rs
+++ b/src/bindings/mod.rs
@@ -74,8 +74,47 @@ pub trait InertiaPageProps {
 ///
 /// veer::register_page!(UsersIndexProps, "Users/Index");
 /// ```
+///
+/// Props that the handler attaches as closures (`once`, `deferred`, `lazy`,
+/// `Prop::scroll`, …) are not fields of the props struct. Describe them in a
+/// second struct (it needs only `ts_rs::TS`) and pass it as the third
+/// argument; the page's TS props type is then the intersection of the two:
+///
+/// ```ignore
+/// #[derive(TS)]
+/// #[ts(export)]
+/// struct UsersIndexClosureProps {
+///     plans: Vec<Plan>,            // once prop: always present
+///     #[ts(optional)]
+///     stats: Option<Stats>,        // deferred prop: absent on first render
+/// }
+///
+/// veer::register_page!(UsersIndexProps, "Users/Index", UsersIndexClosureProps);
+/// ```
 #[macro_export]
 macro_rules! register_page {
+    ($ty:ty, $component:literal, $closure_ty:ty) => {
+        impl $crate::bindings::InertiaPageProps for $ty {
+            const COMPONENT: &'static str = $component;
+        }
+        $crate::__private::inventory::submit! {
+            $crate::bindings::PageEntry {
+                component: $component,
+                ts_name: || {
+                    let cfg = $crate::__private::ts_rs::Config::from_env();
+                    format!(
+                        "{} & {}",
+                        <$ty as $crate::__private::ts_rs::TS>::ident(&cfg),
+                        <$closure_ty as $crate::__private::ts_rs::TS>::ident(&cfg),
+                    )
+                },
+                collect_decls: |out| {
+                    $crate::bindings::collect_decls::<$ty>(out);
+                    $crate::bindings::collect_decls::<$closure_ty>(out);
+                },
+            }
+        }
+    };
     ($ty:ty, $component:literal) => {
         impl $crate::bindings::InertiaPageProps for $ty {
             const COMPONENT: &'static str = $component;
diff --git a/src/config.rs b/src/config.rs
index b035cf4..80a9bfd 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -6,7 +6,6 @@ use crate::root_view::{MinimalRootView, RootView};
 use crate::session::SessionStore;
 use crate::shared::SharedProps;
 use crate::ssr::SsrClient;
-use serde_json::Value;
 use std::borrow::Cow;
 use std::future::Future;
 use std::sync::Arc;
@@ -28,6 +27,8 @@ pub struct InertiaConfig {
     pub(crate) encrypt_history: bool,
     pub(crate) preserve_big_integers: bool,
     pub(crate) with_all_errors: bool,
+    pub(crate) store_previous_url: bool,
+    #[cfg(feature = "devtools")]
     pub(crate) devtools: Option<crate::devtools::DevTools>,
 }
 
@@ -45,6 +46,8 @@ impl Default for InertiaConfig {
             encrypt_history: false,
             preserve_big_integers: false,
             with_all_errors: false,
+            store_previous_url: false,
+            #[cfg(feature = "devtools")]
             devtools: None,
         }
     }
@@ -103,13 +106,28 @@ impl InertiaConfig {
 
     /// Share a once prop with every page. The closure runs only when the
     /// client does not hold the value yet. A handler prop with the same key wins.
-    pub fn share_once<F, Fut>(mut self, key: impl Into<String>, f: F) -> Self
+    pub fn share_once<F, Fut, T>(mut self, key: impl Into<String>, f: F) -> Self
     where
         F: Fn(&RequestInfo) -> Fut + Send + Sync + 'static,
-        Fut: Future<Output = Value> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
+        T: serde::Serialize,
     {
-        self.shared_once
-            .push((key.into(), Arc::new(move |req| Box::pin(f(req)))));
+        self.shared_once.push((
+            key.into(),
+            Arc::new(move |req| {
+                let value = f(req);
+                Box::pin(async { crate::props::prop::to_json(value.await) })
+            }),
+        ));
+        self
+    }
+
+    /// Store the URL of each Inertia page visit in the session, so that
+    /// [`crate::Inertia::back`] has a target when the request has no `Referer`
+    /// header. Needs a session store. Partial reloads and prefetches are not
+    /// stored.
+    pub fn store_previous_url(mut self, on: bool) -> Self {
+        self.store_previous_url = on;
         self
     }
 
@@ -130,6 +148,7 @@ impl InertiaConfig {
     ///     config = config.devtools(DevTools::new());
     /// }
     /// ```
+    #[cfg(feature = "devtools")]
     pub fn devtools(mut self, devtools: crate::devtools::DevTools) -> Self {
         self.devtools = Some(devtools);
         self
diff --git a/src/devtools.rs b/src/devtools.rs
index db6805e..0f3c2b7 100644
--- a/src/devtools.rs
+++ b/src/devtools.rs
@@ -195,18 +195,11 @@ pub struct Finished<'a> {
     pub response_is_empty: bool,
     /// The matched route pattern, if known.
     pub route: Option<&'a str>,
+    /// Where the page render was called, if known.
+    pub render_source: Option<&'static std::panic::Location<'static>>,
 }
 
 impl Recording {
-    /// The `<script>` tag that lets the extension find the entry of the first
-    /// page load.
-    pub fn script_tag(id: &str) -> String {
-        format!(
-            r#"<script data-inertia-devtools-id type="application/json">{}</script>"#,
-            Value::from(id)
-        )
-    }
-
     /// The batch root: the client sends it back as `X-Inertia-Devtools-Parent`.
     pub fn parent_out(&self, req: &RequestInfo) -> &str {
         match &self.batch_id {
@@ -281,7 +274,7 @@ impl Recording {
             "props": f.page.map_or(json!({}), prop_meta),
             "propValues": prop_values,
             "route": { "name": null, "uri": f.route.unwrap_or(""), "action": null },
-            "renderSource": null,
+            "renderSource": f.render_source.map(|l| json!({ "file": l.file(), "line": l.line() })),
             "componentPath": null,
         }));
     }
diff --git a/src/head.rs b/src/head.rs
new file mode 100644
index 0000000..1f3d1cf
--- /dev/null
+++ b/src/head.rs
@@ -0,0 +1,62 @@
+//! Server-provided `<head>` elements for the client's `serverHead` option.
+//!
+//! The client reads an array of raw HTML strings from a prop (`head` by
+//! default). [`Head`] builds that array and escapes each value.
+
+use serde::Serialize;
+
+/// A list of `<head>` elements. Pass it as the `head` prop.
+///
+/// ```
+/// use veer::Head;
+/// let head = Head::new().title("Users").meta("description", "All <users>");
+/// assert_eq!(
+///     serde_json::to_value(&head).unwrap(),
+///     serde_json::json!([
+///         "<title data-inertia=\"title\">Users</title>",
+///         "<meta data-inertia=\"description\" name=\"description\" content=\"All &lt;users&gt;\">",
+///     ])
+/// );
+/// ```
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
+#[serde(transparent)]
+pub struct Head(Vec<String>);
+
+fn escape(s: &str) -> String {
+    s.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
+}
+
+impl Head {
+    /// An empty list.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add `<title>`.
+    pub fn title(mut self, title: &str) -> Self {
+        self.0.push(format!(
+            r#"<title data-inertia="title">{}</title>"#,
+            escape(title)
+        ));
+        self
+    }
+
+    /// Add `<meta name="…" content="…">`. The name is also the `data-inertia`
+    /// key, so that a later page replaces the element.
+    pub fn meta(mut self, name: &str, content: &str) -> Self {
+        let (name, content) = (escape(name), escape(content));
+        self.0.push(format!(
+            r#"<meta data-inertia="{name}" name="{name}" content="{content}">"#
+        ));
+        self
+    }
+
+    /// Add an element as raw HTML. The caller must escape untrusted values.
+    pub fn raw(mut self, html: impl Into<String>) -> Self {
+        self.0.push(html.into());
+        self
+    }
+}
diff --git a/src/inertia.rs b/src/inertia.rs
index 338d063..77a6e09 100644
--- a/src/inertia.rs
+++ b/src/inertia.rs
@@ -43,7 +43,9 @@ impl Inertia {
     }
 
     /// Render a component with strongly-typed props.
+    #[track_caller]
     pub fn render<P: Serialize>(&self, component: impl Into<String>, props: P) -> InertiaResponse {
+        let caller = std::panic::Location::caller();
         let value = match serde_json::to_value(&props) {
             Ok(v) => v,
             Err(e) => {
@@ -51,7 +53,9 @@ impl Inertia {
                 Value::Null
             }
         };
-        InertiaResponse::new(component, value)
+        let mut response = InertiaResponse::new(component, value);
+        response.render_source = Some(caller);
+        response
     }
 
     /// Internal redirect (303 on POST/PUT/PATCH/DELETE; 302-equivalent SeeOther on GET).
@@ -77,17 +81,18 @@ impl Inertia {
         r
     }
 
-    /// Redirect to the `Referer` header value, or `/` if absent.
+    /// Redirect to the page that the user came from: the `Referer` header,
+    /// then the session's previous URL (see
+    /// [`InertiaConfig::store_previous_url`]), then `/`.
     ///
     /// Useful for POST-then-redirect-back flows: submit a form, then call
     /// `inertia.back()` to send the user back to the page they came from.
-    /// Without a `Referer` header (e.g. direct navigation) the redirect falls
-    /// back to `/`.
     pub fn back(&self) -> InertiaResponse {
         let to = self
             .request
             .referer
             .clone()
+            .or_else(|| self.incoming_flash.previous_url.clone())
             .unwrap_or_else(|| "/".to_string());
         self.redirect(to)
     }
diff --git a/src/lib.rs b/src/lib.rs
index 240f833..e643668 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -37,6 +37,7 @@
 //! | `garde` | off | `IntoErrorBag` impl for `garde::Report` |
 //! | `csrf` | off | Inertia/axios-compatible CSRF layer (`CsrfLayer`) |
 //! | `embed` | off | Embedded-asset serving service (`EmbeddedAssets`) |
+//! | `devtools` | off | Recorder + read API for the Inertia DevTools browser extension |
 //! | `ts` | off | TypeScript bindings codegen (`ts-rs` + `inventory`) |
 //!
 //! # Architecture
@@ -57,9 +58,11 @@
 
 pub mod bigint;
 pub mod config;
+#[cfg(feature = "devtools")]
 pub mod devtools;
 pub mod error;
 pub mod errors;
+pub mod head;
 pub mod headers;
 pub mod inertia;
 pub mod page;
@@ -95,8 +98,10 @@ pub mod __private {
 pub use config::InertiaConfig;
 #[cfg(feature = "csrf")]
 pub use csrf::CsrfTokens;
+#[cfg(feature = "devtools")]
 pub use devtools::DevTools;
 pub use error::VeerError;
+pub use head::Head;
 pub use inertia::Inertia;
 pub use page::PageObject;
 pub use props::{Always, Merge, Prop, ScrollMetadata};
diff --git a/src/props/always.rs b/src/props/always.rs
index 981f730..c48ab8b 100644
--- a/src/props/always.rs
+++ b/src/props/always.rs
@@ -23,7 +23,7 @@ impl<T> Always<T> {
 impl<T: Serialize> Serialize for Always<T> {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         let mut map = s.serialize_map(Some(1))?;
-        map.serialize_entry(super::ALWAYS_SENTINEL, &self.0)?;
+        map.serialize_entry(&super::sentinels().always, &self.0)?;
         map.end()
     }
 }
diff --git a/src/props/merge.rs b/src/props/merge.rs
index 5b88c9c..458901f 100644
--- a/src/props/merge.rs
+++ b/src/props/merge.rs
@@ -27,7 +27,7 @@ impl<T> Merge<T> {
 impl<T: Serialize> Serialize for Merge<T> {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         let mut map = s.serialize_map(Some(1))?;
-        map.serialize_entry(super::MERGE_SENTINEL, &self.0)?;
+        map.serialize_entry(&super::sentinels().merge, &self.0)?;
         map.end()
     }
 }
diff --git a/src/props/mod.rs b/src/props/mod.rs
index 6032cc6..2e95032 100644
--- a/src/props/mod.rs
+++ b/src/props/mod.rs
@@ -9,15 +9,30 @@ pub use always::Always;
 pub use merge::Merge;
 pub use prop::{Prop, ScrollMetadata};
 
-/// Sentinel object key that marks a value as wrapped in [`Always`].
+/// Sentinel object keys that mark a value as wrapped in [`Always`] / [`Merge`].
 ///
-/// The wrapper serializes as `{ALWAYS_SENTINEL: <inner>}`, and the resolver
-/// strips the sentinel back out after recording the path. The key is namespaced
-/// so user data is implausibly unlikely to collide.
-pub(crate) const ALWAYS_SENTINEL: &str = "$$veer_always$$";
-/// Sentinel object key that marks a value as wrapped in [`Merge`]. See
-/// [`ALWAYS_SENTINEL`].
-pub(crate) const MERGE_SENTINEL: &str = "$$veer_merge$$";
+/// A wrapper serializes as `{<sentinel>: <inner>}`, and the resolver strips the
+/// sentinel back out after recording the path. The keys have a random suffix
+/// for each process, so that user data cannot contain them.
+pub(crate) struct Sentinels {
+    pub always: String,
+    pub merge: String,
+}
+
+pub(crate) fn sentinels() -> &'static Sentinels {
+    use std::hash::{BuildHasher, Hasher};
+    static SENTINELS: std::sync::OnceLock<Sentinels> = std::sync::OnceLock::new();
+    SENTINELS.get_or_init(|| {
+        // `RandomState` is seeded from the OS for each process.
+        let nonce = std::collections::hash_map::RandomState::new()
+            .build_hasher()
+            .finish();
+        Sentinels {
+            always: format!("$$veer_always_{nonce:016x}$$"),
+            merge: format!("$$veer_merge_{nonce:016x}$$"),
+        }
+    })
+}
 
 #[cfg(test)]
 mod tests {
@@ -46,8 +61,8 @@ mod tests {
             serde_json::to_value(&p).unwrap(),
             json!({
                 "users": ["a", "b"],
-                "cached": {ALWAYS_SENTINEL: 42},
-                "notifs": {MERGE_SENTINEL: ["x"]},
+                "cached": {sentinels().always.as_str(): 42},
+                "notifs": {sentinels().merge.as_str(): ["x"]},
             })
         );
     }
diff --git a/src/props/prop.rs b/src/props/prop.rs
index 0ce27ec..608a2d3 100644
--- a/src/props/prop.rs
+++ b/src/props/prop.rs
@@ -15,6 +15,14 @@ pub(crate) struct Loaded {
     pub scroll: Option<ScrollMetadata>,
 }
 
+/// Serialize a closure's value. A failure is logged and gives `null`.
+pub(crate) fn to_json<T: Serialize>(value: T) -> Value {
+    serde_json::to_value(value).unwrap_or_else(|error| {
+        tracing::error!(%error, "veer: failed to serialize a prop value; using null");
+        Value::Null
+    })
+}
+
 type Loader =
     Box<dyn FnOnce() -> Pin<Box<dyn Future<Output = Result<Loaded, String>> + Send>> + Send>;
 
@@ -127,15 +135,19 @@ impl Prop {
     }
 
     /// A prop resolved on each full visit, and on partial reloads that select it.
-    pub fn new<F, Fut>(f: F) -> Self
+    ///
+    /// The closure returns any `Serialize` value: a struct, a `Vec`, or
+    /// `serde_json::json!`.
+    pub fn new<F, Fut, T>(f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Value> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
+        T: Serialize,
     {
         Self::from_loader(Box::new(|| {
             Box::pin(async {
                 Ok(Loaded {
-                    value: f().await,
+                    value: to_json(f().await),
                     scroll: None,
                 })
             })
@@ -144,17 +156,18 @@ impl Prop {
 
     /// A prop that can fail. On `Err` the response is a `500`, unless the prop
     /// has [`Self::rescue`].
-    pub fn try_new<F, Fut, E>(f: F) -> Self
+    pub fn try_new<F, Fut, T, E>(f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Result<Value, E>> + Send + 'static,
+        Fut: Future<Output = Result<T, E>> + Send + 'static,
+        T: Serialize,
         E: Display,
     {
         Self::from_loader(Box::new(|| {
             Box::pin(async {
                 match f().await {
                     Ok(value) => Ok(Loaded {
-                        value,
+                        value: to_json(value),
                         scroll: None,
                     }),
                     Err(e) => Err(e.to_string()),
@@ -166,16 +179,17 @@ impl Prop {
     /// An infinite-scroll prop. The closure returns the page value (an object
     /// that holds the items under the wrapper key, `data` by default) and its
     /// cursor metadata.
-    pub fn scroll<F, Fut>(f: F) -> Self
+    pub fn scroll<F, Fut, T>(f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = (Value, ScrollMetadata)> + Send + 'static,
+        Fut: Future<Output = (T, ScrollMetadata)> + Send + 'static,
+        T: Serialize,
     {
         let mut prop = Self::from_loader(Box::new(|| {
             Box::pin(async {
                 let (value, metadata) = f().await;
                 Ok(Loaded {
-                    value,
+                    value: to_json(value),
                     scroll: Some(metadata),
                 })
             })
diff --git a/src/props/resolver.rs b/src/props/resolver.rs
index d5142a2..8b43d84 100644
--- a/src/props/resolver.rs
+++ b/src/props/resolver.rs
@@ -120,15 +120,15 @@ fn strip_sentinels(
     always_paths: &mut HashSet<String>,
     merge_paths: &mut HashSet<String>,
 ) {
-    use crate::props::{ALWAYS_SENTINEL, MERGE_SENTINEL};
+    let sentinels = crate::props::sentinels();
 
     // Unwrap any chain of sentinels at this position, recording each.
     loop {
         let kind = match value.as_object() {
             Some(map) if map.len() == 1 => {
-                if map.contains_key(ALWAYS_SENTINEL) {
+                if map.contains_key(&sentinels.always) {
                     Some(true)
-                } else if map.contains_key(MERGE_SENTINEL) {
+                } else if map.contains_key(&sentinels.merge) {
                     Some(false)
                 } else {
                     None
@@ -773,6 +773,14 @@ mod tests {
         assert_eq!(r.props, json!({"auth": {"perms": ["edit"]}}));
     }
 
+    #[tokio::test]
+    async fn fixed_sentinel_names_in_user_data_are_not_unwrapped() {
+        let base = json!({"a": {"$$veer_merge$$": [1]}, "b": {"$$veer_always$$": 1}});
+        let r = run(&req_full(), base.clone(), vec![]).await;
+        assert_eq!(r.props, base);
+        assert!(r.merge_props.is_empty());
+    }
+
     #[tokio::test]
     async fn failed_prop_without_rescue_is_an_error() {
         let failing = Prop::try_new(|| async { Err::<Value, _>("boom") });
diff --git a/src/response.rs b/src/response.rs
index a3b8d16..a039936 100644
--- a/src/response.rs
+++ b/src/response.rs
@@ -19,6 +19,9 @@ pub struct InertiaResponse {
     pub(crate) skip_ssr: bool,
     pub(crate) redirect: Option<crate::protocol::Redirect>,
     pub(crate) pending_flash: crate::session::Flash,
+    /// Where `Inertia::render` was called (for DevTools).
+    #[cfg_attr(not(feature = "devtools"), allow(dead_code))]
+    pub(crate) render_source: Option<&'static std::panic::Location<'static>>,
 }
 
 impl InertiaResponse {
@@ -35,6 +38,7 @@ impl InertiaResponse {
             skip_ssr: false,
             redirect: None,
             pending_flash: Default::default(),
+            render_source: None,
         }
     }
 
@@ -49,10 +53,11 @@ impl InertiaResponse {
     ///
     /// Inertia v3 calls this concept "optional". `lazy()` is the preferred method name in
     /// this crate; `optional()` is provided as a direct alias for ergonomics.
-    pub fn lazy<F, Fut>(self, key: impl Into<String>, f: F) -> Self
+    pub fn lazy<F, Fut, T>(self, key: impl Into<String>, f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Value> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
+        T: serde::Serialize,
     {
         self.prop(key, Prop::new(f).optional())
     }
@@ -61,29 +66,32 @@ impl InertiaResponse {
     ///
     /// Inertia v3 calls this "optional". This method is an alias for [`Self::lazy`]; both
     /// route through the same internal map and behave identically.
-    pub fn optional<F, Fut>(self, key: impl Into<String>, f: F) -> Self
+    pub fn optional<F, Fut, T>(self, key: impl Into<String>, f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Value> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
+        T: serde::Serialize,
     {
         self.lazy(key, f)
     }
 
     /// Attach a deferred prop.
-    pub fn deferred<F, Fut>(self, key: impl Into<String>, group: impl Into<String>, f: F) -> Self
+    pub fn deferred<F, Fut, T>(self, key: impl Into<String>, group: impl Into<String>, f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Value> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
+        T: serde::Serialize,
     {
         self.prop(key, Prop::new(f).group(group))
     }
 
     /// Attach a once prop: resolved one time, then remembered by the client
     /// across pages. Use [`Self::prop`] for a custom key or an expiry.
-    pub fn once<F, Fut>(self, key: impl Into<String>, f: F) -> Self
+    pub fn once<F, Fut, T>(self, key: impl Into<String>, f: F) -> Self
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Value> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
+        T: serde::Serialize,
     {
         self.prop(key, Prop::new(f).once())
     }
diff --git a/src/session/mod.rs b/src/session/mod.rs
index 0f62e17..559ae11 100644
--- a/src/session/mod.rs
+++ b/src/session/mod.rs
@@ -25,6 +25,10 @@ pub struct Flash {
     pub clear_history: bool,
     /// The next page must set `preserveFragment`.
     pub preserve_fragment: bool,
+    /// URL of the last Inertia page visit (see
+    /// [`crate::InertiaConfig::store_previous_url`]). Not one-shot: the layer
+    /// carries it from request to request.
+    pub previous_url: Option<String>,
 }
 
 impl Flash {
@@ -34,6 +38,7 @@ impl Flash {
             && self.bags.is_empty()
             && !self.clear_history
             && !self.preserve_fragment
+            && self.previous_url.is_none()
     }
 }
 
diff --git a/tests/v3_protocol.rs b/tests/v3_protocol.rs
index d2c2d63..a4e3e52 100644
--- a/tests/v3_protocol.rs
+++ b/tests/v3_protocol.rs
@@ -512,6 +512,88 @@ async fn precognition_answers_204_or_422() {
     assert_eq!(resp.headers().get("precognition-success").unwrap(), "true");
 }
 
+#[tokio::test]
+async fn back_uses_the_stored_previous_url_when_there_is_no_referer() {
+    #[derive(serde::Serialize)]
+    struct Plan {
+        name: &'static str,
+    }
+    let session = MockSession::default();
+    let app = Router::new()
+        .route(
+            "/users",
+            get(|i: Inertia| async move {
+                // A closure prop returns a typed value; no `json!` is necessary.
+                i.render("Users", json!({}))
+                    .once("plans", || async { vec![Plan { name: "Pro" }] })
+            })
+            .post(|i: Inertia| async move { i.back() }),
+        )
+        .layer(InertiaLayer::new(
+            config().session(session.clone()).store_previous_url(true),
+        ));
+
+    let p = page(
+        app.clone()
+            .oneshot(req_inertia("GET", "/users?page=2", "v1"))
+            .await
+            .unwrap(),
+    )
+    .await;
+    assert_eq!(p["props"]["plans"], json!([{"name": "Pro"}]));
+
+    // A partial reload and a prefetch do not change the stored URL.
+    let partial = with_headers(
+        "GET",
+        "/users?page=3",
+        &[("x-inertia-partial-component", "Users")],
+    );
+    app.clone().oneshot(partial).await.unwrap();
+    let prefetch = with_headers("GET", "/users?page=4", &[("purpose", "prefetch")]);
+    app.clone().oneshot(prefetch).await.unwrap();
+
+    let resp = app
+        .clone()
+        .oneshot(req_inertia("POST", "/users", "v1"))
+        .await
+        .unwrap();
+    assert_eq!(resp.headers().get("location").unwrap(), "/users?page=2");
+    // The URL is kept for later requests.
+    let resp = app
+        .oneshot(req_inertia("POST", "/users", "v1"))
+        .await
+        .unwrap();
+    assert_eq!(resp.headers().get("location").unwrap(), "/users?page=2");
+}
+
+#[tokio::test]
+async fn precognition_request_with_a_rejected_body_gets_a_precognition_response() {
+    #[derive(serde::Deserialize)]
+    struct NewUser {
+        #[allow(dead_code)]
+        name: String,
+    }
+    let app = Router::new()
+        .route(
+            "/users",
+            post(|_: Inertia, _: veer::InertiaForm<NewUser>| async { "created" }),
+        )
+        .layer(InertiaLayer::new(config()));
+    let r = http::Request::builder()
+        .method("POST")
+        .uri("/users")
+        .header("precognition", "true")
+        .header("content-type", "application/json")
+        .body(axum::body::Body::from("{}"))
+        .unwrap();
+    let resp = app.oneshot(r).await.unwrap();
+    assert_eq!(resp.status(), 422);
+    assert_eq!(resp.headers().get("precognition").unwrap(), "true");
+    let body: Value = serde_json::from_str(&body_string(resp).await).unwrap();
+    assert_eq!(body["errors"], json!({}));
+}
+
+#[cfg(feature = "devtools")]
 #[tokio::test]
 async fn devtools_records_entries_and_serves_the_read_api() {
     let app = Router::new()
@@ -553,6 +635,10 @@ async fn devtools_records_entries_and_serves_the_read_api() {
     assert_eq!(meta["component"], "Users/Show");
     assert_eq!(meta["url"], "http://localhost/users/1");
     assert_eq!(entry["route"]["uri"], "/users/{id}");
+    assert!(entry["renderSource"]["file"]
+        .as_str()
+        .unwrap()
+        .ends_with("v3_protocol.rs"));
     assert_eq!(entry["propValues"]["token"], "[REDACTED]");
     assert_eq!(entry["props"]["stats"]["deferGroup"], "side");
     assert_eq!(

From 6d966f4e379f7a7a927d04e9e0f92c2e0c5d7f05 Mon Sep 17 00:00:00 2001
From: Aditya Tripathi <aditya@climactic.co>
Date: Sat, 3 Oct 2026 22:56:49 +0000
Subject: [PATCH 3/5] docs: add a docs/ folder with one guide per topic; README
 becomes an overview

- docs/: getting started, props, forms and validation, redirects and history,
  sessions, Vite/SSR/assets, TypeScript bindings, CSRF, DevTools,
  architecture (with a protocol coverage table), and an upgrade guide for 0.2
- README: pitch, install, quick start, a short tour, and links to the guides
- example README: what the app shows
- fix two faults in the old README examples: `shared_props_fn` now gives a
  value that `InertiaConfig::shared` accepts, and route paths use the axum 0.8
  `{id}` syntax
---
 CHANGELOG.md                       |   2 +
 README.md                          | 611 +++--------------------------
 docs/README.md                     |  36 ++
 docs/architecture.md               |  97 +++++
 docs/csrf.md                       |  35 ++
 docs/devtools.md                   |  56 +++
 docs/forms-and-validation.md       | 130 ++++++
 docs/getting-started.md            | 118 ++++++
 docs/props.md                      | 170 ++++++++
 docs/redirects-and-history.md      |  57 +++
 docs/sessions.md                   |  72 ++++
 docs/typescript.md                 | 165 ++++++++
 docs/upgrading.md                  |  73 ++++
 docs/vite-ssr-assets.md            | 156 ++++++++
 examples/axum-react-todo/README.md |   8 +-
 src/shared.rs                      |  12 +-
 16 files changed, 1242 insertions(+), 556 deletions(-)
 create mode 100644 docs/README.md
 create mode 100644 docs/architecture.md
 create mode 100644 docs/csrf.md
 create mode 100644 docs/devtools.md
 create mode 100644 docs/forms-and-validation.md
 create mode 100644 docs/getting-started.md
 create mode 100644 docs/props.md
 create mode 100644 docs/redirects-and-history.md
 create mode 100644 docs/sessions.md
 create mode 100644 docs/typescript.md
 create mode 100644 docs/upgrading.md
 create mode 100644 docs/vite-ssr-assets.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d031bdb..2f66e6b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,8 @@ Brings the protocol surface up to Inertia client 3.8.0 / `inertia-laravel` 3.5.1
 - `Prop` at a nested dot path (`.prop("auth.permissions", …)`).
 - An empty `200` response to an Inertia request redirects back.
 - `HttpSsrClient::timeout` and `HttpSsrClient::health`.
+- A `docs/` folder with one guide per topic; the README is now an overview.
+- `shared_props_fn` returns a value that `InertiaConfig::shared` accepts.
 - `Vary: X-Inertia` on all responses that pass through `InertiaLayer`.
 - Plain handler responses (for example `axum::response::Redirect`) now get the
   version-mismatch 409, fragment redirect and flash carry-over too.
diff --git a/README.md b/README.md
index 6569213..4ecfb57 100644
--- a/README.md
+++ b/README.md
@@ -23,10 +23,9 @@ Build modern single-page apps in React, Vue, or Svelte — without writing a JSO
 - ✨ [What is Inertia, and why a Rust adapter](#-what-is-inertia-and-why-a-rust-adapter)
 - 📦 [Installation](#-installation)
 - 🚀 [Quick Start](#-quick-start)
-- 🍳 [Cookbook](#-cookbook)
+- 🧭 [A short tour](#-a-short-tour)
+- 📚 [Documentation](#-documentation)
 - 🎛️ [Feature Flags](#️-feature-flags)
-- 🏗️ [Architecture](#️-architecture)
-- ⚠️ [Caveats](#️-caveats)
 - 🧪 [Example App](#-example-app)
 - 🗺️ [Status & Roadmap](#️-status--roadmap)
 - 🙌 [Acknowledgements](#-acknowledgements)
@@ -55,20 +54,18 @@ Build modern single-page apps in React, Vue, or Svelte — without writing a JSO
 
 **Highlights**
 
-- 🦀 Pure Rust server-side implementation of Inertia v3
-- ⚡ First-class [axum](https://github.com/tokio-rs/axum) adapter (extractor + tower layer)
-- 🧩 Framework-agnostic protocol core — drop new adapters in beside the axum one
-- 📦 Partial reloads, deferred / optional / once props, merge / prepend / deep-merge props, infinite scroll, flash data, encrypted/clear history, big integers, Precognition
-- 🖥️ SSR via `@inertiajs/server` (Node or Bun) with graceful fallback
-- ⚙️ Vite dev + production manifest integration that mirrors Laravel's `@vite`
-- 📤 File uploads via typed `InertiaForm` + a streaming `MultipartStream` extractor
-- ✅ Validation flash for `validator` and `garde`, plus a cookie-based session store
-- 🪢 End-to-end TypeScript bindings: typed page props + Ziggy-style route helpers, generated from Rust
+- 🦀 The full Inertia v3 protocol (client 3.8), checked against the Laravel adapter and the real client
+- ⚡ First-class [axum](https://github.com/tokio-rs/axum) adapter: one extractor, one tower layer
+- 📦 Every prop type: partial reloads, deferred, optional, once, merge, infinite scroll, big integers
+- ✅ Forms the Inertia way: validation errors, flash data, error bags, Precognition live validation, file uploads
+- 🖥️ SSR through the official Node/Bun renderer, with fallback to client rendering
+- ⚙️ Vite dev server + production manifest integration, and embedded assets for a single-binary deploy
+- 🪢 End-to-end TypeScript: page props and route helpers generated from your Rust types
+- 🔒 CSRF protection, history encryption, and a recorder for the Inertia DevTools extension
+- 🧩 Framework-agnostic protocol core with pluggable sessions, root views and SSR clients
 
 ## 📦 Installation
 
-Add `veer` to your `Cargo.toml`:
-
 ```toml
 [dependencies]
 veer = "0.2"
@@ -80,7 +77,7 @@ Or with `cargo add`:
 cargo add veer
 ```
 
-The default feature set includes the axum adapter. See [Feature flags](#️-feature-flags) for everything else.
+The default feature set includes the axum adapter. See [Feature flags](#️-feature-flags) for everything else. Coming from 0.1? Read the [upgrade guide](docs/upgrading.md).
 
 ## 🚀 Quick Start
 
@@ -109,522 +106,73 @@ async fn main() {
 }
 ```
 
-The `Inertia` extractor reads the request. `render(component, props)` returns a builder. The layer handles the rest of the protocol — initial HTML on first load, JSON on XHR navigations, 409 for asset-version mismatches, 303 for POST-redirects, version checks, partial reloads.
+The `Inertia` extractor reads the request. `render(component, props)` returns a builder. The layer handles the rest of the protocol — initial HTML on first load, JSON on XHR navigations, 409 for asset-version mismatches, 303 for redirects, partial reloads. Continue with the [getting started guide](docs/getting-started.md).
 
-## 🍳 Cookbook
+## 🧭 A short tour
 
-<details>
-<summary><b>Validation + flash, Laravel-style</b></summary>
-
-```rust,ignore
-async fn users_create(
-    inertia: Inertia,
-    InertiaForm(body): InertiaForm<NewUser>,
-) -> impl IntoResponse {
-    if let Err(errors) = body.validate() {
-        return inertia.with_errors(errors).redirect("/users/new");
-    }
-    create_user(body).await;
-    inertia
-        .redirect("/users")
-        .with_flash("success", serde_json::json!("User created"))
-}
-```
-
-`InertiaForm` accepts `application/json`, `application/x-www-form-urlencoded`, and (with the `multipart` feature) `multipart/form-data`. The same handler works regardless of how the Inertia client serialized the request.
-
-On the frontend, `usePage().props.errors` and `usePage().flash` are auto-populated whenever a `SessionStore` is configured — no extra wiring. Flash data is the page object's top-level `flash`, so the client does not keep it in the history state. A request that sends `X-Inertia-Error-Bag` (the `errorBag` visit option) gets its errors nested under that bag name.
-
-For live validation ([Precognition](https://inertiajs.com/docs/v3/the-basics/forms#precognition)), answer the validation request before the action runs:
-
-```rust,ignore
-if let Some(precognition) = inertia.precognition() {
-    return precognition.respond(body.validate());   // 204, or 422 with the errors
-}
-```
-
-</details>
-
-<details>
-<summary><b>File uploads</b></summary>
-
-Enable the `multipart` feature and add `UploadedFile` fields to your typed struct:
-
-```rust,ignore
-use veer::{InertiaForm, UploadedFile};
-
-#[derive(serde::Deserialize)]
-struct CreateAvatar {
-    user_id: String,
-    avatar: UploadedFile,
-}
-
-async fn upload_avatar(
-    inertia: Inertia,
-    InertiaForm(form): InertiaForm<CreateAvatar>,
-) -> impl IntoResponse {
-    save_avatar(&form.user_id, &form.avatar.bytes, form.avatar.filename.as_deref()).await;
-    inertia.redirect("/profile").with_flash("success", json!("Avatar updated"))
-}
-```
-
-Inertia's `useForm` automatically switches to `multipart/form-data` when any field is a `File` or `Blob`. The same handler accepts JSON when no file is attached and multipart when one is — no separate route required.
-
-For large or unbounded uploads where in-memory buffering isn't acceptable, use `MultipartStream` instead:
-
-```rust,ignore
-use veer::MultipartStream;
-
-async fn huge_upload(MultipartStream(mut m): MultipartStream) -> impl IntoResponse {
-    while let Some(field) = m.next_field().await.unwrap() {
-        // pipe field.chunk().await into S3, disk, wherever — no buffering
-    }
-    // ...
-}
-```
-
-</details>
-
-<details>
-<summary><b>External redirect (OAuth, billing, etc.)</b></summary>
-
-```rust,ignore
-async fn oauth_start(inertia: Inertia) -> impl IntoResponse {
-    inertia.location("https://accounts.google.com/o/oauth2/v2/auth?...")
-}
-```
-
-An Inertia request gets 409 + `X-Inertia-Location`, which the client honors with a hard navigation. A plain browser request gets a normal 302.
-
-`inertia.redirect("/docs#install")` (a target with a URL fragment) becomes 409 + `X-Inertia-Redirect` for Inertia requests, because XHR drops the fragment of a followed redirect. To keep the fragment of the *original* request instead, call `.preserve_fragment()` on the redirect.
-
-</details>
-
-<details>
-<summary><b>Partial reloads, lazy, deferred, once, merge & scroll props</b></summary>
+**Load data only when the page needs it.** Closures run only when the response needs their value, and they return plain Rust types. → [Props](docs/props.md)
 
 ```rust,ignore
 inertia
-    .render("Users/Index", serde_json::json!({ "users": users, "notifications": notifications }))
-    .lazy("stats", || async { json!({ "hits": load_stats().await }) })
-    .deferred("expensive", "dashboard", || async { load_expensive().await })
-    .once("plans", || async { load_plans().await })
-    .prepend("notifications")
-    .match_on("notifications.id")
-    .prop("posts", Prop::scroll(move || async move {
-        let page = load_posts(page_no).await;
-        (json!({ "data": page.items }), ScrollMetadata::paged("page", page_no, page.has_more))
-    }))
-    .prop("permissions", Prop::try_new(|| async { load_permissions().await }).defer().rescue())
+    .render("Users/Index", UsersIndexProps { users })
+    .lazy("stats", || async { load_stats().await })                    // on request only
+    .deferred("activity", "default", || async { load_activity().await }) // after first render
+    .once("plans", || async { load_plans().await })                    // one time per client
+    .prop("feed", Prop::scroll(move || async move { load_feed(page).await })) // infinite scroll
 ```
 
-A closure returns any `Serialize` value (a struct, a `Vec`, or `json!`).
-
-| Method | Behavior |
-|---|---|
-| `lazy(key, closure)` (alias `optional`) | Closure only runs when the client requests this key via a partial reload |
-| `deferred(key, group, closure)` | First response advertises the key under `deferredProps[group]`; client then issues a follow-up reload that resolves it |
-| `once(key, closure)` | Resolved one time; the client remembers the value across pages (`onceProps`) and the closure is skipped while the client holds it |
-| `merge(path)` / `prepend(path)` / `deep_merge(path)` | The client appends / prepends / deep-merges the value into existing state instead of replacing it. Dot paths merge a nested array (`posts.data`) |
-| `match_on("posts.id")` | Field that identifies an item, so that a merge updates it in place (`matchPropsOn`) |
-| `prop(key, Prop)` | Attach a composable closure prop (see below) |
-| `encrypt_history()` / `clear_history()` | Set the history-state primitives. `InertiaConfig::encrypt_history(true)` turns encryption on for every page |
-| `preserve_big_integers(bool)` | Send integers outside the JavaScript safe range as `{"$bigint": "…"}`, which the client (3.8+) revives as `BigInt`. `InertiaConfig::preserve_big_integers(true)` sets the default |
-| `no_ssr()` | Skip SSR for this response only |
-
-`inertia.back()` redirects to the `Referer`. With `InertiaConfig::store_previous_url(true)` and a session store, veer also keeps the URL of the last Inertia page visit in the session, and `back()` uses it when the request has no `Referer`.
-
-`veer::Head` builds the prop for the client's `serverHead` option and escapes its values: `Head::new().title("Users").meta("description", "…")`, passed as the `head` prop.
-
-`inertia.with_errors(errors)` keeps all messages of a field. `props.errors` has the first message as a string by default; `InertiaConfig::with_all_errors(true)` sends all of them as an array.
-
-`Prop` composes the Inertia categories the way the protocol does. A dot path as key (`.prop("auth.permissions", …)`) puts the prop inside a nested object:
-
-| Constructor / modifier | Behavior |
-|---|---|
-| `Prop::new(closure)` | Resolved on full visits and on partial reloads that select it |
-| `Prop::try_new(closure)` | Closure returns `Result`. On `Err` the response is a 500, unless the prop has `.rescue()`: then the prop is left out and its key goes into `rescuedProps` (the `rescue` slot of `<Deferred>`) |
-| `Prop::scroll(closure)` | [Infinite scroll](https://inertiajs.com/docs/v3/data-props/infinite-scroll): closure returns `(value, ScrollMetadata)`; emits `scrollProps` and merges at `<key>.data` (`.wrapper("items")` changes the key). Honors the client's append/prepend intent and reset |
-| `.optional()` / `.defer()` / `.group("name")` | When the prop loads |
-| `.once()` / `.once_as("key")` / `.until(duration)` / `.fresh()` | Once behavior: custom key, expiry, forced refresh |
-| `.merge()` / `.prepend()` / `.deep_merge()` / `.append_at("data")` / `.prepend_at("data")` / `.match_on("id")` | Merge behavior, relative to the prop |
-
-Partial reloads follow the v3 rules: `only` and `except` take dot paths (`user.name`), `errors` and `Always<T>` values are always sent, and a prop named in `X-Inertia-Reset` is sent without its merge label. `InertiaConfig::share_once(key, closure)` shares a once prop with every page.
-
-</details>
-
-<details>
-<summary><b>Shared props (auth, app name, feature flags)</b></summary>
-
-```rust,ignore
-use veer::shared::shared_props_fn;
-
-let cfg = InertiaConfig::new()
-    .shared(shared_props_fn(|_req| async move {
-        serde_json::json!({
-            "auth": { "user": current_user().await },
-            "app": { "name": "Acme" },
-        })
-    }));
-```
-
-Shared props merge under per-response props (handler props win on key collision).
-
-</details>
-
-<details>
-<summary><b>SSR via @inertiajs/server (Node or Bun)</b></summary>
-
-Enable the `ssr` feature and point at the SSR service:
-
-```rust,ignore
-use veer::ssr::http::HttpSsrClient;
-
-let cfg = InertiaConfig::new()
-    .ssr(HttpSsrClient::new("http://127.0.0.1:13714/render"));
-```
-
-SSR failures fall back to client-side rendering by default, and the log has the error detail from the SSR server. Set `ssr_required(true)` for hard-fail behavior. `HttpSsrClient::timeout(duration)` changes the request timeout (default 5 seconds), and `client.health().await` tells you if the SSR server is up.
-
-For end-to-end SSR you'll usually combine this with `ViteRootView` (next entry) — `ViteRootView` inlines the SSR body verbatim and emits the `<script data-page>` mount the Inertia v3 client expects.
-
-</details>
-
-<details>
-<summary><b>Vite integration (dev + production)</b></summary>
-
-`ViteRootView` is a drop-in `RootView` that mirrors what Laravel's `@vite` + `@viteReactRefresh` Blade directives do. Two modes:
-
-**Dev** — cross-origin script tags pointing at the Vite dev server, plus (opt-in) the React refresh preamble required when the HTML shell is served off-origin:
-
-```rust,ignore
-use veer::ViteRootView;
-
-let cfg = InertiaConfig::new()
-    .root_view(
-        ViteRootView::dev()
-            .title("Acme")
-            .entry("frontend/app.tsx")
-            .dev_server("http://localhost:5173")
-            .react_refresh(true), // needed for @vitejs/plugin-react cross-origin
-    );
-```
-
-**Production** — `vite build` writes `dist/.vite/manifest.json`. `ViteRootView::production` walks it from the entry, emitting the entry script, its CSS, and `<link rel="modulepreload">` hints for transitively imported chunks:
-
-```rust,ignore
-use veer::{ViteManifest, ViteRootView};
-
-let manifest = ViteManifest::load("dist/.vite/manifest.json")?;
-let version  = manifest.hash(); // changes whenever any chunk hash changes
-
-let cfg = InertiaConfig::new()
-    .version(move || version.clone().into()) // bumps client asset cache on rebuild
-    .root_view(
-        ViteRootView::production()
-            .title("Acme")
-            .entry("frontend/app.tsx")
-            .manifest(manifest)
-            .asset_base("/build"),
-    );
-
-// Serve the built bundle next to the routes:
-// .nest_service("/build", tower_http::services::ServeDir::new("dist"))
-```
-
-Wiring `version` to `manifest.hash()` means any rebuild auto-invalidates clients via the Inertia 409 + force-reload protocol — no manual version bumps.
-
-For SSR in production, build the sidecar with `vite build --ssr frontend/ssr.tsx` and run the resulting bundle (`bun dist/ssr/ssr.js` or `node …`). Same `:13714/render` interface as dev.
-
-</details>
-
-<details>
-<summary><b>Inertia DevTools</b></summary>
-
-veer implements the [DevTools protocol](https://inertiajs.com/docs/v3/advanced/devtools-protocol), so the Inertia DevTools browser extension shows each request with its props, headers and route.
-
-Enable the `devtools` Cargo feature, then turn the recorder on in development:
+**Handle a form like a classic server app.** Validate, redirect, and the errors and the flash message show on the next page. → [Forms and validation](docs/forms-and-validation.md)
 
 ```rust,ignore
-let mut cfg = InertiaConfig::new();
-if cfg!(debug_assertions) {
-    cfg = cfg.devtools(veer::DevTools::new());
+async fn users_store(inertia: Inertia, InertiaForm(body): InertiaForm<NewUser>) -> impl IntoResponse {
+    if let Err(errors) = body.validate() {
+        return inertia.with_errors(errors).redirect("/users/new");
+    }
+    create_user(body).await;
+    inertia.redirect("/users").with_flash("success", json!("User created"))
 }
 ```
 
-Without the feature, the recorder is not compiled into the binary.
-
-`InertiaLayer` then records one entry for each request (in memory, the 100 newest for each browser tab), adds the `X-Inertia-Devtools-Id` headers, and serves `GET /_inertia/devtools/entries[/{id}]`. Sensitive keys (`password`, `token`, …) and headers (`Cookie`, `Authorization`, …) are redacted. The read API is open by default, so enable the recorder in development only; `DevTools::new().authorize(|request| …)` adds a guard. The entry has the source location of the `inertia.render` call; the other "open in editor" links (handler, component file) are not available.
-
-</details>
-
-<details>
-<summary><b>CSRF protection (Inertia/axios)</b></summary>
-
-The Inertia client reads an `XSRF-TOKEN` cookie and echoes it
-back in an `X-XSRF-TOKEN` header on every mutating request — no frontend code
-needed. `CsrfLayer` is the server side of that convention: it issues the cookie
-and verifies the header using a stateless, HMAC-signed double-submit token (no
-server-side session required).
-
-Enable the `csrf` feature and stack the layer next to `InertiaLayer`:
-
-```toml
-veer = { version = "0.1", features = ["csrf"] }
-```
-
-```rust,ignore
-use veer::{CsrfLayer, InertiaLayer};
-
-let app = router()
-    .with_state(state)
-    .layer(InertiaLayer::new(cfg))
-    .layer(CsrfLayer::new(secret));   // 32-byte secret; outermost layer
-```
-
-On a token mismatch the layer short-circuits with `419` (the Laravel/Inertia
-convention for an expired token) before the handler runs. Safe methods
-(GET/HEAD/OPTIONS/TRACE) are never checked. For endpoints that can't carry the
-header (third-party webhooks), exclude them:
+**Share data with every page.** → [Shared props](docs/props.md#shared-props)
 
 ```rust,ignore
-CsrfLayer::new(secret).exclude("/webhooks")
+let cfg = InertiaConfig::new().shared(shared_props_fn(|_req| async move {
+    json!({ "auth": { "user": current_user().await } })
+}));
 ```
 
-The cookie is JS-readable by design (so axios can echo it); it is `Secure` +
-`SameSite=Lax` by default — call `.secure(false)` for local HTTP dev.
-
-</details>
-
-<details>
-<summary><b>Embedded assets (single-binary deploy)</b></summary>
-
-For a single self-contained binary, embed the built frontend instead of serving
-it from disk. The manifest embeds via `include_str!`; `EmbeddedAssets` serves the
-bytes. Enable the `embed` feature:
-
-```toml
-veer = { version = "0.1", features = ["embed"] }
-rust-embed = "8"
-```
+**Get TypeScript types from your Rust structs.** → [TypeScript bindings](docs/typescript.md)
 
 ```rust,ignore
-use rust_embed::RustEmbed;
-use veer::{EmbeddedAssets, ViteManifest, ViteRootView};
-
-#[derive(RustEmbed)]
-#[folder = "dist/"]
-struct Assets;
-
-let manifest: ViteManifest = include_str!("../dist/.vite/manifest.json").parse()?;
-let version  = manifest.hash();
-
-let cfg = InertiaConfig::new()
-    .version(move || version.clone().into())
-    .root_view(ViteRootView::production().entry("frontend/app.tsx").manifest(manifest));
-
-let app = router()
-    .with_state(state)
-    .layer(InertiaLayer::new(cfg))
-    // Replaces `.nest_service("/build", ServeDir::new("dist"))`:
-    .nest_service("/build", EmbeddedAssets::new(|p| Assets::get(p).map(|f| f.data)));
-```
-
-`EmbeddedAssets` takes any `Fn(&str) -> Option<Cow<'static, [u8]>>`, so it works
-with `rust-embed`, `include_dir`, or a plain map — Veer depends on none of them.
-It sets `Content-Type` from the file extension and serves content-hashed assets
-with `Cache-Control: public, max-age=31536000, immutable`.
-
-</details>
-
-<details>
-<summary><b>End-to-end TypeScript bindings (Wayfinder-style)</b></summary>
-
-Enable the `ts` feature and the frontend gets an auto-generated `gen/` directory containing every page's props type, a discriminated `Pages` union, and one TypeScript module per controller with method-aware URL builders.
-
-```toml
-[dependencies]
-veer = { version = "0.2", features = ["ts"] }
-ts-rs = "12"
-```
-
-Annotate each prop struct and register it as a page:
-
-```rust,ignore
-use serde::Serialize;
-use ts_rs::TS;
-
 #[derive(Serialize, TS)]
 #[ts(export)]
-#[serde(rename_all = "camelCase")]
-pub struct UsersIndexProps {
-    pub users: Vec<User>,
-}
+pub struct UsersIndexProps { pub users: Vec<User> }
 veer::register_page!(UsersIndexProps, "Users/Index");
 ```
 
-Then build your router using `veer::Router` — same fluent API as `axum::Router`, but every route gets a name and method so the codegen knows about it:
-
-```rust,ignore
-use veer::Method::*;
-
-pub fn router() -> veer::Router<AppState> {
-    veer::Router::new()
-        .named_route(GET,    "users.index",   "/users",      users_index)
-        .named_route(GET,    "users.show",    "/users/:id",  users_show)
-        .named_route(GET,    "users.create",  "/users/new",  users_create)
-        .named_route(POST,   "users.store",   "/users",      users_store)
-        .named_route(PATCH,  "users.update",  "/users/:id",  users_update)
-        .named_route(DELETE, "users.destroy", "/users/:id",  users_destroy)
-}
-
-// In main():
-let app = router().build().with_state(state).layer(InertiaLayer::new(cfg));
-```
-
-`build()` returns a regular `axum::Router`, so `.with_state` / `.layer` / `.merge` / anything else just works. Same-path multi-method calls (GET + POST on `/users`) are merged into a single `MethodRouter` automatically — no panic on duplicate paths.
-
-Props that the handler attaches as closures (`once`, `deferred`, `lazy`, `Prop::scroll`, …) are not fields of the props struct. Describe them in a second struct and pass it as the third argument; the page's TS type is then `UsersIndexProps & UsersIndexClosureProps`:
-
-```rust,ignore
-#[derive(TS)]
-#[ts(export)]
-struct UsersIndexClosureProps {
-    plans: Vec<Plan>,        // once prop
-    #[ts(optional)]
-    stats: Option<Stats>,    // deferred prop: absent on the first render
-}
-veer::register_page!(UsersIndexProps, "Users/Index", UsersIndexClosureProps);
-```
-
-`ts-rs` mirrors `#[serde(rename_all)]` into the generated TypeScript, so the same struct drives both wire format and type. Route names follow the Laravel resource convention (`index`/`show`/`create`/`store`/`update`/`destroy`) so they don't collide with JavaScript reserved words.
-
-Add a tiny binary that builds the router (so the runtime route registry populates) and then emits the bundle. Drop this in `src/bin/gen-bindings.rs` inside your app crate — `cargo` auto-discovers it:
-
-```rust,ignore
-// src/bin/gen-bindings.rs
-fn main() {
-    let _ = my_app::router().build();   // populate registry
-    veer::bindings::generate_split("./frontend/gen").unwrap();
-}
-```
-
-Generate with:
-
-```bash
-cargo run --bin gen-bindings
-```
-
-The codegen has to run inside *your* app binary (not a standalone CLI), because the route registry is populated at runtime by `Router::build()` and the page registrations are link-time `inventory` submissions — both only exist in your compiled crate.
-
-On the frontend, import types and the per-controller action module:
-
-```tsx,ignore
-import { usePage, router, Link } from "@inertiajs/react";
+```tsx
 import { users, type UsersIndexProps } from "./gen";
 
-export default function Index() {
-  const { props } = usePage<UsersIndexProps>();
-  return (
-    <>
-      <Link href={users.create.url()}>New user</Link>
-      {props.users.map((u) => (
-        <Link key={u.id} href={users.show.url({ id: u.id })}>{u.name}</Link>
-      ))}
-    </>
-  );
-}
+<Link href={users.show.url({ id: user.id })}>{user.name}</Link>
 ```
 
-Each action is a callable with `.url` and `.form` helpers:
+## 📚 Documentation
 
-| Call | Returns |
+| Guide | What it covers |
 |---|---|
-| `users.show({id: 1})` | `{ url: "/users/1", method: "get" } as const` (visit definition) |
-| `users.show.url({id: 1})` | `"/users/1"` (just the path string) |
-| `users.show.form({id: 1})` | `{ action: "/users/1", method: "get" } as const` (props for `<form>`) |
-
-Generated layout:
-
-```text
-frontend/gen/
-  index.ts              protocol types, Pages, prop types, action namespace re-exports
-  actions/
-    users.ts            export const index, show, create, store, update, destroy
-    posts.ts            …
-    _root.ts            routes without a dotted prefix
-```
-
-`Always<T>` and `Merge<T>` collapse to `T` on the TypeScript side — the protocol's `mergeProps` / `deferredProps` arrays in the envelope carry the marker information instead.
-
-**Customize the output layout** with the `Split` builder — rename the `actions/` subdirectory, add a filename prefix/suffix, or flatten everything into the root:
-
-```rust,ignore
-veer::bindings::Split::new("./frontend/gen")
-    .actions_dir("controllers")    // -> frontend/gen/controllers/
-    .file_suffix("-controller")    // -> users-controller.ts, posts-controller.ts
-    .generate()?;
-```
-
-`actions_dir("")` writes the controller files directly alongside `index.ts`; `file_prefix` is similarly available.
-
-**Need a single bundled file** instead of the split tree? Use [`bindings::generate("./frontend/inertia.gen.ts")`](https://docs.rs/veer/latest/veer/bindings/fn.generate.html) — same content, one file, with the route tree exposed as a nested `routes.users.show(...)` namespace.
-
-**Auto-regenerate on commit** with [lefthook](https://github.com/evilmartians/lefthook). Add this to `lefthook.yml` at the repo root:
-
-```yaml
-pre-commit:
-  commands:
-    veer-bindings:
-      glob: "*.rs"
-      run: cargo run -q --bin gen-bindings
-      stage_fixed: true
-```
-
-`stage_fixed: true` re-adds the regenerated TS files to the commit so they never drift from the Rust source. Run `lefthook install` once per dev machine. Pair with a CI job that runs `cargo run --bin gen-bindings && git diff --exit-code` on PRs to fail-fast if someone bypasses the hook.
-
-</details>
-
-<details>
-<summary><b>Cookie-based flash session</b></summary>
-
-For apps without an existing session crate:
-
-```rust,ignore
-use veer::session::cookie::CookieSessionStore;
-
-let cfg = InertiaConfig::new()
-    .session(CookieSessionStore::new(env_secret()).secure(true));
-```
-
-HMAC-SHA256-signed, constant-time verification, one-shot semantics. For anything more elaborate, implement the `SessionStore` trait over your existing session crate (`axum-login`, redis, …) in ~30 lines.
-
-</details>
-
-<details>
-<summary><b>tower-sessions integration</b></summary>
-
-If the app already runs `tower-sessions`, enable the `tower-sessions` feature and plug `TowerSessionStore` into the config. Flash data round-trips through whatever backend (Redis, Postgres, in-memory, …) tower-sessions is configured with.
-
-```rust,ignore
-use time::Duration;
-use tower_sessions::{Expiry, MemoryStore, SessionManagerLayer};
-use veer::{session::tower::TowerSessionStore, InertiaConfig, InertiaLayer};
-
-let session_layer = SessionManagerLayer::new(MemoryStore::default())
-    .with_expiry(Expiry::OnInactivity(Duration::minutes(30)));
-
-let cfg = InertiaConfig::new().session(TowerSessionStore::new());
-
-let app = axum::Router::new()
-    // … routes …
-    .layer(InertiaLayer::new(cfg))
-    .layer(session_layer); // tower-sessions must wrap *outside* InertiaLayer
-```
-
-Flash is stored under a single key (`_veer_flash` by default; override with `TowerSessionStore::new().key("...")`).
-
-</details>
+| [Getting started](docs/getting-started.md) | Install, first page, how a request flows, the frontend entry point |
+| [Props](docs/props.md) | Partial reloads, lazy / deferred / once props, merging, infinite scroll, shared props, big integers |
+| [Forms and validation](docs/forms-and-validation.md) | `InertiaForm`, validation errors, error bags, flash data, Precognition, file uploads |
+| [Redirects and history](docs/redirects-and-history.md) | `redirect`, `back`, external redirects, URL fragments, history encryption |
+| [Sessions](docs/sessions.md) | The cookie store, `tower-sessions`, writing your own store |
+| [Vite, SSR and assets](docs/vite-ssr-assets.md) | `ViteRootView`, server-side rendering, embedded assets, `<head>` elements |
+| [TypeScript bindings](docs/typescript.md) | Typed page props and route helpers generated from Rust |
+| [CSRF protection](docs/csrf.md) | `CsrfLayer` and the `XSRF-TOKEN` convention |
+| [DevTools](docs/devtools.md) | The recorder for the Inertia DevTools browser extension |
+| [Architecture](docs/architecture.md) | Crate layout, protocol coverage, extension points |
+| [Upgrading from 0.1](docs/upgrading.md) | Every breaking change in 0.2 and what to do |
+
+API reference: [docs.rs/veer](https://docs.rs/veer). For the client side, use the [Inertia documentation](https://inertiajs.com/docs/v3).
 
 ## 🎛️ Feature Flags
 
@@ -633,75 +181,30 @@ Flash is stored under a single key (`_veer_flash` by default; override with `Tow
 | `axum` | **on** | Axum extractor + tower layer + `InertiaForm` body extractor |
 | `multipart` | off | File upload support (`UploadedFile`, `MultipartStream`) |
 | `ssr` | off | HTTP SSR client (`reqwest`) |
-| `cookie-session` | off | Signed-cookie one-shot flash store |
-| `tower-sessions` | off | Flash store backed by [`tower-sessions`](https://crates.io/crates/tower-sessions) |
+| `cookie-session` | off | Signed-cookie session store |
+| `tower-sessions` | off | Session store backed by [`tower-sessions`](https://crates.io/crates/tower-sessions) |
 | `validator` | off | `IntoErrorBag` impl for `validator::ValidationErrors` |
 | `garde` | off | `IntoErrorBag` impl for `garde::Report` |
-| `csrf` | off | Inertia/axios-compatible CSRF protection (`CsrfLayer`) |
+| `csrf` | off | CSRF protection (`CsrfLayer`) |
 | `embed` | off | Embedded-asset serving for single-binary deploys (`EmbeddedAssets`) |
 | `devtools` | off | Recorder + read API for the Inertia DevTools browser extension |
 | `ts` | off | End-to-end TypeScript bindings codegen (`ts-rs` + `inventory`) |
 
 Disabling a feature drops its transitive deps entirely.
 
-## 🏗️ Architecture
-
-```text
-┌────────────────────────────────────────────────────────┐
-│  axum Router                                           │
-│  ┌──────────────────────────────────────────────────┐  │
-│  │ InertiaLayer                                     │  │
-│  │   ├─ reads flash from SessionStore               │  │
-│  │   ├─ injects config into request extensions      │  │
-│  │   └─ on response: finalizes InertiaResponse,     │  │
-│  │      writes flash, rewrites 302→303 on non-GET   │  │
-│  └──────────────────────────────────────────────────┘  │
-│                       │                                │
-│                       ▼                                │
-│        ┌───────────────────────────┐                   │
-│        │  Inertia (extractor)      │                   │
-│        │  inertia.render(...) →    │                   │
-│        │  InertiaResponse builder  │                   │
-│        └───────────────────────────┘                   │
-└────────────────────────────────────────────────────────┘
-              │
-              ▼
-   ┌──────────────────────────────────────┐
-   │  Protocol core (framework-agnostic)  │
-   │  • RequestInfo / PageObject          │
-   │  • decide() state machine            │
-   │  • prop resolver (partial reloads,   │
-   │    deferred groups, merge keys)      │
-   │  • Pluggable: RootView, SessionStore,│
-   │    SsrClient, SharedProps            │
-   └──────────────────────────────────────┘
-```
-
-The protocol core has zero I/O and zero framework deps — pure data structures and decision functions, exhaustively unit-tested. Adapters for other Rust frameworks (actix, rocket, salvo) can sit beside the axum one without touching it.
-
-## ⚠️ Caveats
-
-> `Always<T>` and `Merge<T>` are detected at any depth and through any serialization path — typed `#[derive(Serialize)]` structs, `serde_json::json!`, hand-built `Value`s, mixed maps. A nested wrapper acts at its dot path: `Merge` adds the path (`posts.data`) to `mergeProps`, and `Always` keeps the value through partial-reload filters.
->
-> An empty `200` response to an Inertia request becomes a redirect back (`Referer`, or `/`), as in the Laravel adapter, because the client cannot render it.
-
 ## 🧪 Example App
 
-A complete end-to-end demo lives at [`examples/axum-react-todo/`](examples/axum-react-todo) — axum backend + React/Vite frontend, with validation, flash messages, and an in-memory todo store.
+A complete end-to-end demo lives at [`examples/axum-react-todo/`](examples/axum-react-todo) — axum backend + React/Vite frontend, in CSR and SSR mode. It has a todo list with validation, flash messages and Precognition, and a showcase page for once, deferred, rescued, scroll and big-integer props with generated TypeScript types.
 
 ```bash
-# Terminal 1 — Rust backend
-cargo run -p axum-react-todo
-
-# Terminal 2 — Vite dev server
 cd examples/axum-react-todo
-bun install
-bun dev
+just              # CSR mode — open http://localhost:5173
+SSR=1 just dev    # SSR mode — open http://localhost:3000
 ```
 
 ## 🗺️ Status & Roadmap
 
-`veer` is pre-1.0. The protocol surface follows Inertia v3 as of client 3.8 / `inertia-laravel` 3.5 (partial reloads, deferred / optional / once props, merge props, infinite scroll, flash data, history encryption, fragment redirects, big integers, Precognition, SSR, asset versioning, validation errors, DevTools). Planned for follow-ups:
+`veer` is pre-1.0. The protocol surface follows Inertia v3 as of client 3.8 / `inertia-laravel` 3.5; the [coverage table](docs/architecture.md#protocol-coverage) has the detail. Planned:
 
 - Adapters for `actix-web` and `rocket`
 - Typed route-param inference (today: `string | number`; goal: read each handler's `Path` extractor and emit the matching TS type)
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..b85086c
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,36 @@
+# Veer documentation
+
+Veer is the server side of the [Inertia.js v3 protocol](https://inertiajs.com/docs/v3/core-concepts/the-protocol) for Rust. These guides cover the Rust side. For the client side (React, Vue, Svelte), use the [Inertia documentation](https://inertiajs.com/docs/v3).
+
+## Start here
+
+| Guide | What it covers |
+|---|---|
+| [Getting started](getting-started.md) | Install, first page, how a request flows, the frontend entry point |
+| [Upgrading from 0.1](upgrading.md) | Every breaking change in 0.2 and what to do |
+
+## Building pages
+
+| Guide | What it covers |
+|---|---|
+| [Props](props.md) | Partial reloads, lazy / deferred / once props, merging, infinite scroll, shared props, big integers |
+| [Forms and validation](forms-and-validation.md) | `InertiaForm`, validation errors, error bags, flash data, Precognition, file uploads |
+| [Redirects and history](redirects-and-history.md) | `redirect`, `back`, external redirects, URL fragments, history encryption |
+| [Sessions](sessions.md) | The cookie store, `tower-sessions`, writing your own store |
+
+## Frontend integration
+
+| Guide | What it covers |
+|---|---|
+| [Vite, SSR and assets](vite-ssr-assets.md) | `ViteRootView`, server-side rendering, embedded assets, `<head>` elements |
+| [TypeScript bindings](typescript.md) | Typed page props and route helpers generated from Rust |
+
+## Operations
+
+| Guide | What it covers |
+|---|---|
+| [CSRF protection](csrf.md) | `CsrfLayer` and the `XSRF-TOKEN` convention |
+| [DevTools](devtools.md) | The recorder for the Inertia DevTools browser extension |
+| [Architecture](architecture.md) | Crate layout, feature flags, protocol coverage, extension points |
+
+API reference: [docs.rs/veer](https://docs.rs/veer). Working example: [`examples/axum-react-todo`](../examples/axum-react-todo).
diff --git a/docs/architecture.md b/docs/architecture.md
new file mode 100644
index 0000000..d00c59a
--- /dev/null
+++ b/docs/architecture.md
@@ -0,0 +1,97 @@
+# Architecture
+
+## Layers
+
+```text
+┌────────────────────────────────────────────────────────┐
+│  axum Router                                           │
+│  ┌──────────────────────────────────────────────────┐  │
+│  │ InertiaLayer                                     │  │
+│  │   ├─ reads session data (errors, flash)          │  │
+│  │   ├─ puts the config into request extensions     │  │
+│  │   └─ on response: finishes the InertiaResponse,  │  │
+│  │      writes session data, applies protocol rules │  │
+│  └──────────────────────────────────────────────────┘  │
+│                       │                                │
+│                       ▼                                │
+│        ┌───────────────────────────┐                   │
+│        │  Inertia (extractor)      │                   │
+│        │  inertia.render(...) →    │                   │
+│        │  InertiaResponse builder  │                   │
+│        └───────────────────────────┘                   │
+└────────────────────────────────────────────────────────┘
+              │
+              ▼
+   ┌──────────────────────────────────────┐
+   │  Protocol core (no framework)        │
+   │  • RequestInfo / PageObject          │
+   │  • decide(): which response shape    │
+   │  • prop resolver                     │
+   │  • Traits: RootView, SessionStore,   │
+   │    SsrClient, SharedProps            │
+   └──────────────────────────────────────┘
+```
+
+A handler returns an `InertiaResponse`, which is only a description: the component, the props, the closures. The layer finishes it after the handler returns, because only the layer has the request headers, the session data and the config.
+
+The protocol core has no I/O and no framework types. `protocol::decide` is a pure function from the request to a response shape, and `props::resolver::resolve` is a function from the props and the request headers to the final props and metadata. Both have unit tests. An adapter for another framework can use them without a change.
+
+## Extension points
+
+| Trait | Purpose | Built in |
+|---|---|---|
+| `RootView` | The HTML shell of the first page load | `MinimalRootView`, `ViteRootView`, `ClosureRootView` |
+| `SessionStore` | Errors and flash data between requests | `CookieSessionStore`, `TowerSessionStore` |
+| `SsrClient` | Server-side rendering | `HttpSsrClient` |
+| `SharedProps` | Props for every page | `shared_props_fn` |
+| `IntoErrorBag` | Validation errors from any library | `validator`, `garde`, maps and pairs |
+
+## Feature flags
+
+| Flag | Default | Effect |
+|------|---------|--------|
+| `axum` | **on** | Axum extractor, tower layer, `InertiaForm`, `Router`, Precognition |
+| `multipart` | off | File uploads (`UploadedFile`, `MultipartStream`) |
+| `ssr` | off | HTTP SSR client (`reqwest`) |
+| `cookie-session` | off | Signed-cookie session store |
+| `tower-sessions` | off | Session store on [`tower-sessions`](https://crates.io/crates/tower-sessions) |
+| `validator` | off | `IntoErrorBag` for `validator::ValidationErrors` |
+| `garde` | off | `IntoErrorBag` for `garde::Report` |
+| `csrf` | off | `CsrfLayer` and `CsrfTokens` |
+| `embed` | off | `EmbeddedAssets` for a single-binary deploy |
+| `devtools` | off | Recorder for the Inertia DevTools extension |
+| `ts` | off | TypeScript bindings (`ts-rs`, `inventory`) |
+
+A feature that is off brings in none of its dependencies.
+
+## Protocol coverage
+
+Veer follows the Inertia v3 protocol as of client 3.8 and `inertia-laravel` 3.5.
+
+| Area | Status |
+|---|---|
+| HTML and JSON page responses, `Vary` | ✅ |
+| Asset versioning (`409`, `X-Inertia-Version`) | ✅ |
+| Redirects (`303`, external `409`, fragment `409`) | ✅ |
+| Partial reloads (`only`, `except`, dot paths, reset) | ✅ |
+| Optional, deferred, once, always props | ✅ |
+| Rescued deferred props | ✅ |
+| Merge, prepend, deep merge, match-on | ✅ |
+| Infinite scroll | ✅ |
+| Shared props, `sharedProps` | ✅ |
+| Validation errors, error bags | ✅ |
+| Flash data | ✅ |
+| History encryption, clear history, preserve fragment | ✅ |
+| Big integers | ✅ |
+| Precognition | ✅ |
+| Server-side rendering | ✅ |
+| DevTools protocol | ✅ (no handler or component source links) |
+
+The wire formats are checked against the protocol document, the `inertia-laravel` source, and the client source, and the example app is checked in a browser with the React client. Vue and Svelte use the same client core.
+
+## Differences from the Laravel adapter
+
+- **`Prop::try_new` needs `.rescue()`** to rescue a failure; without it an `Err` gives a `500`. This is the same rule, in Rust terms.
+- **`back()`** uses the `Referer` header first. Laravel uses the session's previous URL first.
+- **Sessions hold only veer's data** (errors, flash, previous URL). Veer is not a general session library.
+- **The once-prop expiry** is set with a `Duration` (`.until(...)`).
diff --git a/docs/csrf.md b/docs/csrf.md
new file mode 100644
index 0000000..baee29b
--- /dev/null
+++ b/docs/csrf.md
@@ -0,0 +1,35 @@
+# CSRF protection
+
+The Inertia client reads an `XSRF-TOKEN` cookie and sends its value in an `X-XSRF-TOKEN` header on each request that changes data. `CsrfLayer` is the server side of that convention. It needs no session: the token is a signed double-submit token (HMAC-SHA256).
+
+Enable the `csrf` feature and add the layer outside `InertiaLayer`:
+
+```toml
+veer = { version = "0.2", features = ["csrf"] }
+```
+
+```rust,ignore
+use veer::{CsrfLayer, InertiaLayer};
+
+let app = router()
+    .with_state(state)
+    .layer(InertiaLayer::new(cfg))
+    .layer(CsrfLayer::new(secret));   // at least 32 bytes; the outermost layer
+```
+
+## Behavior
+
+- `GET`, `HEAD`, `OPTIONS` and `TRACE` are not checked. The layer issues the cookie.
+- Other methods need a header that agrees with the cookie. If not, the layer answers `419` and the handler does not run. `419` is the status that the Inertia client knows for an expired token.
+- The cookie is readable from JavaScript, because the client must copy it into the header. It is `Secure` and `SameSite=Lax`.
+
+## Options
+
+| Method | Effect |
+|---|---|
+| `.secure(false)` | No `Secure` flag; for local HTTP development |
+| `.same_site(SameSite::Strict)` | Change the `SameSite` attribute |
+| `.cookie_name("…")` / `.header_name("…")` | Change the names; set the same names on the client |
+| `.exclude("/webhooks")` | No check for this path prefix (for requests that cannot send the header) |
+
+`CsrfTokens` is the core without a framework (`generate`, `verify`), for use outside axum.
diff --git a/docs/devtools.md b/docs/devtools.md
new file mode 100644
index 0000000..427a205
--- /dev/null
+++ b/docs/devtools.md
@@ -0,0 +1,56 @@
+# DevTools
+
+[Inertia DevTools](https://inertiajs.com/docs/v3/advanced/devtools) is a browser extension that shows each Inertia request: the props and their categories, the headers, the route. Veer implements the server side of its [protocol](https://inertiajs.com/docs/v3/advanced/devtools-protocol).
+
+## Setup
+
+1. Enable the `devtools` Cargo feature. Without it, the recorder is not compiled into your binary.
+
+   ```toml
+   veer = { version = "0.2", features = ["devtools"] }
+   ```
+
+2. Turn the recorder on, in development only:
+
+   ```rust,ignore
+   let mut cfg = InertiaConfig::new();
+   if cfg!(debug_assertions) {
+       cfg = cfg.devtools(veer::DevTools::new());
+   }
+   ```
+
+3. Install the extension ([Chrome](https://chromewebstore.google.com/detail/inertiajs-devtools/cbaffpghpcbmgbnlpamegieokkpdlnih), [Firefox](https://addons.mozilla.org/en-US/firefox/addon/inertia-js-devtools/)), and use client version 3.6 or later. Open the browser developer tools and select the "Inertia" panel.
+
+Run the Vite dev server for the full feature set: the client exposes its visit data to the extension only in development mode.
+
+## What the recorder does
+
+For each request that goes through `InertiaLayer`, the recorder:
+
+- makes an entry with the method, URL, status, request type, timing, headers, bodies, and for a page: the props and their categories;
+- adds `X-Inertia-Devtools-Id` and `X-Inertia-Devtools-Parent-Out` to the response;
+- on the first page load, adds a `<script data-inertia-devtools-id>` tag before `</body>`.
+
+The extension then reads the entry from `GET /_inertia/devtools/entries/{id}`. `GET /_inertia/devtools/entries` lists all entries, newest first.
+
+Entries are in memory: the 100 newest for each browser tab (`DevTools::new().limit(n)` changes this). A restart clears them.
+
+## Security
+
+The entries contain the props and bodies of every user. So:
+
+- **Use the recorder in development only.** The read API is open by default.
+- If other people can reach your development server, add a guard:
+
+  ```rust,ignore
+  DevTools::new().authorize(|request| is_developer(request))
+  ```
+
+  The read API then answers `403` when the guard returns `false`.
+- Sensitive values are replaced with `[REDACTED]`: the headers `Authorization`, `Proxy-Authorization`, `Cookie`, `Set-Cookie`, `X-CSRF-Token`, `X-XSRF-Token`, and the keys `password`, `password_confirmation`, `current_password`, `token`, `_token`, `access_token`, `refresh_token`, `secret`, `client_secret`, `api_key` in bodies, props and URL query strings.
+
+## Limits
+
+- The entry has the file and line of the `inertia.render` call. The other "open in editor" links (handler, component file) and the route name are not available.
+- A request body is recorded only when it is JSON, comes from an Inertia request, and is smaller than 256 KB.
+- This implementation follows the protocol document and the extension source. It has automated tests against both, but no test with the installed extension yet. Please report a problem if the panel shows something wrong.
diff --git a/docs/forms-and-validation.md b/docs/forms-and-validation.md
new file mode 100644
index 0000000..b917c0e
--- /dev/null
+++ b/docs/forms-and-validation.md
@@ -0,0 +1,130 @@
+# Forms and validation
+
+Inertia handles a form submit like a classic server-rendered app: the handler validates, then redirects. Errors and messages travel to the next page through the session. You need a session store for this; see [Sessions](sessions.md).
+
+## A form handler
+
+```rust,ignore
+use veer::{Inertia, InertiaForm};
+use validator::Validate;
+
+#[derive(serde::Deserialize, Validate)]
+struct NewUser {
+    #[validate(length(min = 1, message = "name is required"))]
+    name: String,
+    #[validate(email(message = "email is not valid"))]
+    email: String,
+}
+
+async fn users_store(
+    inertia: Inertia,
+    InertiaForm(body): InertiaForm<NewUser>,
+) -> impl IntoResponse {
+    if let Err(errors) = body.validate() {
+        return inertia.with_errors(errors).redirect("/users/new");
+    }
+    create_user(body).await;
+    inertia.redirect("/users").with_flash("success", json!("User created"))
+}
+```
+
+`InertiaForm<T>` reads `application/json`, `application/x-www-form-urlencoded`, and, with the `multipart` feature, `multipart/form-data`. One handler works for all three.
+
+## Validation errors
+
+`with_errors` takes anything that implements `IntoErrorBag`:
+
+- `validator::ValidationErrors` (feature `validator`)
+- `garde::Report` (feature `garde`)
+- `HashMap<String, String>`, `Vec<(String, String)>`, `Vec<(&str, &str)>`
+
+On the next page, the errors are in `props.errors`, which is always present (`{}` when there are none). On the frontend, `useForm` puts them in `form.errors`.
+
+- **All messages.** By default each field has its first message, as a string. With `InertiaConfig::with_all_errors(true)`, each field has an array of all messages.
+- **Error bags.** When a request names a bag (the `errorBag` visit option, sent as `X-Inertia-Error-Bag`), veer nests the errors under that name: `{ "createUser": { "email": "…" } }`. This keeps the errors of two forms on one page apart.
+- **Errors on a render.** `inertia.render(…).with_errors(errors)` puts the errors on that page, with no redirect.
+
+## Flash data
+
+```rust,ignore
+inertia.redirect("/users").with_flash("success", json!("User created"))
+```
+
+Flash data is one-shot. It is the top-level `flash` field of the page object (`usePage().flash` on the frontend), and the client does not keep it in the browser history. It survives a chain of redirects, and responses that are not pages do not use it up.
+
+`with_flash` on a render puts the data on that page.
+
+## Precognition (live validation)
+
+[Precognition](https://inertiajs.com/docs/v3/the-basics/forms#precognition) validates a field while the user fills in the form, with the validation rules of the server. The client sends the normal request with a `Precognition: true` header. Answer it before the action runs:
+
+```rust,ignore
+async fn users_store(
+    inertia: Inertia,
+    InertiaForm(body): InertiaForm<NewUser>,
+) -> axum::response::Response {
+    if let Some(precognition) = inertia.precognition() {
+        return precognition.respond(body.validate());
+    }
+    if let Err(errors) = body.validate() {
+        return inertia.with_errors(errors).redirect("/users/new").into_response();
+    }
+    create_user(body).await;
+    inertia.redirect("/users").into_response()
+}
+```
+
+`respond` returns `204` when the requested fields are valid, and `422` with the errors when they are not. It reports only the fields that the client named in `Precognition-Validate-Only`.
+
+On the frontend, give `useForm` the method and URL:
+
+```tsx
+const form = useForm("post", "/users", { name: "", email: "" });
+
+<input
+  value={form.data.email}
+  onChange={(e) => form.setData("email", e.target.value)}
+  onBlur={() => form.validate("email")}
+/>
+{form.errors.email}
+```
+
+The client validates a field only after its value changes.
+
+## File uploads
+
+Enable the `multipart` feature and add `UploadedFile` fields:
+
+```rust,ignore
+use veer::{InertiaForm, UploadedFile};
+
+#[derive(serde::Deserialize)]
+struct CreateAvatar {
+    user_id: String,
+    avatar: UploadedFile,
+}
+
+async fn upload_avatar(
+    inertia: Inertia,
+    InertiaForm(form): InertiaForm<CreateAvatar>,
+) -> impl IntoResponse {
+    save_avatar(&form.user_id, &form.avatar.bytes, form.avatar.filename.as_deref()).await;
+    inertia.redirect("/profile").with_flash("success", json!("Avatar updated"))
+}
+```
+
+The client's `useForm` changes to `multipart/form-data` when a field is a `File`. `UploadedFile` holds the file in memory. For large uploads, read the stream:
+
+```rust,ignore
+use veer::MultipartStream;
+
+async fn huge_upload(MultipartStream(mut m): MultipartStream) -> impl IntoResponse {
+    while let Some(field) = m.next_field().await.unwrap() {
+        // Write each chunk to disk or object storage.
+    }
+}
+```
+
+## CSRF
+
+Form submits need CSRF protection. See [CSRF protection](csrf.md).
diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 0000000..20e799f
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,118 @@
+# Getting started
+
+## Install
+
+```toml
+[dependencies]
+veer = "0.2"
+axum = "0.8"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+```
+
+The default feature set has the axum adapter. Other features are opt-in; see the [feature flag table](architecture.md#feature-flags).
+
+Minimum supported Rust version: **1.88**.
+
+## A first page
+
+```rust,no_run
+use axum::{routing::get, Router};
+use veer::{Inertia, InertiaConfig, InertiaLayer, MinimalRootView};
+
+#[tokio::main]
+async fn main() {
+    let cfg = InertiaConfig::new()
+        .version(|| "1".into())
+        .root_view(
+            MinimalRootView::new()
+                .title("Acme")
+                .vite_entry("/src/main.tsx"),
+        );
+
+    let app = Router::new()
+        .route("/", get(|inertia: Inertia| async move {
+            inertia.render("Home", serde_json::json!({ "msg": "hello" }))
+        }))
+        .layer(InertiaLayer::new(cfg));
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+```
+
+There are three parts:
+
+- **`InertiaConfig`** is built once at startup. It holds the asset version, the root view (the HTML shell), and optional parts: a session store, an SSR client, shared props.
+- **`Inertia`** is an axum extractor. `inertia.render(component, props)` returns an `InertiaResponse` builder. `props` is any `Serialize` value: a struct or `serde_json::json!`.
+- **`InertiaLayer`** does the protocol work after your handler returns.
+
+## What the layer does
+
+| Request | Response |
+|---|---|
+| First page load (no `X-Inertia` header) | The HTML shell, with the page object in a `<script data-page="app" type="application/json">` tag |
+| Inertia visit (`X-Inertia: true`) | The page object as JSON, with `X-Inertia: true` |
+| Inertia `GET` with an old asset version | `409` + `X-Inertia-Location` + `X-Inertia-Version`; the client reloads |
+| `inertia.redirect(...)` | `303 See Other` |
+| A plain `302` from a `POST` / `PUT` / `PATCH` / `DELETE` handler | Changed to `303` |
+
+Every response gets `Vary: X-Inertia`, because HTML and JSON share a URL.
+
+## Typed props
+
+Use a struct in place of `json!`:
+
+```rust,ignore
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+struct UsersIndexProps {
+    users: Vec<User>,
+    can_create: bool,
+}
+
+async fn users_index(inertia: Inertia) -> impl IntoResponse {
+    inertia.render("Users/Index", UsersIndexProps { users: load_users().await, can_create: true })
+}
+```
+
+The same struct can generate the TypeScript type of the page; see [TypeScript bindings](typescript.md).
+
+## The frontend entry point
+
+Veer needs nothing special on the client. Use the official adapter:
+
+```tsx
+// src/main.tsx
+import { createInertiaApp } from "@inertiajs/react";
+import { createRoot } from "react-dom/client";
+
+createInertiaApp({
+  resolve: (name) => {
+    const pages = import.meta.glob("./pages/**/*.tsx", { eager: true });
+    return pages[`./pages/${name}.tsx`];
+  },
+  setup({ el, App, props }) {
+    createRoot(el).render(<App {...props} />);
+  },
+});
+```
+
+`MinimalRootView` is sufficient to start. For a real app, use `ViteRootView`, which handles the Vite dev server and the production manifest; see [Vite, SSR and assets](vite-ssr-assets.md).
+
+## Asset versioning
+
+`InertiaConfig::version` returns a string that changes when your assets change. When a client sends an old version, veer answers `409` and the client does a full reload. With Vite, use the manifest hash:
+
+```rust,ignore
+let manifest = ViteManifest::load("dist/.vite/manifest.json")?;
+let version = manifest.hash();
+let cfg = InertiaConfig::new().version(move || version.clone().into());
+```
+
+## Next steps
+
+- [Props](props.md): load data only when the page needs it.
+- [Forms and validation](forms-and-validation.md): handle a form submit with errors and a flash message.
+- [`examples/axum-react-todo`](../examples/axum-react-todo): a complete app.
diff --git a/docs/props.md b/docs/props.md
new file mode 100644
index 0000000..611a3d9
--- /dev/null
+++ b/docs/props.md
@@ -0,0 +1,170 @@
+# Props
+
+Props are the data of a page. Veer follows the [prop evaluation model](https://inertiajs.com/docs/v3/core-concepts/the-protocol#prop-evaluation-model) of the Inertia protocol: each prop has a category, and the category decides when the server resolves it and what metadata the page object carries.
+
+## Overview
+
+```rust,ignore
+inertia
+    .render("Users/Index", UsersIndexProps { users, notifications })
+    .lazy("stats", || async { load_stats().await })
+    .deferred("activity", "default", || async { load_activity().await })
+    .once("plans", || async { load_plans().await })
+    .prepend("notifications")
+    .match_on("notifications.id")
+```
+
+Plain props (the struct) are always resolved. The builder methods attach **closure props**: the closure runs only when the response needs the value. A closure returns any `Serialize` value.
+
+| Method | When the closure runs |
+|---|---|
+| `lazy(key, f)` / `optional(key, f)` | Only when a partial reload asks for the key |
+| `deferred(key, group, f)` | Not on the first response; the client asks for it after the first render |
+| `once(key, f)` | One time; the client remembers the value across pages |
+| `prop(key, Prop)` | As the `Prop` says (see [Composing with `Prop`](#composing-with-prop)) |
+
+## Partial reloads
+
+The client can ask for a subset of the props of the page it is on (`router.reload({ only: ['users'] })`). Veer applies the rules of the protocol:
+
+- `only` and `except` take dot paths: `only: ['user.name']` returns only that nested value.
+- With only `except`, all other props are returned.
+- `errors` is always returned.
+- A value wrapped in [`Always`](#always-and-merge-wrappers) is always returned.
+- If the component of the request is not the component of the response, the reload is a full visit.
+
+## Deferred props
+
+```rust,ignore
+.deferred("activity", "default", || async { load_activity().await })
+.deferred("related", "sidebar", || async { load_related().await })
+```
+
+The first response lists the keys under `deferredProps`, by group. The client then makes one request for each group. On the frontend, use `<Deferred data="activity" fallback={…}>`.
+
+### Rescued props
+
+A deferred prop that can fail should not fail the page. Use `Prop::try_new` with `.rescue()`:
+
+```rust,ignore
+.prop("permissions", Prop::try_new(|| async { load_permissions().await }).defer().rescue())
+```
+
+On `Err`, veer logs the error, leaves the prop out, and lists its key in `rescuedProps`. The client shows the `rescue` slot of `<Deferred>`. Without `.rescue()`, an `Err` gives a `500`.
+
+## Once props
+
+```rust,ignore
+.once("plans", || async { load_plans().await })
+```
+
+The value is resolved one time. The client remembers it and sends its key in `X-Inertia-Except-Once-Props` on later requests, and veer then skips the closure. To share a once prop with every page, set it on the config:
+
+```rust,ignore
+let cfg = InertiaConfig::new()
+    .share_once("countries", |_req| async { load_countries().await });
+```
+
+For a custom key, an expiry, or a forced refresh, use `Prop`: `.once_as("key")`, `.until(duration)`, `.fresh()`.
+
+## Merging props
+
+By default, a partial reload replaces a prop. A merge label tells the client to combine the new value with the one it has.
+
+```rust,ignore
+inertia
+    .render("Feed", json!({ "posts": posts, "notifications": notifications, "chat": chat }))
+    .merge("posts")                 // append
+    .prepend("notifications")       // prepend
+    .deep_merge("chat")             // merge objects recursively
+    .match_on("posts.id")           // update an item in place when the id is the same
+```
+
+A dot path merges a nested array: `.merge("posts.data")`.
+
+When the client sends `X-Inertia-Reset` for a prop (`router.reload({ reset: ['posts'] })`), veer sends the prop without its merge label, so the client replaces the value.
+
+## Infinite scroll
+
+```rust,ignore
+.prop("posts", Prop::scroll(move || async move {
+    let page = load_posts(page_no).await;
+    (
+        PostsPage { data: page.items },
+        ScrollMetadata::paged("page", page_no, page.has_more),
+    )
+}))
+```
+
+The closure returns the page value and its cursor. The value holds the items under the wrapper key (`data` by default; change it with `.wrapper("items")`). Veer emits `scrollProps` and a merge label for `<key>.data`, and follows the client's append / prepend intent and reset. On the frontend, use `<InfiniteScroll data="posts">`.
+
+`ScrollMetadata::paged(name, current, has_more)` is for numbered pages. For cursor pagination, build it by hand: `ScrollMetadata::new("cursor").current(cur).next(next).previous(prev)`.
+
+## Composing with `Prop`
+
+`Prop` is the general form. The categories compose, as they do in the protocol: a prop can be deferred and merged, or once and deferred.
+
+| Constructor | Behavior |
+|---|---|
+| `Prop::new(f)` | Resolved on full visits, and on partial reloads that select it |
+| `Prop::try_new(f)` | `f` returns `Result`. `Err` gives a `500`, or a rescued prop with `.rescue()` |
+| `Prop::scroll(f)` | An infinite-scroll prop; `f` returns `(value, ScrollMetadata)` |
+
+| Modifier | Behavior |
+|---|---|
+| `.optional()` | Resolve only on a partial reload that selects the prop |
+| `.defer()` / `.group("name")` | Defer, in the `default` group or a named group |
+| `.once()` / `.once_as("key")` / `.until(duration)` / `.fresh()` | Once behavior: custom key, expiry, forced refresh |
+| `.merge()` / `.prepend()` / `.deep_merge()` | Merge behavior for the prop itself |
+| `.append_at("data")` / `.prepend_at("data")` | Merge behavior for a nested path |
+| `.match_on("id")` | Field that identifies an item, relative to the prop |
+| `.rescue()` | Rescue an `Err` from `try_new` |
+| `.wrapper("items")` | Wrapper key of a scroll prop |
+
+A dot path as key puts the prop inside a nested object: `.prop("auth.permissions", …)`.
+
+## Shared props
+
+Shared props are sent with every page: the signed-in user, the app name, feature flags.
+
+```rust,ignore
+use veer::shared::shared_props_fn;
+
+let cfg = InertiaConfig::new()
+    .shared(shared_props_fn(|_req| async move {
+        serde_json::json!({
+            "auth": { "user": current_user().await },
+            "app": { "name": "Acme" },
+        })
+    }));
+```
+
+A page prop with the same key wins. The page object lists the shared keys in `sharedProps`, which the client uses for instant visits. For request-specific data, implement the `SharedProps` trait; its method gets the `RequestInfo`.
+
+## `Always` and `Merge` wrappers
+
+Two wrapper types mark a value inside your props struct:
+
+```rust,ignore
+#[derive(serde::Serialize)]
+struct DashboardProps {
+    csrf_ready: Always<bool>,          // always sent, also on partial reloads
+    notifications: Merge<Vec<Notice>>, // merged by the client
+}
+```
+
+They work at any depth and through any serialization path (structs, `json!`, hand-built values). A nested wrapper acts at its dot path. On the TypeScript side they collapse to the inner type.
+
+## Big integers
+
+JavaScript numbers lose precision above 2^53. With big-integer support on, veer sends each integer outside the safe range as `{"$bigint": "…"}`, and the client (3.8.0 or later) turns it into a `BigInt`.
+
+```rust,ignore
+// For one response:
+inertia.render("Orders/Show", props).preserve_big_integers(true)
+
+// For every response:
+let cfg = InertiaConfig::new().preserve_big_integers(true);
+```
+
+Integers inside the safe range stay normal numbers, so the same prop can arrive as a `number` or a `bigint`. Flash data gets the same treatment.
diff --git a/docs/redirects-and-history.md b/docs/redirects-and-history.md
new file mode 100644
index 0000000..aa512fd
--- /dev/null
+++ b/docs/redirects-and-history.md
@@ -0,0 +1,57 @@
+# Redirects and history
+
+## Redirects
+
+```rust,ignore
+inertia.redirect("/users")          // 303 See Other
+inertia.back()                      // back to the previous page
+inertia.location("https://…")       // leave the app
+```
+
+`redirect` always answers `303`, so the browser follows with a `GET` after any method. A plain `302` that your handler returns from a `POST`, `PUT`, `PATCH` or `DELETE` (for example `axum::response::Redirect`) is changed to `303` by the layer.
+
+### Back
+
+`inertia.back()` redirects to, in this order:
+
+1. the `Referer` header of the request;
+2. the previous URL from the session, if `InertiaConfig::store_previous_url(true)` is set;
+3. `/`.
+
+With `store_previous_url`, veer stores the URL of each Inertia page visit in the session. Partial reloads and prefetches are not stored. This is the same rule as the `store_previous_url` option of the Laravel adapter. It needs a session store. With the cookie store the value lives for 60 seconds; use `tower-sessions` for a longer life.
+
+### External redirects
+
+```rust,ignore
+async fn oauth_start(inertia: Inertia) -> impl IntoResponse {
+    inertia.location("https://accounts.example.com/oauth/authorize?…")
+}
+```
+
+An XHR cannot follow a redirect to another origin. For an Inertia request, veer answers `409` with `X-Inertia-Location`, and the client does a full browser navigation. For a plain browser request it answers a normal `302`.
+
+### URL fragments
+
+An XHR drops the fragment (`#section`) of a redirect that it follows. Veer handles both cases:
+
+- **The redirect target has a fragment**: `inertia.redirect("/docs#install")`. For an Inertia request, veer answers `409` with `X-Inertia-Redirect`, and the client makes a new visit to the full URL.
+- **Keep the fragment of the original request**: `inertia.redirect("/docs").preserve_fragment()`. The next page object has `preserveFragment: true`.
+
+### Empty responses
+
+An Inertia request that gets an empty `200` cannot render anything. As the Laravel adapter does, veer changes it into a redirect back.
+
+## History
+
+Inertia keeps page data in the browser history state. Two controls protect sensitive pages:
+
+```rust,ignore
+inertia.render("Account", props).encrypt_history()   // encrypt this page's history state
+inertia.redirect("/login").clear_history()           // the next page clears the encryption key
+```
+
+`InertiaConfig::encrypt_history(true)` turns encryption on for every page. `clear_history()` on a redirect applies to the page that the redirect lands on. Call it on logout, so that the back button cannot show the pages of the signed-out user.
+
+## Asset version mismatch
+
+When a client sends an old asset version on a `GET`, veer answers `409` with `X-Inertia-Location` and `X-Inertia-Version`. The client then reloads the page. The version header tells the client that this is a deploy and not an external redirect, so it does not reload during a background request such as a poll. Flash data survives the reload.
diff --git a/docs/sessions.md b/docs/sessions.md
new file mode 100644
index 0000000..d0a9dcc
--- /dev/null
+++ b/docs/sessions.md
@@ -0,0 +1,72 @@
+# Sessions
+
+Veer uses a session store for data that must reach the next request: validation errors, flash data, and the previous URL. Without a store, `with_errors` and `with_flash` on a redirect have no effect.
+
+## Cookie store
+
+For an app with no session crate. Enable the `cookie-session` feature:
+
+```rust,ignore
+use veer::session::cookie::CookieSessionStore;
+
+let cfg = InertiaConfig::new()
+    .session(CookieSessionStore::new(secret)); // at least 32 bytes
+```
+
+The data is in one cookie (`_veer_flash`), signed with HMAC-SHA256 and verified in constant time. The cookie is `HttpOnly`, `Secure` and `SameSite=Lax`, and lives for 60 seconds.
+
+- For local HTTP development, call `.secure(false)`.
+- A cookie holds about 4 KB. For large flash data, use `tower-sessions`.
+
+## tower-sessions
+
+If the app already uses [`tower-sessions`](https://crates.io/crates/tower-sessions), enable the `tower-sessions` feature. The data then lives in the backend that you configured (memory, Redis, Postgres, …).
+
+```rust,ignore
+use time::Duration;
+use tower_sessions::{Expiry, MemoryStore, SessionManagerLayer};
+use veer::{session::tower::TowerSessionStore, InertiaConfig, InertiaLayer};
+
+let session_layer = SessionManagerLayer::new(MemoryStore::default())
+    .with_expiry(Expiry::OnInactivity(Duration::minutes(30)));
+
+let cfg = InertiaConfig::new().session(TowerSessionStore::new());
+
+let app = axum::Router::new()
+    // … routes …
+    .layer(InertiaLayer::new(cfg))
+    .layer(session_layer); // must wrap outside InertiaLayer
+```
+
+The data is under one session key (`_veer_flash`; change it with `TowerSessionStore::new().key("…")`).
+
+## A custom store
+
+Implement `SessionStore` over the session crate that you use:
+
+```rust,ignore
+use async_trait::async_trait;
+use http::{request::Parts, Extensions, HeaderMap};
+use veer::{Flash, SessionStore};
+
+struct MyStore;
+
+#[async_trait]
+impl SessionStore for MyStore {
+    async fn read_and_clear(&self, req: &Parts) -> Flash {
+        // Load the Flash for this request, or Flash::default().
+    }
+
+    async fn write(&self, headers: &mut HeaderMap, req_extensions: &Extensions, flash: Flash) {
+        // Save the Flash for the next request. An empty Flash means "clear".
+    }
+}
+```
+
+`Flash` implements `Serialize` and `Deserialize`, so you can store it as JSON. It is `#[non_exhaustive]`; start from `Flash::default()`. `write` gets the response headers (for a cookie) and a copy of the request extensions (for a session handle that a middleware put there).
+
+## How the data flows
+
+- A **redirect** writes its errors and flash data, plus the flash data that the request read and did not use. A chain of redirects thus keeps a flash message.
+- A **page render** uses the data: errors go to `props.errors`, flash data to the page's `flash`.
+- **Other responses** (a JSON endpoint, a `404`, a Precognition response) pass the data on unchanged.
diff --git a/docs/typescript.md b/docs/typescript.md
new file mode 100644
index 0000000..424b44f
--- /dev/null
+++ b/docs/typescript.md
@@ -0,0 +1,165 @@
+# TypeScript bindings
+
+With the `ts` feature, veer generates TypeScript from your Rust code: the props type of each page, a `Pages` union, and one module of URL helpers for each controller. The types come from the same structs that produce the JSON, so they cannot drift.
+
+```toml
+[dependencies]
+veer = { version = "0.2", features = ["ts"] }
+ts-rs = "12"
+```
+
+## 1. Register pages
+
+```rust,ignore
+use serde::Serialize;
+use ts_rs::TS;
+
+#[derive(Serialize, TS)]
+#[ts(export)]
+#[serde(rename_all = "camelCase")]
+pub struct UsersIndexProps {
+    pub users: Vec<User>,
+}
+veer::register_page!(UsersIndexProps, "Users/Index");
+```
+
+`ts-rs` follows `#[serde(rename_all)]`, so the type and the wire format agree.
+
+### Closure props
+
+Props that a handler attaches as closures (`once`, `deferred`, `lazy`, `Prop::scroll`, …) are not fields of the props struct. Describe them in a second struct and pass it as the third argument:
+
+```rust,ignore
+#[derive(TS)]
+#[ts(export)]
+pub struct UsersIndexClosureProps {
+    pub plans: Vec<Plan>,        // once prop
+    #[ts(optional)]
+    pub stats: Option<Stats>,    // deferred prop: absent on the first render
+    pub feed: Feed,              // scroll prop
+}
+veer::register_page!(UsersIndexProps, "Users/Index", UsersIndexClosureProps);
+```
+
+The props type of the page is then `UsersIndexProps & UsersIndexClosureProps`. The closures return the same Rust types, so one definition serves both sides:
+
+```rust,ignore
+inertia
+    .render("Users/Index", UsersIndexProps { users })
+    .once("plans", || async { load_plans().await })                 // Vec<Plan>
+    .deferred("stats", "default", || async { load_stats().await })  // Stats
+```
+
+Mark a deferred or lazy prop `#[ts(optional)]`, because it is absent until the client loads it.
+
+## 2. Name the routes
+
+`veer::Router` is a thin layer over `axum::Router` that records a name and a method for each route:
+
+```rust,ignore
+use veer::Method::*;
+
+pub fn router() -> veer::Router<AppState> {
+    veer::Router::new()
+        .named_route(GET,    "users.index",   "/users",      users_index)
+        .named_route(GET,    "users.show",    "/users/{id}", users_show)
+        .named_route(GET,    "users.create",  "/users/new",  users_create)
+        .named_route(POST,   "users.store",   "/users",      users_store)
+        .named_route(PATCH,  "users.update",  "/users/{id}", users_update)
+        .named_route(DELETE, "users.destroy", "/users/{id}", users_destroy)
+}
+
+// In main():
+let app = router().build().with_state(state).layer(InertiaLayer::new(cfg));
+```
+
+`build()` returns a normal `axum::Router`. Two methods on one path are merged. `.route(path, method_router)` adds a route without a name.
+
+The first part of the name (`users`) is the controller; the names after it follow the Laravel resource convention (`index`, `show`, `create`, `store`, `update`, `destroy`).
+
+## 3. Generate
+
+Add a small binary to your app crate:
+
+```rust,ignore
+// src/bin/gen-bindings.rs
+fn main() {
+    let _ = my_app::router().build();   // fills the route registry
+    veer::bindings::generate_split("./frontend/gen").unwrap();
+}
+```
+
+```bash
+cargo run --bin gen-bindings
+```
+
+The generator must run inside your crate, because the pages and routes are registered by your compiled code.
+
+```text
+frontend/gen/
+  index.ts              protocol types, Pages union, prop types, action re-exports
+  actions/
+    users.ts            index, show, create, store, update, destroy
+    _root.ts            routes with no dot in the name
+```
+
+## 4. Use on the frontend
+
+```tsx
+import { Link, usePage } from "@inertiajs/react";
+import { users, type Pages } from "./gen";
+
+type Props = Extract<Pages, { component: "Users/Index" }>["props"];
+
+export default function Index() {
+  const { props } = usePage<Props>();
+  return (
+    <>
+      <Link href={users.create.url()}>New user</Link>
+      {props.users.map((u) => (
+        <Link key={u.id} href={users.show.url({ id: u.id })}>{u.name}</Link>
+      ))}
+    </>
+  );
+}
+```
+
+Each action has three forms:
+
+| Call | Returns |
+|---|---|
+| `users.show({ id: 1 })` | `{ url: "/users/1", method: "get" }` |
+| `users.show.url({ id: 1 })` | `"/users/1"` |
+| `users.show.form({ id: 1 })` | `{ action: "/users/1", method: "get" }` |
+
+## Options
+
+**Layout.** The `Split` builder changes the output layout:
+
+```rust,ignore
+veer::bindings::Split::new("./frontend/gen")
+    .actions_dir("controllers")    // frontend/gen/controllers/
+    .file_suffix("-controller")    // users-controller.ts
+    .generate()?;
+```
+
+`actions_dir("")` writes the files next to `index.ts`. For one file, use `veer::bindings::generate("./frontend/inertia.gen.ts")`.
+
+**Large integers.** `ts-rs` maps `u64` and `i64` to `bigint`. Turn on [big-integer support](props.md#big-integers) so that large values arrive as `BigInt`; values inside the safe range still arrive as `number`.
+
+**Wrappers.** `Always<T>` and `Merge<T>` become `T`.
+
+**Keep the output current.** With [lefthook](https://github.com/evilmartians/lefthook):
+
+```yaml
+pre-commit:
+  commands:
+    veer-bindings:
+      glob: "*.rs"
+      run: cargo run -q --bin gen-bindings
+      stage_fixed: true
+```
+
+In CI, run `cargo run --bin gen-bindings && git diff --exit-code`.
+
+Files of a controller that you removed are not deleted; delete the output folder before you generate if that is important.
diff --git a/docs/upgrading.md b/docs/upgrading.md
new file mode 100644
index 0000000..c0888f1
--- /dev/null
+++ b/docs/upgrading.md
@@ -0,0 +1,73 @@
+# Upgrading from 0.1 to 0.2
+
+Version 0.2 brings veer to the current Inertia v3 protocol (client 3.8). Most apps need the first two changes; the others apply only if you use the feature. The full list of additions is in the [changelog](../CHANGELOG.md).
+
+## Flash data moved out of props
+
+Flash data is now the top-level `flash` field of the page object. This is what the v3 client expects: it does not keep `flash` in the browser history.
+
+```diff
+- const success = usePage().props.flash?.success;
++ const success = usePage().flash.success;
+```
+
+No change on the Rust side: `with_flash` works as before.
+
+## `ts-rs` 12
+
+If you use the `ts` feature, update `ts-rs`:
+
+```diff
+- ts-rs = "11"
++ ts-rs = "12"
+```
+
+Then generate the bindings again. The generated `PageObject` and `Flash` types changed.
+
+## Route paths
+
+Not a veer change, but check it: axum 0.8 writes path parameters as `/users/{id}`, not `/users/:id`.
+
+## `reset_merge` is removed
+
+`InertiaResponse::reset_merge` and the `resetMergeProps` field were not part of the protocol. Delete the call. The client asks for a reset (`router.reload({ reset: ['posts'] })`), and veer then sends the prop without its merge label.
+
+## `location()` for plain requests
+
+`inertia.location(url)` answers `409` + `X-Inertia-Location` only for an Inertia request. A plain browser request now gets a `302`, which a browser can follow.
+
+## `with_errors` on a render
+
+`inertia.render(…).with_errors(errors)` now shows the errors on that page. In 0.1 they went to the next page. `with_errors(…).redirect(…)` is unchanged.
+
+## Partial reloads follow the protocol
+
+- `errors` is always sent.
+- A partial reload with only `except` returns all other props (0.1 returned none).
+- `only` and `except` accept dot paths.
+- A prop that the response leaves out has no merge label.
+
+If frontend code relied on the old behavior, check it.
+
+## Custom session stores
+
+- `Flash::errors` is now `HashMap<String, Vec<String>>`: all messages of a field.
+- `Flash` is `#[non_exhaustive]` and has new fields. Build it from `Flash::default()`, and store the complete value; `Flash` implements `Serialize` and `Deserialize`.
+- A store must keep the data when a response that is not a page writes it back.
+
+## Lower-level types
+
+- `props::closure::{LazyProp, DeferredProp}` are replaced by `props::Prop`. The builder methods `lazy`, `optional` and `deferred` are unchanged.
+- `RequestInfo` and `PageObject` are `#[non_exhaustive]`. Use `RequestInfo::from_parts` and `PageObject::new`.
+- `protocol::ResponseShape` has new variants.
+- `props::resolver::resolve` returns a `Result`.
+
+## New Cargo feature
+
+The DevTools recorder is behind the new `devtools` feature. Nothing changes if you do not enable it.
+
+## Recommended after the upgrade
+
+- Update the client to `@inertiajs/react` (or `vue3`, `svelte`) 3.8.
+- Closure props can return typed values: `.once("plans", || async { load_plans().await })`. `json!` is no longer necessary.
+- Give closure props TypeScript types with the [third argument of `register_page!`](typescript.md#closure-props).
diff --git a/docs/vite-ssr-assets.md b/docs/vite-ssr-assets.md
new file mode 100644
index 0000000..cca6f38
--- /dev/null
+++ b/docs/vite-ssr-assets.md
@@ -0,0 +1,156 @@
+# Vite, SSR and assets
+
+The **root view** is the HTML shell of the first page load. Veer has three:
+
+| Root view | Use |
+|---|---|
+| `MinimalRootView` | A shell with no dependencies; good for a first test |
+| `ViteRootView` | Vite dev server and production manifest |
+| `ClosureRootView`, or your own `RootView` | Full control over the HTML (for example a template engine) |
+
+## Vite
+
+`ViteRootView` does what Laravel's `@vite` and `@viteReactRefresh` directives do.
+
+**Development.** Script tags point at the Vite dev server:
+
+```rust,ignore
+use veer::ViteRootView;
+
+let cfg = InertiaConfig::new().root_view(
+    ViteRootView::dev()
+        .title("Acme")
+        .entry("frontend/app.tsx")
+        .dev_server("http://localhost:5173")
+        .react_refresh(true), // necessary for @vitejs/plugin-react
+);
+```
+
+**Production.** `vite build` writes `dist/.vite/manifest.json`. `ViteRootView::production` reads it and emits the entry script, its CSS, and `modulepreload` links for imported chunks:
+
+```rust,ignore
+use veer::{ViteManifest, ViteRootView};
+
+let manifest = ViteManifest::load("dist/.vite/manifest.json")?;
+let version = manifest.hash(); // changes when a chunk changes
+
+let cfg = InertiaConfig::new()
+    .version(move || version.clone().into())
+    .root_view(
+        ViteRootView::production()
+            .title("Acme")
+            .entry("frontend/app.tsx")
+            .manifest(manifest)
+            .asset_base("/build"),
+    );
+
+// Serve the built files:
+// .nest_service("/build", tower_http::services::ServeDir::new("dist"))
+```
+
+With `version` set to `manifest.hash()`, each new build makes old clients reload. You do not change a version by hand.
+
+## Server-side rendering
+
+SSR needs a small Node or Bun process that renders the page; the official client packages provide it (`@inertiajs/react/server` and the equivalents). Enable the `ssr` feature and give veer its URL:
+
+```rust,ignore
+use veer::ssr::http::HttpSsrClient;
+
+let cfg = InertiaConfig::new()
+    .ssr(HttpSsrClient::new("http://127.0.0.1:13714/render"));
+```
+
+For each first page load, veer posts the page object to the SSR server and puts the returned `head` and `body` into the shell.
+
+| Setting | Effect |
+|---|---|
+| default | If SSR fails, veer logs the error (with the detail from the SSR server) and renders on the client |
+| `InertiaConfig::ssr_required(true)` | If SSR fails, answer `500` |
+| `inertia.render(…).no_ssr()` | No SSR for this response |
+| `HttpSsrClient::timeout(duration)` | Request timeout (default 5 seconds) |
+| `client.health().await` | `true` if the SSR server answers `GET /health`; use it to wait at startup |
+
+The SSR entry file on the frontend:
+
+```tsx
+// frontend/ssr.tsx
+import createServer from "@inertiajs/react/server";
+import { createInertiaApp } from "@inertiajs/react";
+import ReactDOMServer from "react-dom/server";
+
+createServer((page) =>
+  createInertiaApp({
+    page,
+    render: ReactDOMServer.renderToString,
+    resolve: (name) => import(`./pages/${name}.tsx`),
+    setup: ({ App, props }) => <App {...props} />,
+  }),
+);
+```
+
+In production, build it with `vite build --ssr frontend/ssr.tsx` and run the bundle with `node` or `bun`.
+
+## Embedded assets
+
+For one self-contained binary, embed the built frontend. Enable the `embed` feature:
+
+```rust,ignore
+use rust_embed::RustEmbed;
+use veer::{EmbeddedAssets, ViteManifest, ViteRootView};
+
+#[derive(RustEmbed)]
+#[folder = "dist/"]
+struct Assets;
+
+let manifest: ViteManifest = include_str!("../dist/.vite/manifest.json").parse()?;
+let version = manifest.hash();
+
+let cfg = InertiaConfig::new()
+    .version(move || version.clone().into())
+    .root_view(ViteRootView::production().entry("frontend/app.tsx").manifest(manifest));
+
+let app = router()
+    .layer(InertiaLayer::new(cfg))
+    .nest_service("/build", EmbeddedAssets::new(|p| Assets::get(p).map(|f| f.data)));
+```
+
+`EmbeddedAssets` takes any `Fn(&str) -> Option<Cow<'static, [u8]>>`, so it works with `rust-embed`, `include_dir`, or a map. It sets `Content-Type` from the file extension and a long `Cache-Control`, which is correct for file names that contain a content hash.
+
+## Head elements from the server
+
+The client has a `serverHead` option that reads `<head>` elements from a prop (`head` by default). `veer::Head` builds that prop and escapes its values:
+
+```rust,ignore
+use veer::Head;
+
+inertia.render("Users/Show", UsersShowProps {
+    head: Head::new().title(&user.name).meta("description", &user.bio),
+    user,
+})
+```
+
+`Head::raw(html)` adds an element as raw HTML; escape untrusted values yourself.
+
+## A custom root view
+
+```rust,ignore
+use veer::{RootView, RootViewContext};
+
+struct MyView;
+
+impl RootView for MyView {
+    fn render(&self, ctx: RootViewContext<'_>) -> Result<String, String> {
+        let body = match ctx.ssr {
+            Some(ssr) => ssr.body.clone(),
+            None => format!(
+                r#"<script data-page="app" type="application/json">{}</script><div id="app"></div>"#,
+                ctx.page_json_script
+            ),
+        };
+        Ok(format!("<!doctype html><html><head>…</head><body>{body}</body></html>"))
+    }
+}
+```
+
+Use `ctx.page_json_script` inside the `<script>` tag: it is the page JSON with `<`, `>` and `/` escaped, so that prop data cannot close the tag. Do not HTML-escape it again.
diff --git a/examples/axum-react-todo/README.md b/examples/axum-react-todo/README.md
index b7e66e1..8d630e8 100644
--- a/examples/axum-react-todo/README.md
+++ b/examples/axum-react-todo/README.md
@@ -3,6 +3,12 @@
 End-to-end demo of `veer` driving a React + Vite frontend. Runs in two modes
 from the same binary, toggled by an env flag.
 
+## What it shows
+
+- `/todos`: a list with create and delete, validation errors, flash messages, and Precognition live validation on the create form.
+- `/showcase`: a once prop, a deferred prop, a rescued prop, infinite scroll, a fragment redirect, and a big integer, with TypeScript types generated from the Rust structs (`src/todos.rs`).
+- The DevTools recorder is on in debug builds.
+
 ## Run
 
 From this directory:
@@ -22,7 +28,7 @@ If you don't have `just`: `cargo install just` (or `brew install just`).
 Pure client-side bootstrap — Vite owns the browser, Rust owns the data.
 
 1. Browser loads `http://localhost:5173/` → Vite serves `index.html`.
-2. `frontend/app.tsx` runs, does a single `fetch` with `X-Inertia: true` for the current URL.
+2. `frontend/app.tsx` runs, does a single `fetch` with `X-Inertia: true` for the current URL, and puts the result into the page's `<script data-page>` tag.
 3. Vite's proxy forwards it to the Rust backend on `:3000`.
 4. Rust returns the page object as JSON (made unambiguous by `csr_only(true)`).
 5. `createInertiaApp` mounts with `createRoot`. Subsequent navigations are XHRs through the same proxy.
diff --git a/src/shared.rs b/src/shared.rs
index 073a3fb..8d15f9b 100644
--- a/src/shared.rs
+++ b/src/shared.rs
@@ -27,7 +27,15 @@ where
     }
 }
 
-/// Helper to wrap a closure as a boxed `SharedProps` trait object.
+#[async_trait]
+impl SharedProps for Arc<dyn SharedProps> {
+    async fn shared(&self, req: &RequestInfo) -> Value {
+        (**self).shared(req).await
+    }
+}
+
+/// Helper to wrap a closure as a boxed `SharedProps` trait object. Pass the
+/// result to [`crate::InertiaConfig::shared`].
 pub fn shared_props_fn<F, Fut>(f: F) -> Arc<dyn SharedProps>
 where
     F: Fn(&RequestInfo) -> Fut + Send + Sync + 'static,
@@ -47,5 +55,7 @@ mod tests {
         let s = shared_props_fn(|_r| async { json!({"x": 1}) });
         let r = RequestInfo::from_parts(http::Method::GET, "/".into(), &HeaderMap::new());
         assert_eq!(s.shared(&r).await, json!({"x": 1}));
+        // The helper's result goes straight into the config.
+        let _ = crate::InertiaConfig::new().shared(s);
     }
 }

From d91428a805dfac4ea93296156553232efe3b5a68 Mon Sep 17 00:00:00 2001
From: Aditya Tripathi <aditya@climactic.co>
Date: Sat, 3 Oct 2026 23:26:41 +0000
Subject: [PATCH 4/5] =?UTF-8?q?fix:=20review=20corrections=20=E2=80=94=20p?=
 =?UTF-8?q?revious=20URL=20storage,=20closure=20wrappers,=20Precognition?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- the previous URL is no longer part of `Flash`: `SessionStore` has
  `previous_url` / `store_previous_url` (defaults keep nothing). The cookie
  store uses its own signed cookie; flash data keeps its 60 s life and plain
  responses no longer rewrite the session
- the URL of each page visit is stored (also the first HTML load), except
  `//host` targets and URLs over 2048 bytes; the empty-200 redirect uses it
- `Merge` / `Always` wrappers inside a closure prop's value are stripped and
  labelled (they reached the client as marker objects)
- remove the Precognition fallback in the layer: it could replace a handler's
  own 422 body and report a rejected body as valid
- a nested `Always` under an unselected parent is not sent: the client
  replaces top-level props, so a partial parent would lose its other fields
- `InertiaMiddleware` drives the service instance that `poll_ready` readied
- docs: Precognition notes, session store methods, wrapper behavior
---
 CHANGELOG.md                   |   4 +-
 docs/architecture.md           |   1 -
 docs/forms-and-validation.md   |   6 +-
 docs/props.md                  |   2 +-
 docs/redirects-and-history.md  |   2 +-
 docs/sessions.md               |   4 +-
 src/adapters/axum/extractor.rs |  11 ++--
 src/adapters/axum/layer.rs     |  39 +++++--------
 src/adapters/axum/response.rs  |  32 +++++++----
 src/config.rs                  |   2 +-
 src/inertia.rs                 |   4 +-
 src/props/always.rs            |   4 +-
 src/props/resolver.rs          |  28 ++++++++-
 src/session/cookie.rs          | 100 ++++++++++++++++++++++++++-------
 src/session/mod.rs             |  22 ++++++--
 src/session/tower.rs           |  21 +++++++
 tests/common/mod.rs            |   8 +++
 tests/v3_protocol.rs           |  65 ++++++++++++++-------
 18 files changed, 255 insertions(+), 100 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2f66e6b..671a86a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -36,8 +36,6 @@ Brings the protocol surface up to Inertia client 3.8.0 / `inertia-laravel` 3.5.1
 - `InertiaConfig::store_previous_url`: `Inertia::back` uses the session's
   previous URL when the request has no `Referer`.
 - `veer::Head`: escaped `<head>` elements for the client's `serverHead` option.
-- A Precognition request whose body an extractor rejects still gets a
-  Precognition response.
 - Inertia DevTools protocol (`devtools` feature): `InertiaConfig::devtools(DevTools::new())` records
   each request, sets the `X-Inertia-Devtools-*` headers and serves the read API.
 - All validation messages per field: `IntoErrorBag::into_all_errors`,
@@ -66,6 +64,8 @@ Brings the protocol surface up to Inertia client 3.8.0 / `inertia-laravel` 3.5.1
 - `with_errors` on a render puts the errors on that page (not on the next one).
 - Flash data is used only by a page render; other responses pass it on.
 - `Flash::errors` is `HashMap<String, Vec<String>>` (all messages per field).
+- `SessionStore` has two new methods with defaults, `previous_url` and
+  `store_previous_url`.
 - `Flash` is `#[non_exhaustive]` and has `clear_history` / `preserve_fragment`;
   `clear_history()` on a redirect now applies to the page the redirect lands on.
 - Wrapper paths are dot paths; a nested `Merge<T>` now emits `mergeProps`.
diff --git a/docs/architecture.md b/docs/architecture.md
index d00c59a..8c926b3 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -92,6 +92,5 @@ The wire formats are checked against the protocol document, the `inertia-laravel
 ## Differences from the Laravel adapter
 
 - **`Prop::try_new` needs `.rescue()`** to rescue a failure; without it an `Err` gives a `500`. This is the same rule, in Rust terms.
-- **`back()`** uses the `Referer` header first. Laravel uses the session's previous URL first.
 - **Sessions hold only veer's data** (errors, flash, previous URL). Veer is not a general session library.
 - **The once-prop expiry** is set with a `Duration` (`.until(...)`).
diff --git a/docs/forms-and-validation.md b/docs/forms-and-validation.md
index b917c0e..7af73a8 100644
--- a/docs/forms-and-validation.md
+++ b/docs/forms-and-validation.md
@@ -36,7 +36,7 @@ async fn users_store(
 
 - `validator::ValidationErrors` (feature `validator`)
 - `garde::Report` (feature `garde`)
-- `HashMap<String, String>`, `Vec<(String, String)>`, `Vec<(&str, &str)>`
+- `HashMap<String, String>`, `Vec<(String, String)>`, `Vec<(&'static str, &'static str)>`
 
 On the next page, the errors are in `props.errors`, which is always present (`{}` when there are none). On the frontend, `useForm` puts them in `form.errors`.
 
@@ -74,6 +74,10 @@ async fn users_store(
 }
 ```
 
+> **Do the check first.** A Precognition request is the same request as the real submit, with one more header. A handler that does not call `inertia.precognition()` runs its action on each validation request. The client reports "Did not receive a Precognition response" in that case.
+>
+> **The body must deserialize.** `InertiaForm<T>` runs before your handler. A validation request sends the form as it is at that moment, so use types that accept incomplete input (`String`, `Option<T>`, `#[serde(default)]`) and put the rules in the validator.
+
 `respond` returns `204` when the requested fields are valid, and `422` with the errors when they are not. It reports only the fields that the client named in `Precognition-Validate-Only`.
 
 On the frontend, give `useForm` the method and URL:
diff --git a/docs/props.md b/docs/props.md
index 611a3d9..fda784a 100644
--- a/docs/props.md
+++ b/docs/props.md
@@ -153,7 +153,7 @@ struct DashboardProps {
 }
 ```
 
-They work at any depth and through any serialization path (structs, `json!`, hand-built values). A nested wrapper acts at its dot path. On the TypeScript side they collapse to the inner type.
+They work at any depth and through any serialization path (structs, `json!`, hand-built values). A nested wrapper acts at its dot path. A nested `Always` value is kept when the partial reload selects its parent (for example `only: ['auth']` with `except: ['auth.user']`); when the parent is not selected, the parent is not sent, because the client replaces top-level props as a whole. For data that every response must carry, put `Always` on a top-level prop. On the TypeScript side they collapse to the inner type.
 
 ## Big integers
 
diff --git a/docs/redirects-and-history.md b/docs/redirects-and-history.md
index aa512fd..65d639e 100644
--- a/docs/redirects-and-history.md
+++ b/docs/redirects-and-history.md
@@ -18,7 +18,7 @@ inertia.location("https://…")       // leave the app
 2. the previous URL from the session, if `InertiaConfig::store_previous_url(true)` is set;
 3. `/`.
 
-With `store_previous_url`, veer stores the URL of each Inertia page visit in the session. Partial reloads and prefetches are not stored. This is the same rule as the `store_previous_url` option of the Laravel adapter. It needs a session store. With the cookie store the value lives for 60 seconds; use `tower-sessions` for a longer life.
+With `store_previous_url`, veer stores the URL of each page visit in the session. Partial reloads and prefetches are not stored, as in the Laravel adapter. It needs a session store that keeps a previous URL: both built-in stores do. The cookie store keeps it in its own signed cookie for two hours; `tower-sessions` keeps it in the session. A URL longer than 2048 bytes is not stored.
 
 ### External redirects
 
diff --git a/docs/sessions.md b/docs/sessions.md
index d0a9dcc..3bdbda0 100644
--- a/docs/sessions.md
+++ b/docs/sessions.md
@@ -13,7 +13,7 @@ let cfg = InertiaConfig::new()
     .session(CookieSessionStore::new(secret)); // at least 32 bytes
 ```
 
-The data is in one cookie (`_veer_flash`), signed with HMAC-SHA256 and verified in constant time. The cookie is `HttpOnly`, `Secure` and `SameSite=Lax`, and lives for 60 seconds.
+The data is in one cookie (`_veer_flash`), signed with HMAC-SHA256 and verified in constant time. The cookie is `HttpOnly`, `Secure` and `SameSite=Lax`, and lives for 60 seconds. The [previous URL](redirects-and-history.md#back) has its own signed cookie (`_veer_previous_url`), which lives for two hours.
 
 - For local HTTP development, call `.secure(false)`.
 - A cookie holds about 4 KB. For large flash data, use `tower-sessions`.
@@ -63,6 +63,8 @@ impl SessionStore for MyStore {
 }
 ```
 
+For [`store_previous_url`](redirects-and-history.md#back), also implement `previous_url` and `store_previous_url`. Their defaults keep nothing.
+
 `Flash` implements `Serialize` and `Deserialize`, so you can store it as JSON. It is `#[non_exhaustive]`; start from `Flash::default()`. `write` gets the response headers (for a cookie) and a copy of the request extensions (for a session handle that a middleware put there).
 
 ## How the data flows
diff --git a/src/adapters/axum/extractor.rs b/src/adapters/axum/extractor.rs
index ad4e20d..b535eae 100644
--- a/src/adapters/axum/extractor.rs
+++ b/src/adapters/axum/extractor.rs
@@ -19,6 +19,8 @@ pub(crate) struct PerRequest {
     pub req_extensions: Arc<Extensions>,
     /// Id of the DevTools entry of this request, when the recorder is on.
     pub devtools_id: Option<String>,
+    /// URL of the last page visit, when `store_previous_url` is on.
+    pub previous_url: Option<String>,
 }
 
 impl<S> FromRequestParts<S> for Inertia
@@ -44,10 +46,9 @@ where
             .map(|p| p.as_str().to_string())
             .unwrap_or_else(|| parts.uri.path().to_string());
         let req_info = RequestInfo::from_parts(parts.method.clone(), url, &parts.headers);
-        Ok(Inertia::from_parts(
-            per.config,
-            req_info,
-            (*per.flash).clone(),
-        ))
+        let previous_url = per.previous_url.clone();
+        let mut inertia = Inertia::from_parts(per.config, req_info, (*per.flash).clone());
+        inertia.previous_url = previous_url;
+        Ok(inertia)
     }
 }
diff --git a/src/adapters/axum/layer.rs b/src/adapters/axum/layer.rs
index 36d4c11..6f07fab 100644
--- a/src/adapters/axum/layer.rs
+++ b/src/adapters/axum/layer.rs
@@ -70,7 +70,10 @@ where
 
     fn call(&mut self, req: Request<Body>) -> Self::Future {
         let cfg = self.config.clone();
-        let mut inner = self.inner.clone();
+        // Tower contract: drive the instance that poll_ready readied, leaving a
+        // fresh clone behind for the next call.
+        let clone = self.inner.clone();
+        let mut inner = std::mem::replace(&mut self.inner, clone);
         Box::pin(async move {
             #[cfg_attr(not(feature = "devtools"), allow(unused_mut))]
             let (mut parts, mut body) = req.into_parts();
@@ -114,7 +117,13 @@ where
             // still reach them on the response side.
             let extensions_snapshot = Arc::new(parts.extensions.clone());
 
+            let previous_url = match &cfg.session {
+                Some(s) if cfg.store_previous_url => s.previous_url(&parts).await,
+                _ => None,
+            };
+
             let per_request = PerRequest {
+                previous_url,
                 config: cfg.clone(),
                 flash: Arc::new(flash),
                 req_extensions: extensions_snapshot.clone(),
@@ -157,29 +166,6 @@ where
                     .append(&veer_headers::VARY, HeaderValue::from_static("X-Inertia"));
             }
 
-            // A validation request must get a Precognition response, also when
-            // an extractor rejected the body before the handler ran.
-            if req_info.is_precognition && !resp.headers().contains_key(&veer_headers::PRECOGNITION)
-            {
-                if resp.status() == StatusCode::UNPROCESSABLE_ENTITY {
-                    let body = r#"{"message":"The given data was invalid.","errors":{}}"#;
-                    *resp.body_mut() = Body::from(body);
-                    resp.headers_mut().remove(http::header::CONTENT_LENGTH);
-                    resp.headers_mut().insert(
-                        http::header::CONTENT_TYPE,
-                        HeaderValue::from_static("application/json"),
-                    );
-                }
-                resp.headers_mut().insert(
-                    &veer_headers::PRECOGNITION,
-                    HeaderValue::from_static("true"),
-                );
-                resp.headers_mut().append(
-                    &veer_headers::VARY,
-                    HeaderValue::from_static("Precognition"),
-                );
-            }
-
             #[cfg(feature = "devtools")]
             if let Some(recording) = recording {
                 let page = resp.extensions_mut().remove::<RecordedPage>();
@@ -291,7 +277,10 @@ async fn plain_response(
         resp = redirect(
             StatusCode::SEE_OTHER,
             http::header::LOCATION,
-            req.referer.as_deref().unwrap_or("/"),
+            req.referer
+                .as_deref()
+                .or(per.previous_url.as_deref())
+                .unwrap_or("/"),
         );
     }
 
diff --git a/src/adapters/axum/response.rs b/src/adapters/axum/response.rs
index 27ae441..047fec7 100644
--- a/src/adapters/axum/response.rs
+++ b/src/adapters/axum/response.rs
@@ -179,16 +179,19 @@ pub(crate) async fn finalize(
     // Flash data from the previous request, then data flashed by this handler.
     page.flash = incoming.bags.clone().into_iter().collect();
     page.flash.extend(std::mem::take(&mut pending.bags));
-    // As the Laravel adapter: page visits by XHR, not partial reloads or prefetches.
+    // The previous URL: each page visit, but not a partial reload or a
+    // prefetch. `//host` would be another origin as a redirect target, and a
+    // very long URL does not fit in a cookie.
     let is_partial = req_info.partial_component.as_deref() == Some(builder.component.as_str());
-    if cfg.store_previous_url
-        && req_info.is_inertia
+    let url = &req_info.url;
+    let store_url = cfg.store_previous_url
         && req_info.method == http::Method::GET
         && !req_info.is_prefetch
         && !is_partial
-    {
-        pending.previous_url = Some(req_info.url.clone());
-    }
+        && per.previous_url.as_deref() != Some(url)
+        && url.len() <= 2048
+        && !url.starts_with("//")
+        && !url.starts_with("/\\");
     if builder
         .preserve_big_integers
         .unwrap_or(cfg.preserve_big_integers)
@@ -253,7 +256,11 @@ pub(crate) async fn finalize(
             })
             .unwrap_or_else(|e| format!("root view error: {e}"));
         // The extension sees the first page load through the DOM only.
-        if let (Some(id), Some(at)) = (&per.devtools_id, html.rfind("</body>")) {
+        if let Some((id, at)) = per
+            .devtools_id
+            .as_ref()
+            .and_then(|id| Some((id, html.rfind("</body>")?)))
+        {
             let tag = format!(
                 r#"<script data-inertia-devtools-id type="application/json">{}</script>"#,
                 Value::from(id.as_str())
@@ -271,6 +278,11 @@ pub(crate) async fn finalize(
     if let Some(recorded) = recorded {
         response.extensions_mut().insert(recorded);
     }
+    if let (true, Some(session)) = (store_url, &cfg.session) {
+        session
+            .store_previous_url(response.headers_mut(), &per.req_extensions, url)
+            .await;
+    }
     finish_with_flash(response, pending, per).await
 }
 
@@ -309,14 +321,10 @@ pub(crate) fn version_mismatch(location: &str, version: &str) -> Response<Body>
 
 pub(crate) async fn finish_with_flash(
     mut response: Response<Body>,
-    mut pending: crate::session::Flash,
+    pending: crate::session::Flash,
     per: &PerRequest,
 ) -> Response<Body> {
     if let Some(session) = &per.config.session {
-        // The previous URL is not one-shot: carry it on.
-        if pending.previous_url.is_none() {
-            pending.previous_url = per.flash.previous_url.clone();
-        }
         session
             .write(response.headers_mut(), &per.req_extensions, pending)
             .await;
diff --git a/src/config.rs b/src/config.rs
index 80a9bfd..ff553a6 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -122,7 +122,7 @@ impl InertiaConfig {
         self
     }
 
-    /// Store the URL of each Inertia page visit in the session, so that
+    /// Store the URL of each page visit in the session, so that
     /// [`crate::Inertia::back`] has a target when the request has no `Referer`
     /// header. Needs a session store. Partial reloads and prefetches are not
     /// stored.
diff --git a/src/inertia.rs b/src/inertia.rs
index 77a6e09..072275d 100644
--- a/src/inertia.rs
+++ b/src/inertia.rs
@@ -16,6 +16,7 @@ pub struct Inertia {
     pub(crate) config: Arc<InertiaConfig>,
     pub(crate) request: Arc<RequestInfo>,
     pub(crate) incoming_flash: Arc<Flash>,
+    pub(crate) previous_url: Option<String>,
 }
 
 impl Inertia {
@@ -29,6 +30,7 @@ impl Inertia {
             config,
             request: Arc::new(request),
             incoming_flash: Arc::new(incoming_flash),
+            previous_url: None,
         }
     }
 
@@ -92,7 +94,7 @@ impl Inertia {
             .request
             .referer
             .clone()
-            .or_else(|| self.incoming_flash.previous_url.clone())
+            .or_else(|| self.previous_url.clone())
             .unwrap_or_else(|| "/".to_string());
         self.redirect(to)
     }
diff --git a/src/props/always.rs b/src/props/always.rs
index c48ab8b..81c8b36 100644
--- a/src/props/always.rs
+++ b/src/props/always.rs
@@ -9,7 +9,9 @@ use serde::{Serialize, Serializer};
 /// (typed `#[derive(Serialize)]` structs, `serde_json::json!`, hand-built
 /// `Value`s, etc.). The wrapper serializes as a single-key sentinel object
 /// that the Inertia resolver strips before sending to the client. A nested
-/// wrapper keeps its value through partial-reload filters at that dot path.
+/// wrapper keeps its value when the partial reload selects its parent. When the
+/// parent is not selected, the parent is not sent: the client replaces
+/// top-level props as a whole, so a partial parent would lose its other fields.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Always<T>(pub T);
 
diff --git a/src/props/resolver.rs b/src/props/resolver.rs
index 8b43d84..73650a7 100644
--- a/src/props/resolver.rs
+++ b/src/props/resolver.rs
@@ -225,6 +225,9 @@ impl Filter<'_> {
             if always.contains(&path) {
                 return true;
             }
+            // An unselected parent is dropped with its nested `Always` values.
+            // A parent with only some of its fields would replace the client's
+            // copy, because the client replaces top-level props.
             if !self.includes(&path) {
                 return false;
             }
@@ -428,7 +431,17 @@ pub async fn resolve(input: ResolveInput<'_>) -> Result<ResolvedProps, PropError
 
         match loader().await {
             Ok(loaded) => {
-                insert_path(map, &key, loaded.value);
+                // A closure can return `Merge` / `Always` wrappers too.
+                let mut value = loaded.value;
+                let (mut path, mut always, mut merges) =
+                    (key.clone(), HashSet::new(), HashSet::new());
+                strip_sentinels(&mut value, &mut path, &mut always, &mut merges);
+                out.merge_props.extend(
+                    merges
+                        .into_iter()
+                        .filter(|p| !filter.is_reset(p) && filter.emits_metadata(p)),
+                );
+                insert_path(map, &key, value);
                 collect_merge(&mut out);
                 if let Some(metadata) = loaded.scroll {
                     out.scroll_props.insert(
@@ -618,6 +631,8 @@ mod tests {
     async fn always_survives_only_and_except_at_any_depth() {
         let base = json!({"a": 1, "flag": Always(true), "auth": {"user": Always("u"), "x": 1}});
         let r = run(&req_partial(&["a"], &["flag", "auth"]), base, vec![]).await;
+        // An unselected parent is not sent: a partial `auth` would replace the
+        // client's complete one.
         assert_eq!(r.props, json!({"a": 1, "flag": true}));
 
         let base = json!({"a": 1, "auth": {"user": Always("u"), "x": 1}});
@@ -830,6 +845,17 @@ mod tests {
         assert_eq!(r.props, json!({"errors": {}}));
     }
 
+    #[tokio::test]
+    async fn wrappers_in_a_closure_value_are_stripped() {
+        let props = vec![(
+            "feed",
+            value(json!({"data": Merge(vec![1]), "x": Always(2)})),
+        )];
+        let r = run(&req_full(), json!({}), props).await;
+        assert_eq!(r.props, json!({"feed": {"data": [1], "x": 2}}));
+        assert_eq!(r.merge_props, ["feed.data"]);
+    }
+
     #[tokio::test]
     async fn nested_merge_path_replaces_the_root_label() {
         let props = vec![
diff --git a/src/session/cookie.rs b/src/session/cookie.rs
index c58d809..88322fb 100644
--- a/src/session/cookie.rs
+++ b/src/session/cookie.rs
@@ -10,6 +10,8 @@ use sha2::Sha256;
 use std::time::Duration;
 
 const COOKIE_NAME: &str = "_veer_flash";
+const PREVIOUS_URL_COOKIE: &str = "_veer_previous_url";
+const PREVIOUS_URL_MAX_AGE: Duration = Duration::from_secs(2 * 60 * 60);
 
 type HmacSha256 = Hmac<Sha256>;
 
@@ -95,19 +97,43 @@ impl CookieSessionStore {
     }
 }
 
+fn read_cookie(req: &RequestParts, name: &str) -> Option<String> {
+    req.headers
+        .get_all(header::COOKIE)
+        .iter()
+        .filter_map(|hv| hv.to_str().ok())
+        .flat_map(|s| s.split(';'))
+        .filter_map(|s| Cookie::parse(s.trim().to_owned()).ok())
+        .find(|c| c.name() == name)
+        .map(|c| c.value().to_string())
+}
+
+impl CookieSessionStore {
+    fn set_cookie(
+        &self,
+        headers: &mut HeaderMap,
+        name: &'static str,
+        value: String,
+        max_age: Duration,
+    ) {
+        let mut c = Cookie::new(name, value);
+        c.set_path("/");
+        c.set_secure(self.secure);
+        c.set_http_only(true);
+        c.set_same_site(self.same_site);
+        c.set_max_age(cookie::time::Duration::seconds(max_age.as_secs() as i64));
+        if let Ok(hv) = http::HeaderValue::from_str(&c.to_string()) {
+            headers.append(header::SET_COOKIE, hv);
+        }
+    }
+}
+
 #[async_trait]
 impl SessionStore for CookieSessionStore {
     async fn read_and_clear(&self, req: &RequestParts) -> Flash {
-        let raw = req
-            .headers
-            .get_all(header::COOKIE)
-            .iter()
-            .filter_map(|hv| hv.to_str().ok())
-            .flat_map(|s| s.split(';'))
-            .filter_map(|s| Cookie::parse(s.trim().to_owned()).ok())
-            .find(|c| c.name() == COOKIE_NAME)
-            .map(|c| c.value().to_string());
-        raw.and_then(|r| self.decode(&r)).unwrap_or_default()
+        read_cookie(req, COOKIE_NAME)
+            .and_then(|r| self.decode(&r))
+            .unwrap_or_default()
     }
 
     async fn write(&self, headers: &mut HeaderMap, _req_extensions: &Extensions, flash: Flash) {
@@ -118,18 +144,27 @@ impl SessionStore for CookieSessionStore {
             }
             return;
         }
-        let value = self.encode(&flash);
-        let mut c = Cookie::new(COOKIE_NAME, value);
-        c.set_path("/");
-        c.set_secure(self.secure);
-        c.set_http_only(true);
-        c.set_same_site(self.same_site);
-        c.set_max_age(cookie::time::Duration::seconds(
-            self.max_age.as_secs() as i64
-        ));
-        if let Ok(hv) = http::HeaderValue::from_str(&c.to_string()) {
-            headers.append(header::SET_COOKIE, hv);
+        self.set_cookie(headers, COOKIE_NAME, self.encode(&flash), self.max_age);
+    }
+
+    async fn previous_url(&self, req: &RequestParts) -> Option<String> {
+        let raw = read_cookie(req, PREVIOUS_URL_COOKIE)?;
+        let (b64, sig) = raw.split_once('.')?;
+        if !self.verify(b64.as_bytes(), sig) {
+            return None;
         }
+        String::from_utf8(URL_SAFE_NO_PAD.decode(b64).ok()?).ok()
+    }
+
+    async fn store_previous_url(
+        &self,
+        headers: &mut HeaderMap,
+        _req_extensions: &Extensions,
+        url: &str,
+    ) {
+        let b64 = URL_SAFE_NO_PAD.encode(url);
+        let value = format!("{b64}.{}", self.sign(b64.as_bytes()));
+        self.set_cookie(headers, PREVIOUS_URL_COOKIE, value, PREVIOUS_URL_MAX_AGE);
     }
 }
 
@@ -169,6 +204,29 @@ mod tests {
         assert_eq!(read.errors["name"], ["required"]);
     }
 
+    #[tokio::test]
+    async fn previous_url_has_its_own_signed_cookie() {
+        let store = CookieSessionStore::new(vec![0u8; 32]);
+        let mut headers = HeaderMap::new();
+        store
+            .store_previous_url(&mut headers, &Extensions::new(), "/users?page=2")
+            .await;
+        let set = headers[header::SET_COOKIE].to_str().unwrap();
+        assert!(set.starts_with("_veer_previous_url=") && set.contains("Max-Age=7200"));
+        let value = set.split_once('=').unwrap().1.split(';').next().unwrap();
+
+        let request = |value: &str| {
+            let b =
+                Request::builder().header(header::COOKIE, format!("_veer_previous_url={value}"));
+            b.body(()).unwrap().into_parts().0
+        };
+        assert_eq!(
+            store.previous_url(&request(value)).await.as_deref(),
+            Some("/users?page=2")
+        );
+        assert_eq!(store.previous_url(&request("L2V2aWw.bad")).await, None);
+    }
+
     #[tokio::test]
     async fn missing_cookie_yields_empty_flash() {
         let store = CookieSessionStore::new(vec![0u8; 32]);
diff --git a/src/session/mod.rs b/src/session/mod.rs
index 559ae11..188a532 100644
--- a/src/session/mod.rs
+++ b/src/session/mod.rs
@@ -25,10 +25,6 @@ pub struct Flash {
     pub clear_history: bool,
     /// The next page must set `preserveFragment`.
     pub preserve_fragment: bool,
-    /// URL of the last Inertia page visit (see
-    /// [`crate::InertiaConfig::store_previous_url`]). Not one-shot: the layer
-    /// carries it from request to request.
-    pub previous_url: Option<String>,
 }
 
 impl Flash {
@@ -38,7 +34,6 @@ impl Flash {
             && self.bags.is_empty()
             && !self.clear_history
             && !self.preserve_fragment
-            && self.previous_url.is_none()
     }
 }
 
@@ -59,4 +54,21 @@ pub trait SessionStore: Send + Sync {
     /// clone of the incoming request's extensions, captured by `InertiaLayer`
     /// so session middlewares' per-request handles remain reachable.
     async fn write(&self, headers: &mut HeaderMap, req_extensions: &Extensions, flash: Flash);
+
+    /// The URL of the last page visit, for [`crate::Inertia::back`]. Unlike
+    /// flash data it is not one-shot. The default has none, so
+    /// [`crate::InertiaConfig::store_previous_url`] needs a store that
+    /// implements this method and [`Self::store_previous_url`].
+    async fn previous_url(&self, _req: &RequestParts) -> Option<String> {
+        None
+    }
+
+    /// Keep `url` as the previous URL. The default does nothing.
+    async fn store_previous_url(
+        &self,
+        _headers: &mut HeaderMap,
+        _req_extensions: &Extensions,
+        _url: &str,
+    ) {
+    }
 }
diff --git a/src/session/tower.rs b/src/session/tower.rs
index 0bb489a..a906530 100644
--- a/src/session/tower.rs
+++ b/src/session/tower.rs
@@ -99,6 +99,27 @@ impl SessionStore for TowerSessionStore {
             tracing::error!(error = %e, "veer: failed to write flash to tower-sessions");
         }
     }
+
+    async fn previous_url(&self, req: &RequestParts) -> Option<String> {
+        let session = req.extensions.get::<Session>()?;
+        let key = format!("{}_previous_url", self.key);
+        session.get::<String>(&key).await.ok().flatten()
+    }
+
+    async fn store_previous_url(
+        &self,
+        _headers: &mut HeaderMap,
+        req_extensions: &Extensions,
+        url: &str,
+    ) {
+        let Some(session) = req_extensions.get::<Session>() else {
+            return;
+        };
+        let key = format!("{}_previous_url", self.key);
+        if let Err(e) = session.insert(&key, url).await {
+            tracing::error!(error = %e, "veer: failed to write the previous URL to tower-sessions");
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index 50a7658..4fdff38 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -8,6 +8,8 @@ use veer::ssr::{SsrClient, SsrError, SsrPayload};
 #[derive(Clone, Default)]
 pub struct MockSession {
     pub store: Arc<Mutex<Flash>>,
+    #[allow(dead_code)]
+    pub previous_url: Arc<Mutex<Option<String>>>,
 }
 
 #[async_trait]
@@ -20,6 +22,12 @@ impl SessionStore for MockSession {
         let mut g = self.store.lock().await;
         *g = flash;
     }
+    async fn previous_url(&self, _req: &http::request::Parts) -> Option<String> {
+        self.previous_url.lock().await.clone()
+    }
+    async fn store_previous_url(&self, _h: &mut HeaderMap, _ext: &Extensions, url: &str) {
+        *self.previous_url.lock().await = Some(url.to_string());
+    }
 }
 
 #[derive(Clone)]
diff --git a/tests/v3_protocol.rs b/tests/v3_protocol.rs
index a4e3e52..0bd3736 100644
--- a/tests/v3_protocol.rs
+++ b/tests/v3_protocol.rs
@@ -533,6 +533,16 @@ async fn back_uses_the_stored_previous_url_when_there_is_no_referer() {
             config().session(session.clone()).store_previous_url(true),
         ));
 
+    // The first (HTML) page load is a page visit too.
+    app.clone()
+        .oneshot(req("GET", "/users?page=1"))
+        .await
+        .unwrap();
+    assert_eq!(
+        session.previous_url.lock().await.as_deref(),
+        Some("/users?page=1")
+    );
+
     let p = page(
         app.clone()
             .oneshot(req_inertia("GET", "/users?page=2", "v1"))
@@ -567,30 +577,43 @@ async fn back_uses_the_stored_previous_url_when_there_is_no_referer() {
 }
 
 #[tokio::test]
-async fn precognition_request_with_a_rejected_body_gets_a_precognition_response() {
-    #[derive(serde::Deserialize)]
-    struct NewUser {
-        #[allow(dead_code)]
-        name: String,
-    }
+async fn back_does_not_use_a_stored_url_that_points_at_another_origin() {
+    let session = MockSession::default();
     let app = Router::new()
-        .route(
-            "/users",
-            post(|_: Inertia, _: veer::InertiaForm<NewUser>| async { "created" }),
-        )
-        .layer(InertiaLayer::new(config()));
-    let r = http::Request::builder()
-        .method("POST")
-        .uri("/users")
-        .header("precognition", "true")
-        .header("content-type", "application/json")
-        .body(axum::body::Body::from("{}"))
+        .fallback(|i: Inertia| async move { i.render("NotFound", json!({})) })
+        .route("/go", post(|i: Inertia| async move { i.back() }))
+        .layer(InertiaLayer::new(
+            config().session(session.clone()).store_previous_url(true),
+        ));
+    app.clone()
+        .oneshot(req_inertia("GET", "//evil.example/x", "v1"))
+        .await
+        .unwrap();
+    assert_eq!(*session.previous_url.lock().await, None);
+
+    // An empty 200 goes back to the stored URL when there is no Referer.
+    *session.previous_url.lock().await = Some("/users".into());
+    let app = Router::new()
+        .route("/empty", post(|| async {}))
+        .layer(InertiaLayer::new(
+            config().session(session.clone()).store_previous_url(true),
+        ));
+    let resp = app
+        .oneshot(req_inertia("POST", "/empty", "v1"))
+        .await
         .unwrap();
+    assert_eq!(resp.headers().get("location").unwrap(), "/users");
+}
+
+#[tokio::test]
+async fn handler_that_ignores_precognition_gets_no_precognition_header() {
+    // The client then reports the fault, and no handler body is rewritten.
+    let app = Router::new()
+        .route("/users", post(|| async { "created" }))
+        .layer(InertiaLayer::new(config()));
+    let r = with_headers("POST", "/users", &[("precognition", "true")]);
     let resp = app.oneshot(r).await.unwrap();
-    assert_eq!(resp.status(), 422);
-    assert_eq!(resp.headers().get("precognition").unwrap(), "true");
-    let body: Value = serde_json::from_str(&body_string(resp).await).unwrap();
-    assert_eq!(body["errors"], json!({}));
+    assert!(resp.headers().get("precognition").is_none());
 }
 
 #[cfg(feature = "devtools")]

From 9e1af0a3ba3169b611e07473e660b736195d0ad0 Mon Sep 17 00:00:00 2001
From: Aditya Tripathi <aditya@climactic.co>
Date: Sat, 3 Oct 2026 23:38:01 +0000
Subject: [PATCH 5/5] docs: use a recursive glob in the SSR resolver example

---
 docs/vite-ssr-assets.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/vite-ssr-assets.md b/docs/vite-ssr-assets.md
index cca6f38..017368a 100644
--- a/docs/vite-ssr-assets.md
+++ b/docs/vite-ssr-assets.md
@@ -79,17 +79,19 @@ import createServer from "@inertiajs/react/server";
 import { createInertiaApp } from "@inertiajs/react";
 import ReactDOMServer from "react-dom/server";
 
+const pages = import.meta.glob("./pages/**/*.tsx", { eager: true });
+
 createServer((page) =>
   createInertiaApp({
     page,
     render: ReactDOMServer.renderToString,
-    resolve: (name) => import(`./pages/${name}.tsx`),
+    resolve: (name) => pages[`./pages/${name}.tsx`],
     setup: ({ App, props }) => <App {...props} />,
   }),
 );
 ```
 
-In production, build it with `vite build --ssr frontend/ssr.tsx` and run the bundle with `node` or `bun`.
+Build it with `vite build --ssr frontend/ssr.tsx` and run the bundle with `node` or `bun`. `import.meta.glob` is a Vite feature: if you run the source file directly with Bun in development, import the pages into a map by hand, as the [example app](../examples/axum-react-todo/frontend/ssr.tsx) does.
 
 ## Embedded assets