@rsc-kit/mcp 0.16.2 → 0.17.0

package/guides/routing.md

@@ -301,7 +301,13 @@ a stored page, so `usePathname` just answers with the url being rendered.
 
 A **query string** is not — the same route is asked for with `?q=shoes` and
 `?q=hats` — so there is no honest answer at build time, and `useSearchParams`
-throws rather than pretending it is empty.
+throws rather than pretending it is empty. The dev server does the same, on
+purpose: a page has one shape, and a boundary missing in dev is the one the
+build will refuse. Under a `<Suspense>` you wrote, nothing is said. With
+nothing closer than a `loading.tsx`, dev prints one line and shows it at the
+bottom of the page: the whole segment is that fallback until the query
+arrives, and a boundary around the component that reads keeps the rest
+painted.
 
 Wrap it, and the throw becomes the fallback:
 

package/guides/seo-files.md

@@ -0,0 +1,95 @@
+# robots, sitemap and llms.txt
+
+> The files a site describes itself with, from a file beside the root layout — written the way Next writes them, stored at build when they can be.
+
+A crawler asks for `/robots.txt` and `/sitemap.xml` before it reads a page,
+and a model asks for `/llms.txt`. Each comes from a file beside the root
+layout, named for what it answers:
+
+| file | answers | returns |
+| --- | --- | --- |
+| `src/app/robots.ts` | `/robots.txt` | `MetadataRoute.Robots` |
+| `src/app/sitemap.ts` | `/sitemap.xml` | `MetadataRoute.Sitemap` |
+| `src/app/llms.ts` | `/llms.txt` | `MetadataRoute.Llms` |
+| `src/app/llms-full.ts` | `/llms-full.txt` | a string |
+
+The same names and shapes as Next, so a port copies them across unchanged.
+
+```ts title="src/app/robots.ts"
+import type { MetadataRoute } from '@rsc-kit/core/metadata';
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: [
+      { userAgent: '*', allow: '/', disallow: ['/api/', '/studio'] },
+      { userAgent: 'GPTBot', disallow: '/' },
+    ],
+    sitemap: '/sitemap.xml',
+  };
+}
+```
+
+```ts title="src/app/sitemap.ts"
+import type { MetadataRoute } from '@rsc-kit/core/metadata';
+import { db } from '@/lib/db';
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  const posts = await db.post.findMany({ select: { slug: true, updatedAt: true } });
+
+  return [
+    { url: '/', changeFrequency: 'weekly', priority: 1 },
+    { url: '/pricing' },
+    ...posts.map((post) => ({ url: `/blog/${post.slug}`, lastModified: post.updatedAt })),
+  ];
+}
+```
+
+```ts title="src/app/llms.ts"
+import type { MetadataRoute } from '@rsc-kit/core/metadata';
+
+export default function llms(): MetadataRoute.Llms {
+  return {
+    title: 'Remorva',
+    summary: 'Photo restoration: damage repaired and colour restored, in about a minute.',
+    sections: [
+      { title: 'Pages', links: [{ title: 'Pricing', url: '/pricing', description: 'Per restoration, no subscription' }] },
+    ],
+  };
+}
+```
+
+A relative url in any of them is made absolute with the root layout's
+`metadataBase`; without one, a relative url is a build error that says so.
+Any of the three may return a string instead, served as written.
+
+## How they are served
+
+Each file becomes an api route, and that decides the rest. A `sitemap.ts`
+that reads nothing per request — the database counts as nothing, the request
+does not — is answered once at build and stored, like any frozen route, and
+served from the file after. One that reads `cookies()` or awaits
+`connection()` stays dynamic and runs per request. The build's table lists
+them with the other routes and says which.
+
+They run no middleware, on purpose: a guard on the root layout's directory
+would otherwise answer a crawler's request for `robots.txt` with a 401.
+
+The urls are typed like every other route, so `route('/sitemap.xml')` is a
+link the build checks.
+
+## Files as written
+
+A hand-written file beside the root layout is served at the root as it is:
+`robots.txt`, `sitemap.xml` (or `sitemap-posts.xml`), `llms.txt`,
+`llms-full.txt`, and the others a site is asked for there — `humans.txt`,
+`security.txt`, `ads.txt`. In development they are read from `app/`; a build
+copies them beside the client output. A file and a function for the same url
+is a build error naming both.
+
+## Coming from Next
+
+`app/robots.ts` and `app/sitemap.ts` carry across unchanged. `app/llms.txt`
+in Next is usually a `route.ts`; here it is `llms.ts` with a shape, or a file
+as written. Next's `generateSitemaps()` for a sitemap split across files is
+not here: a `sitemap-posts.xml` written by hand, or a `route.ts` under
+`app/sitemap/`, covers it.

