fimo 0.12.0 → 0.12.1

package/assets/skills/fimo-code/references/frameworks/next/app-router.md

@@ -0,0 +1,116 @@
+# Next.js App Router
+
+Preserve the project's existing App Router structure. Fimo does not require a route group, `[locale]` segment, middleware, or a specific rendering mode.
+
+## Root provider
+
+Resolve the locale using the application's existing strategy, fetch labels on the server, and pass the snapshot into the client provider:
+
+```tsx
+import { getLabels } from 'fimo/next';
+import { FimoProvider } from 'fimo/next/client';
+
+export default async function RootLayout({ children }: { children: React.ReactNode }) {
+  const locale = 'en'; // replace with the app's own resolver
+  const labels = await getLabels({ locale });
+
+  return (
+    <html lang={locale}>
+      <body>
+        <FimoProvider labels={labels.snapshot}>{children}</FimoProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+Do not hardcode a locale when the app already resolves one from route params, a cookie, headers/domain, middleware, or an i18n library. Load `references/frameworks/next/locales.md` for those cases.
+
+## Static generation and ISR
+
+Server Components may read generated clients directly. Omit `locale` to use the configured default or bind the application-resolved locale once with `createFimo`:
+
+```tsx
+import { createFimo, RichText, Text } from 'fimo/next';
+import { content } from '@/schemas';
+
+export const revalidate = 60;
+
+export default async function ArticlesPage() {
+  const fimo = createFimo({ content });
+  const page = await fimo.articles.list({ sort: '-publishedAt', limit: 12 });
+
+  return page.items.map((article) => (
+    <article key={`${article.id}:${article.locale}`}>
+      <Text value={article.title} as="h2" />
+      <RichText value={article.body} />
+    </article>
+  ));
+}
+```
+
+`createFimo({ content, locale })` is a typed locale-bound facade over the generated registry. It does not own routing and does not force SSG.
+
+Static builds that read Fimo must receive the real build-time `FIMO_API_URL` (or `NEXT_PUBLIC_FIMO_API_URL`) and default locale environment. Do not switch a route to dynamic rendering merely to hide a missing build environment; choose SSG, ISR, or request-time rendering from the application's intended behavior.
+
+## Request-time rendering
+
+Use normal Next request APIs and pass the resulting locale/query values to Fimo:
+
+```tsx
+import { headers } from 'next/headers';
+import { createFimo, Text } from 'fimo/next';
+import { content } from '@/schemas';
+
+export const dynamic = 'force-dynamic';
+
+export default async function Page() {
+  const locale = (await headers()).get('x-locale') ?? 'en';
+  const fimo = createFimo({ content, locale });
+  const settings = await fimo.settings.get();
+  return <Text value={settings.siteName} as="h1" />;
+}
+```
+
+This example demonstrates request-time rendering, not a recommended locale policy. Preserve the application's actual resolver.
+
+## Client Components
+
+Client Components use the generated `.client` module and `fimo/next/client`:
+
+```tsx
+'use client';
+
+import { Text, useLabels } from 'fimo/next/client';
+import * as Article from '@/schemas/Article.client';
+
+export function FeaturedArticles() {
+  const { t } = useLabels();
+  const { data: page, isLoading } = Article.useList({ where: { featured: true }, limit: 3 });
+
+  if (isLoading || !page) return null;
+  return (
+    <section>
+      <Text value={t('articles.featured')} as="h2" />
+      {page.items.map((article) => (
+        <Text key={article.id} value={article.title} as="h3" />
+      ))}
+    </section>
+  );
+}
+```
+
+Do not add `'use client'` to a page solely because Fimo is present. Keep promise reads and server primitives in Server Components; introduce a Client Component only for browser state, events, or hooks.
+
+## Metadata
+
+Next remains in control through `generateMetadata`. Resolve labels/content on the server and convert tracked strings only where Next expects primitives:
+
+```ts
+export async function generateMetadata() {
+  const labels = await getLabels();
+  return { title: String(labels.t('seo.home.title')) };
+}
+```
+
+Do not expect `FimoProvider` to inject SEO, routes, language, or direction.

package/assets/skills/fimo-code/references/frameworks/next/locales.md

@@ -0,0 +1,59 @@
+# Next.js locale integration
+
+The application resolves locale; Fimo consumes it. Preserve existing route segments, middleware, cookies, domains, headers, redirects, language switchers, and i18n libraries.
+
+## Server reads
+
+Pass the resolved locale to the server facade and label reader:
+
+```ts
+const fimo = createFimo({ content, locale });
+const [page, labels] = await Promise.all([fimo.articles.list({ limit: 12 }), getLabels({ locale })]);
+```
+
+If omitted, both use the configured default locale. Avoid request-global locale state; server code should receive or resolve locale at the request/route boundary.
+
+## Client context
+
+Pass the same locale through `FimoProvider`. A matching label snapshot supplies it automatically:
+
+```tsx
+const labels = await getLabels({ locale });
+return <FimoProvider labels={labels.snapshot}>{children}</FimoProvider>;
+```
+
+When labels are not needed at that boundary, use `<FimoProvider locale={locale}>` so generated client hooks still query the correct locale.
+
+## Existing strategies
+
+- App Router route segment: read `params.locale` in the relevant layout/page.
+- Next locale middleware or library: reuse its resolved locale.
+- Cookie/user preference: read it using Next's request API in request-time code.
+- Domain/header routing: resolve from the incoming request or middleware result.
+- Pages Router i18n: reuse `context.locale` in data functions and `router.locale`/page props on the client.
+- Default-only app: omit locale arguments and let Fimo use `.fimo/config.json#i18n.defaultLocale` (fallback `en`).
+
+With `next-i18next`, keep its routing and translation provider for the strings it owns. Pass the same resolved locale to Fimo; do not replace the library or duplicate its route structure.
+
+Before creating non-default Fimo labels or content variants, confirm that those locales are enabled for the linked Fimo project. `.fimo/config.json` documents the application's locale policy, but `fimo validate` does not currently add project locales.
+
+## Ownership boundary
+
+The application owns:
+
+- which URL maps to which locale;
+- locale detection and switching;
+- redirects and canonical URLs;
+- `<html lang>` and `dir`;
+- localized Next metadata.
+
+Fimo owns:
+
+- configured locale/default-locale policy;
+- localized content variants and labels;
+- client content/label context after receiving the locale;
+- editable source metadata.
+
+Do not add `.fimo/config.json#routes` to a Next project yet. The current route-metadata validator expects React Router's `src/routes.ts`; a first-class Next Studio catalog and preview bridge are separate product work. Do not create a fake `src/routes.ts` to satisfy that check.
+
+Do not introduce `[locale]` segments, cookie routing, or domain routing unless the product request requires that URL strategy. Do not add a second locale provider when the existing one can supply the resolved locale to Fimo.

