docs(inertia): add the Inertia page + Filament callout on Livewire

Inertia is API-shaped on the server — query → hydrate → serialize props
→ JSON, the path the benchmarks already measure — so it needs no
dedicated axis, just a page that says so. Frame it as the easy case
opposite Livewire: plain JSON props, no HMAC snapshot, so no
byte-identity subtlety beyond Grease's standing promise. Add it to the
Introduction nav next to Octane/Livewire.

Also add a one-liner on the Livewire page: Filament is Livewire-based
and a Filament table is the canonical query-active update (re-queries on
every sort/filter/page), so it benefits on every interaction.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: serpentblade

docs/.vitepress/config.mts

@@ -69,6 +69,7 @@ export default defineConfig({
             { text: 'Why Grease', link: '/guide/why' },
             { text: 'Grease & Octane', link: '/guide/octane' },
             { text: 'Grease & Livewire', link: '/guide/livewire' },
+            { text: 'Grease & Inertia', link: '/guide/inertia' },
             { text: 'Getting Started', link: '/guide/getting-started' },
           ],
         },

docs/guide/inertia.md

@@ -0,0 +1,50 @@
+# Grease & Inertia
+
+## On the server, an Inertia visit *is* an API request — Grease greases it the same way
+
+[Inertia](https://inertiajs.com) moves rendering to Vue/React on the client, but the server
+half never changes shape. A controller queries its models, serializes them into props, and
+returns JSON:
+
+```php
+return Inertia::render('Users/Index', [
+    'users' => User::with('posts')->get(),
+]);
+```
+
+On the PHP side that's query → hydrate → serialize → respond — the exact path the
+[benchmarks](/guide/benchmarks) and `realworld.php` already measure on a plain JSON endpoint.
+Every visit is a fresh request; there's no persistent server-side component state. So the tiers
+land precisely as they do on an API route:
+
+- **Model hydration / casting** — the controller queries the models behind the props.
+- **`toArray()` + date serialization** — Inertia serializes props to JSON through the same path,
+  so a model or resource prop runs the [date/cast tiers](/guide/serialization-helpers).
+- **Container / request / router / events** — the request envelope, greased like any route.
+
+There's nothing Inertia-specific to install or configure: the model + serialization tiers are
+your props, the foundation tiers are the request. Add `HasGrease` to the models your controllers
+return and the existing [API numbers](/guide/benchmarks) are your numbers.
+
+## The easy case — no snapshot, no checksum
+
+Where [Livewire](/guide/livewire) ships a checksummed snapshot of model state between requests —
+a real place a one-byte serialization drift could break rehydration — Inertia carries no such
+thing. Props are plain JSON in the response, regenerated from scratch every visit; nothing is
+HMAC-sealed, no state round-trips through the browser. So there's no byte-identity subtlety to
+reason about beyond Grease's standing promise that serialized output is
+[byte-identical to vanilla](/guide/why#the-one-rule-byte-identical-output) — which every tier
+already keeps. Partial reloads (`only`/`except`) just send a subset of those same props: still a
+fresh request, fewer props serialized.
+
+(Inertia's SSR renders Vue/React in a Node process — Grease is a PHP package and doesn't touch
+it. The PHP side still only produces the props JSON, and that's what gets greased.)
+
+## Getting started
+
+Add `HasGrease` to the [Eloquent models](/guide/getting-started) your controllers pass as props —
+that's the whole story. The [Blade component tier](/guide/blade) barely applies (Inertia's only
+Blade is the root `app.blade.php` rendered once on the first load; every visit after is JSON), but
+the [container](/guide/container), [request](/guide/request), [router](/guide/routing), and
+[event](/guide/events) tiers all apply to the request like any other route and compound on top. An
+Inertia app is an API app wearing a SPA — greasing it is the same work, in the same place.

docs/guide/livewire.md

@@ -83,6 +83,11 @@ cheap with or without Grease, and that's fine. The win tracks the work: an inter
 model work gets greased every time; one that does none costs nothing either way. So the more your
 components actually *do* per click, the more this is doing for you.
 
+This is why **[Filament](https://filamentphp.com)** benefits so directly: it's built on Livewire,
+and a Filament table re-queries on every sort, filter, and page — the query-active shape, on every
+interaction. Put `HasGrease` on the models behind your resources and every table interaction takes
+the greased path.
+
 ## Getting started
 
 There's nothing Livewire-specific to install or configure. Add `HasGrease` to the