package/guides/typed-routes.md

@@ -94,6 +94,15 @@ const nav = [
 Without `satisfies`, TypeScript infers `string` for `href` and you lose the
 check.
 
+## The build checks
+
+`vite build` runs the project's typecheck before it bundles, and stops on an
+error — so a link to a route that does not exist is a failed build, not a 404
+found after deploying. It is the same `tsc --noEmit` the `check` script runs,
+on the same tsconfig, and it costs about a second. `rscKit({ typecheck: false })`
+turns it off; a project with no `tsconfig.json`, or no `typescript`
+installed, is skipped without being asked.
+
 ## If you never run the generator
 
 `.rsc-kit/rsc-routes.d.ts` is written by the build. Without it — or with a

package/guides/view-transitions.md

@@ -17,7 +17,7 @@ badly.
 | a server action's result, put into state | yes |
 | `<Form>` — errors, success, optimistic updates | yes |
 | a streamed `<Suspense>` boundary arriving | yes, React does this on its own |
-| navigating to another page | yes, behind a flag |
+| navigating to another page | yes — the update carries a transition type |
 
 ## What works
 
@@ -62,15 +62,61 @@ throughout, so everything it drives animates the same way.
 
 ## Navigating between pages
 
-Off by default, because it changes how every navigation commits:
+A navigation replaces the segment inside `startTransition`, so a
+`<ViewTransition>` around it animates like any other. What you cannot tell
+from outside is a navigation from the first commit after hydration — the
+boundary taking over the server-rendered page, which animated would be the
+page fading into itself on every load. So a navigation's update carries the
+transition type `rsc-navigation`, and that first commit does not. Key the
+boundary on it:
 
-```ts title="vite.config.ts"
-rscKit({ viewTransitions: true })
+```tsx title="src/app/layout.tsx"
+import { ViewTransition } from 'react';
+
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en">
+      <body className="min-h-full flex flex-col">
+        <ViewTransition default={{ 'rsc-navigation': 'page', default: 'none' }}>
+          <div className="flex flex-1 flex-col">{children}</div>
+        </ViewTransition>
+      </body>
+    </html>
+  );
+}
+```
+
+That is a server component, and it can be: `ViewTransition` is a built-in like
+`Suspense`, which the payload carries as a symbol. No `'use client'` file is
+needed for it.
+
+`default: 'none'` is what makes a first load or a reload never animate. The
+`<div>` matters (here it also carries the body's flex layout, so a `<main>`
+inside still fills the height): React names each top-level element under a boundary and
+animates every one on its own, so a page of five sections becomes five groups,
+each morphing from where it was to where it is now. One wrapper element is one
+snapshot pair — the old page and the new one dissolving into each other, the
+way Inertia's does. A navbar inside the pair cross-fades into itself, which is
+invisible; put the boundary around `<main>` in a nested layout instead when
+you want the navbar left out of it entirely. Leave the wrapper out when you
+want the per-element movement instead.
+
+### Shaping the animation
+
+The pair carries the class you chose, so your CSS shapes it there. The
+browser's default is a 250 ms cross-fade:
+
+```css title="src/app/styles.css"
+/* Shorter, or none at all — the instant swap Inertia does by default. */
+::view-transition-old(.page),
+::view-transition-new(.page) {
+  animation-duration: 120ms;
+}
 ```
 
-A build-time constant rather than a runtime setting, so an app that does not
-ask for it does not carry the boundary at all. What it animates is the segment
-a navigation replaces; what a page does inside itself needs no flag.
+`animation: none` on both is the instant swap, with the transition still in
+place for the shared elements you name yourself (`<ViewTransition name="hero">`
+still morphs).
 
 ## Coming back to a page you were just on
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsc-kit/mcp",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "An MCP server over what an rsc-kit build decided: the routes, why each one is static or not, and what it costs the browser.",
   "type": "module",
   "license": "MIT",