package/assets/skills/fimo-code/references/frameworks/next/pages-router.md

@@ -0,0 +1,99 @@
+# Next.js Pages Router
+
+Preserve `pages/` or `src/pages/`. Pages Router sends props through JSON serialization, while Fimo read values carry classes/symbol metadata. Use generated `serialize()` and `.client` `hydrate()` at that boundary so rendered values remain editable.
+
+## Provider in `_app`
+
+Pass each page's label snapshot to one provider:
+
+```tsx
+import { FimoProvider, type LabelsSnapshot } from 'fimo/next/client';
+import type { AppProps } from 'next/app';
+
+type FimoPageProps = { fimoLabels: LabelsSnapshot };
+
+export default function App({ Component, pageProps }: AppProps<FimoPageProps>) {
+  return (
+    <FimoProvider labels={pageProps.fimoLabels}>
+      <Component {...pageProps} />
+    </FimoProvider>
+  );
+}
+```
+
+If the application already has providers, compose Fimo with them; do not replace the tree.
+
+## Static generation and ISR
+
+```tsx
+import { createFimo, getLabels } from 'fimo/next';
+import type { GetStaticProps, InferGetStaticPropsType } from 'next';
+
+import { ArticleView } from '@/components/ArticleView';
+import { content } from '@/schemas';
+import * as ArticleClient from '@/schemas/Article.client';
+
+export const getStaticProps = (async ({ locale }) => {
+  const fimo = createFimo({ content, locale });
+  const [page, labels] = await Promise.all([
+    fimo.articles.list({ sort: '-publishedAt', limit: 1 }),
+    getLabels({ locale }),
+  ]);
+  const article = page.items[0];
+  if (!article) return { notFound: true };
+
+  return {
+    props: {
+      article: fimo.articles.serialize(article),
+      fimoLabels: labels.snapshot,
+    },
+    revalidate: 60,
+  };
+}) satisfies GetStaticProps;
+
+export default function Page({ article: serialized }: InferGetStaticPropsType<typeof getStaticProps>) {
+  return <ArticleView article={ArticleClient.hydrate(serialized)} />;
+}
+```
+
+`serialize()` is not an editing workaround or a routing API. It converts source-tracked values to JSON-safe props. `hydrate()` restores those values after Next deserializes them.
+
+## Request-time rendering
+
+```tsx
+import { getLabels } from 'fimo/next';
+import type { GetServerSideProps, InferGetServerSidePropsType } from 'next';
+import * as Article from '@/schemas/Article';
+import * as ArticleClient from '@/schemas/Article.client';
+
+export const getServerSideProps = (async ({ params, locale }) => {
+  const [article, labels] = await Promise.all([
+    Article.getBySlug(String(params?.slug), { locale }),
+    getLabels({ locale }),
+  ]);
+  return article ? { props: { article: Article.serialize(article), fimoLabels: labels.snapshot } } : { notFound: true };
+}) satisfies GetServerSideProps;
+
+export default function ArticlePage({ article }: InferGetServerSidePropsType<typeof getServerSideProps>) {
+  return <ArticleView article={ArticleClient.hydrate(article)} />;
+}
+```
+
+Use the locale/router values Pages Router already supplies. Do not introduce App Router conventions.
+
+## Client hooks
+
+Interactive components import hooks and primitives from the client surfaces:
+
+```tsx
+import { Text, useLabels } from 'fimo/next/client';
+import * as Article from '@/schemas/Article.client';
+
+export function SearchResults() {
+  const { t } = useLabels();
+  const { data } = Article.useList({ limit: 12 });
+  return <Text value={t('search.title')} as="h1" />;
+}
+```
+
+Do not serialize data that never crosses `getStaticProps`/`getServerSideProps`. Do not hydrate plain API JSON or data already returned by a client hook.

package/assets/skills/fimo-code/references/frameworks/next.md

@@ -0,0 +1,116 @@
+# Next.js integration
+
+Use this reference when `fimo describe --json` reports `framework.slug: "nextjs"`, or the project uses an App Router (`app/` or `src/app/`) or Pages Router (`pages/` or `src/pages/`) tree.
+
+Fimo supports schema-first content in both routers across static generation, ISR, request-time rendering, and Client Components. The application owns routes, locale resolution, links, `<html lang/dir>`, and SEO. Fimo receives the resolved locale and supplies content, labels, source metadata, and client editing context.
+
+## Choose the router reference
+
+- `app/` or `src/app/` → `references/frameworks/next/app-router.md`
+- `pages/` or `src/pages/` → `references/frameworks/next/pages-router.md`
+- Existing locale library, middleware, cookies, domains, or locale route segments → also load `references/frameworks/next/locales.md`
+
+When streaming a nested reference from the CLI, preserve its slashes: use `--ref frameworks/next/app-router`, `--ref frameworks/next/pages-router`, or `--ref frameworks/next/locales`. Do not flatten those IDs.
+
+Preserve the router already present. Do not add a second router or convert between App and Pages Router merely to integrate Fimo.
+
+## Client dependency
+
+Server-only Fimo reads need no client data library. If the app uses `FimoProvider`,
+`useLabels`, or generated `.client` hooks, add `@tanstack/react-query` using the
+project's package manager. It is an optional `fimo` peer so server-only projects
+do not install it automatically.
+
+## Runtime URL
+
+Linked projects need the tenant content API in both Next runtimes:
+
+```dotenv
+FIMO_API_URL=https://<tenant-api>
+NEXT_PUBLIC_FIMO_API_URL=https://<tenant-api>
+```
+
+Current `fimo init` and `fimo clone` write these alongside `VITE_API_URL` while
+preserving user-owned values. Never point them at the management API. Keep the
+server variable private; only the public variable is compiled into Client
+Components.
+
+## Generate the content surface
+
+Author `src/schemas/<Uid>.json`, then run `fimo schemas push <Uid>`. The push validates the schema, updates the linked environment, and generates:
+
+```text
+src/schemas/
+├── Article.json
+├── Article.types.ts
+├── Article.ts
+├── Article.client.ts
+└── index.ts
+```
+
+- `<Uid>.ts` is server-safe and exposes promise reads plus `serialize()`.
+- `<Uid>.client.ts` starts with `'use client'`, exposes React Query hooks plus `hydrate()`.
+- `index.ts` exports the generated `content` registry used by `createFimo`.
+- `.types.ts` is an implementation detail; import public types from `<Uid>.ts` or `<Uid>.client.ts`.
+
+Never write the registry by hand and never create alternate `*.schema.json` filenames.
+
+## Server and client boundaries
+
+Server Components, route handlers, `getStaticProps`, and `getServerSideProps` import from `fimo/next` and generated server modules:
+
+```ts
+import { createFimo, getLabels, Text } from 'fimo/next';
+import { content } from '@/schemas';
+
+const fimo = createFimo({ content, locale });
+const [articles, labels] = await Promise.all([
+  fimo.articles.list({ sort: '-publishedAt', limit: 12 }),
+  getLabels({ locale }),
+]);
+```
+
+Client Components import from `fimo/next/client` and generated `.client` modules:
+
+```tsx
+'use client';
+
+import { Text, useLabels } from 'fimo/next/client';
+import * as Article from '@/schemas/Article.client';
+
+export function ArticleList() {
+  const { t } = useLabels();
+  const { data } = Article.useList({ limit: 12 });
+  return <Text value={t('articles.title')} as="h1" />;
+}
+```
+
+Do not import `fimo/next/client` into server-only modules. Do not import React Query hooks from `<Uid>.ts`.
+
+## Provider boundary
+
+Client hooks need one `FimoProvider` near the application root. The server may fetch a label snapshot and pass it across that boundary:
+
+```tsx
+import { getLabels } from 'fimo/next';
+import { FimoProvider } from 'fimo/next/client';
+
+const labels = await getLabels({ locale });
+return <FimoProvider labels={labels.snapshot}>{children}</FimoProvider>;
+```
+
+Passing `locale` without `labels` is valid when only content hooks need context. Passing a matching snapshot supplies both locale and labels. Never teach the unreleased `FimoNextProvider` name; the public component is `FimoProvider`.
+
+## Rendering modes
+
+- Static/ISR: promise reads run during build/revalidation. App Router uses `revalidate`; Pages Router returns `revalidate` from `getStaticProps`.
+- Request-time: App Router uses its normal request APIs/dynamic route policy; Pages Router uses `getServerSideProps`.
+- Client reads: generated `.client` hooks use React Query under `FimoProvider`.
+- Pages Router props must be JSON-safe; use generated `serialize()` before returning props and generated `.client` `hydrate()` in the page.
+- App Router Server Components do not need serialize/hydrate for values that stay on the server-rendered side.
+
+## Greenfield boundary
+
+Use normal schemas, generated clients, Fimo primitives, and labels. Do not use migration-only `Wrapped*` components, private `fetchEntries`, fallback stores, or adopted-site loaders. Migration code may temporarily adapt old source shapes, but those interfaces are not the Next SDK.
+
+Do not add `.fimo/config.json#routes` to a Next project yet. The current route-metadata validator still targets React Router and expects `src/routes.ts`; a first-class Next route catalog and preview bridge are separate product work. Fimo content, labels, locales, and hosting do not require that catalog.

package/assets/skills/fimo-code/references/frameworks/react-router.md

@@ -0,0 +1,295 @@
+# Setup Fimo on React Router 8
+
+This recipe describes the canonical Fimo + React Router framework-mode setup.
+It mirrors what `fimo init` scaffolds today; you can also apply it to an
+existing RR project.
+
+## Prerequisites
+
+- Node 22.22+
+- A Fimo project created via `fimo init` (gives you `projectId`,
+  `organizationId`, and an `apiUrl`).
+
+## Install
+
+```
+pnpm add fimo react react-dom react-router @tanstack/react-query
+pnpm add -D @react-router/dev @react-router/node @tailwindcss/vite tailwindcss vite @types/node @types/react @types/react-dom typescript
+```
+
+## File: `package.json`
+
+```json
+{
+  "name": "__PROJECT_SLUG__",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "react-router dev --port 5173",
+    "build": "react-router build && fimo export-static",
+    "preview": "vite preview --host 0.0.0.0 --port 4173",
+    "typecheck": "tsc --noEmit"
+  }
+}
+```
+
+## File: `vite.config.ts`
+
+```ts
+import { reactRouter } from '@react-router/dev/vite';
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+
+import { fimo } from 'fimo/vite';
+
+export default defineConfig({
+  plugins: [reactRouter(), fimo({ sitemap: true })],
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './src/'),
+    },
+  },
+});
+```
+
+Notes:
+
+- **You** call `reactRouter()`. `fimo/vite` no longer auto-injects it — the
+  user's vite.config owns the framework plugin. This is the library-mode shape.
+- `fimo()` is synchronous; it returns a `PluginOption[]` you drop straight into
+  `plugins`. Don't `await` it or spread it.
+- Do **not** add `fimo({ seo: true })` here. RR handles SEO via the `meta`
+  export (see `src/root.tsx`); the build-time SEO plugin would conflict.
+- `sitemap` is opt-in and off by default; pass `fimo({ sitemap: true })` to emit
+  `sitemap.xml` (the canonical template does this). Omitting the option leaves
+  it off.
+- `fimo({ robots: true })` opt-in to emit `robots.txt`.
+
+## File: `react-router.config.ts`
+
+```ts
+import type { Config } from '@react-router/dev/config';
+
+export default {
+  appDirectory: 'src',
+  ssr: false,
+  // Static-site generation is opt-in. By default this template builds as an
+  // SPA (single index.html shell, client-side routing). To prerender routes at
+  // build time — required for crawler-visible per-route SEO — add this line:
+  //
+  //   import { getFimoPaths } from 'fimo/paths';
+  //   prerender: async () => (await getFimoPaths()).map((p) => p.path),
+  //
+  // `getFimoPaths()` expands dynamic routes (e.g. `/blog/:slug`) by fetching
+  // schema entries from the content API. See `references/frameworks/react-router.md`
+  // in the fimo skill for the full setup pattern.
+  buildDirectory: 'dist',
+} satisfies Config;
+```
+
+**SSG is opt-in now.** Default = SPA (one HTML shell). Add `prerender`
+yourself if you want crawler-visible per-route HTML. The previous
+"prerender everything by default" behavior was a website-builder opinion
+that doesn't fit infrastructure mode — your call which routes to prerender,
+when to render them, and how.
+
+## File: `src/root.tsx`
+
+The explicit `QueryClientProvider` below is the canonical template shape so the
+app can configure query defaults such as `staleTime`. Adopted SPAs can omit it:
+`FimoProviders` reuses an ancestor client when present and supplies a stable
+fallback otherwise.
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { FimoProviders, FimoScripts, loadFimoMetaData, buildFimoMeta, fimoHtmlProps } from 'fimo/react-router';
+import type { MetaFunction } from 'react-router';
+import { Links, Meta, Outlet, Scripts, ScrollRestoration } from 'react-router';
+
+const queryClient = new QueryClient({
+  defaultOptions: { queries: { staleTime: Infinity } },
+});
+
+export async function loader(args: { request: Request }) {
+  return loadFimoMetaData(args);
+}
+
+export const meta: MetaFunction = (args) => buildFimoMeta(args);
+
+export function Layout({ children }: { children: React.ReactNode }) {
+  return (
+    <html {...fimoHtmlProps()}>
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <Meta />
+        <Links />
+        <FimoScripts />
+      </head>
+      <body>
+        {children}
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
+
+export default function AppRoot() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <FimoProviders>
+        <Outlet />
+      </FimoProviders>
+    </QueryClientProvider>
+  );
+}
+```
+
+## File: `src/routes.ts`
+
+```ts
+import type { RouteConfig } from '@react-router/dev/routes';
+import { index } from '@react-router/dev/routes';
+import { fimoRoutes } from 'fimo/react-router/routes';
+
+const routes = [index('./pages/Index.tsx', { id: 'home' })] satisfies RouteConfig;
+
+export default fimoRoutes(routes) satisfies RouteConfig;
+```
+
+Page filenames are your choice; the scaffold uses PascalCase (e.g. `Index.tsx`,
+`Privacy.tsx`).
+
+`fimoRoutes()` is Fimo's React Router helper for path-prefix locales. It is a no-op for single-locale projects and expands concrete locale aliases when `.fimo/config.json#i18n.locales` contains more locales. Custom routers can ignore this helper and pass their own locale to `<FimoProviders locale={locale}>`; see `references/locales.md`.
+
+### Locale-aware navigation
+
+Use `FimoLink` for internal links that should preserve the current locale or deliberately switch it:
+
+```tsx
+import { FimoLink } from 'fimo/react-router';
+
+<FimoLink to="/pricing">Pricing</FimoLink>
+<FimoLink to="/pricing" locale="es">Spanish pricing</FimoLink>
+```
+
+Read the active locale with `useLocale()` when component logic needs the locale list, current canonical route, or document direction:
+
+```tsx
+import { useLocale } from 'fimo/ui';
+
+const { locale, defaultLocale, locales, routePath, dir } = useLocale();
+```
+
+`FimoLink` localizes absolute internal paths using `.fimo/config.json#i18n.routing`; relative, hash, query-only, and external URLs remain unchanged. Copyable route and navigation examples live in `assets/react-router-locales/`.
+
+## File: `src/pages/Index.tsx`
+
+```tsx
+import { Text, useLabels } from 'fimo/ui';
+
+export default function HomePage() {
+  const { t } = useLabels();
+
+  return (
+    <main>
+      <Text value={t('home.hero.title')} as="h1" />
+    </main>
+  );
+}
+```
+
+## File: `.fimo/config.json`
+
+```json
+{
+  "version": "4",
+  "seo": {
+    "title": "__PROJECT_SLUG__",
+    "siteName": "__PROJECT_SLUG__"
+  },
+  "routes": {
+    "home": {
+      "label": "Home",
+      "path": "/"
+    }
+  }
+}
+```
+
+## File: `.fimo/project.json`
+
+```json
+{
+  "projectId": "__PROJECT_ID__",
+  "organizationId": "__ORG_ID__",
+  "apiUrl": "__API_URL__"
+}
+```
+
+Replace the `__PROJECT_ID__` / `__ORG_ID__` / `__API_URL__` sentinels with the
+values from `fimo init`'s output (or `fimo projects info`).
+
+## File: `tsconfig.json`
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "types": ["@react-router/node", "vite/client"],
+    "paths": { "@/*": ["./src/*"] }
+  },
+  "include": ["src", "*.config.ts"]
+}
+```
+
+## File: `index.css`
+
+```css
+@import 'tailwindcss';
+```
+
+(Optional — only if using Tailwind. Tailwind is not required for Fimo to
+function; it just ships with the canonical template.)
+
+## Verify and iterate
+
+Run the app with the project's package-manager `dev` script (`pnpm dev` /
+`npm run dev` / `yarn dev` / `bun dev` — match the lockfile). It serves the site
+on localhost with live reload — this is your iteration loop: edit, see the change,
+repeat with the developer.
+
+`fimo deploy` is on-demand, not part of this loop: run it only when the developer
+wants a hosted preview, a shareable link, or to go live — and only on their signal.
+The dashboard's preview iframe shows the **deployed** app, so it only reflects
+changes after a `fimo deploy` (the local dev server is localhost-only).
+
+## What you don't add
+
+- **No `fimo({ seo: true })`** — React Router's `meta` export covers SEO via
+  `loadFimoMetaData` + `buildFimoMeta`. The build-time SEO plugin is for
+  framework-less Vite + React setups (`references/frameworks/vite-react.md`).
+- **No `<FimoSeo />` component** — not part of the RR setup.
+- **No manual `<script src="overlay-runtime.js">`** — `<FimoScripts />`
+  handles preview-script + overlay loading.
+
+## What to do next
+
+- Add more routes: extend `src/routes.ts`, create matching `src/pages/*.tsx`,
+  add route entries in `.fimo/config.json#routes`.
+- Add a sitemap: pass `fimo({ sitemap: true })` (opt-in, off by default; the
+  canonical template enables it). To customize the base URL, set
+  `.fimo/config.json#seo.url`.
+- Override SEO per route with React Router's `meta` export and the existing `loadFimoMetaData` / `buildFimoMeta` integration in `src/root.tsx`.
+- Look up rendering exports in `references/ui.md` and generated content APIs in `references/content/clients.md`.