fimo 0.12.0 → 0.12.1

package/assets/skills/fimo-code/references/setup-plain-vite.md

@@ -1,229 +1,5 @@
-# Setup Fimo on plain Vite + React
+# Vite + React reference moved
 
-Use this recipe for a Vite + React SPA without React Router framework mode.
-This is also the upgrade path for legacy Fimo v3 projects — v3 was plain Vite,
-so this layout is what those projects look like now.
+Load `references/frameworks/vite-react.md`.
 
-## When to use this vs. React Router
-
-- **Plain Vite (this recipe):** simplest setup; client-side routing via a
-  React Router library router (`BrowserRouter`, no framework-mode SSR/SSG);
-  SEO via build-time HTML rewrite. Per-route SEO that crawlers see requires
-  prerendering (SSG); without it, the SPA serves one `index.html` for every
-  URL and crawlers see only the home SEO.
-- **React Router (`setup-react-router.md`):** framework-mode SSR + per-route
-  SEO via `meta` export; recommended when you want real per-route crawler SEO.
-
-## Prerequisites
-
-- Node 20+
-- A Fimo project created via `fimo init`.
-
-## Install
-
-```
-pnpm add fimo react react-dom react-router @tanstack/react-query
-pnpm add -D vite @vitejs/plugin-react @types/react @types/react-dom typescript
-```
-
-## File: `package.json`
-
-```json
-{
-  "name": "__PROJECT_SLUG__",
-  "version": "0.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "dev": "vite --host 0.0.0.0 --port 5173",
-    "build": "vite build",
-    "preview": "vite preview --host 0.0.0.0 --port 4173",
-    "typecheck": "tsc --noEmit"
-  }
-}
-```
-
-Validate runs automatically during `fimo deploy` and API-side sandbox builds.
-For a purely local build, run `fimo validate` manually first when you need to
-regenerate schemas/forms or check missing labels before `pnpm build`.
-
-## File: `vite.config.ts`
-
-```ts
-import { defineConfig } from 'vite';
-
-import { fimo } from 'fimo/vite';
-
-export default defineConfig(() => ({
-  plugins: fimo({ seo: true }),
-}));
-```
-
-Notes:
-
-- `fimo({ seo: true })` opts in to the build-time SEO plugin
-  (`transformIndexHtml`-based). This is the right tool for plain Vite — there's
-  no framework `meta` export to plug into.
-- Add `fimo({ seo: true, sitemap: true, robots: true })` to also emit
-  `sitemap.xml` and `robots.txt` at build.
-
-## File: `index.html`
-
-```html
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>__PROJECT_SLUG__</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>
-```
-
-The `seo` plugin rewrites `<title>`, og, twitter, canonical tags from
-`.fimo/config.json#seo` at build time. You can leave a placeholder title in
-`index.html`; it'll be replaced.
-
-## File: `src/main.tsx`
-
-`FimoProviders` requires a React Router `<Router>` ancestor (it reads
-`useLocation`/`useNavigate`). It reuses a host app's
-`@tanstack/react-query` client when one exists and supplies a stable fallback
-for adopted SPAs. This recipe still mounts an explicit provider so the app owns
-the shared cache and its configuration:
-
-```tsx
-import { FimoProviders } from 'fimo/react-router';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import React from 'react';
-import { createRoot } from 'react-dom/client';
-import { BrowserRouter } from 'react-router';
-
-import { App } from './App';
-
-const queryClient = new QueryClient();
-
-createRoot(document.getElementById('root')!).render(
-  <React.StrictMode>
-    <QueryClientProvider client={queryClient}>
-      <BrowserRouter>
-        <FimoProviders>
-          <App />
-        </FimoProviders>
-      </BrowserRouter>
-    </QueryClientProvider>
-  </React.StrictMode>
-);
-```
-
-`react-router` and `@tanstack/react-query` are peer dependencies of `fimo`;
-both are in the install command above. `FimoProviders` is exported only from
-the `fimo/react-router` adapter barrel. Keep the explicit QueryClientProvider
-when the app needs custom query defaults or shared cache access; adopted SPAs
-can omit it.
-
-## File: `src/App.tsx`
-
-```tsx
-import { Text, useLabels } from 'fimo/ui';
-
-export function App() {
-  const { t } = useLabels();
-
-  return (
-    <main>
-      <Text value={t('home.hero.title')} as="h1" />
-    </main>
-  );
-}
-```
-
-## File: `.fimo/config.json`
-
-```json
-{
-  "version": "3",
-  "seo": {
-    "title": "__PROJECT_SLUG__",
-    "siteName": "__PROJECT_SLUG__"
-  },
-  "routes": {
-    "home": {
-      "label": "Home",
-      "path": "/"
-    }
-  }
-}
-```
-
-Note: `"version": "3"` marks the legacy plain-Vite (no-RR-framework-mode)
-shape. `fimo()` is version-agnostic — it composes a fixed set of build-time
-plugins from the `seo`/`sitemap`/`robots` options you pass and never reads
-this version field. It also never injects the React Router plugin: in a
-framework-mode project that `reactRouter()` plugin is added by your own
-`vite.config.ts`, not by `fimo/vite`.
-
-## File: `.fimo/project.json`
-
-```json
-{
-  "projectId": "__PROJECT_ID__",
-  "organizationId": "__ORG_ID__",
-  "apiUrl": "__API_URL__"
-}
-```
-
-## 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": ["vite/client"]
-  },
-  "include": ["src", "*.config.ts"]
-}
-```
-
-## 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 (hosted preview / shareable
-link / go live), run only on the developer's signal; the dashboard's preview iframe
-shows the **deployed** app, not the localhost dev server.
-
-## Known limitations vs. React Router
-
-- **Per-route SEO that crawlers see** requires either (a) using React Router
-  framework mode with prerender, (b) a Vite SSG plugin like `vite-plugin-ssg`,
-  or (c) accepting that the crawler sees the home SEO for every URL.
-- **Dashboard "live edit SEO" preview** requires a reload on plain Vite —
-  there's no React-side head-mutation component yet. The static `seo` plugin
-  bakes SEO at build time.
-- **Routing**: `FimoProviders` requires a React Router context, so this recipe
-  wires `BrowserRouter` from `react-router`. You can swap it for another
-  React Router setup (e.g. a `createBrowserRouter` data router with
-  `<RouterProvider>`), but a `<Router>` ancestor is mandatory — the runtime's
-  preview bridge and pageview tracker call `useLocation`/`useNavigate`.
-
-## What to do next
-
-- Add a sitemap: pass `fimo({ seo: true, sitemap: true })` and set
-  `.fimo/config.json#seo.url` to your production base URL.
-- Look up exports: see `references/ui.md`.
-- Use schema content: see `references/content.md`.
+This compatibility pointer keeps older scaffold comments and agent prompts valid while framework guidance lives in one consistent tree.

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

@@ -1,278 +1,5 @@
-# Setup Fimo on React Router 8
+# React Router reference moved
 
-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.
+Load `references/frameworks/react-router.md`.
 
-## 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"
-  }
-}
-```
-
-Validate runs automatically during `fimo deploy` and API-side sandbox builds.
-For a purely local build, run `fimo validate` manually first when you need to
-regenerate schemas/forms or check missing labels before `pnpm build`.
-
-## 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/setup-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`.
-
-## 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 plain-Vite setups (`setup-vite-plain.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: see `references/seo-overrides.md`.
-- Look up an export: see `references/api.md`.
+This compatibility pointer keeps older scaffold comments and agent prompts valid while framework guidance lives in one consistent tree.

package/assets/skills/fimo-code/references/ui.md

@@ -1,90 +1,44 @@
-# UI: components, JSX conventions, code rules
+# React rendering primitives
 
-Everything about writing React code in a Fimo project: the `fimo/ui` component set, app code conventions (routing, components, loading states), and the JSX-side anti-patterns.
+Use Fimo components for source-tracked schema and label values so Studio can identify the field being rendered. Generated reads wrap editable fields with source metadata; pass the whole value to the matching primitive because unwrapping it first removes Studio's edit target.
 
-Load this for **any JSX work** that renders schema content, `t()` output, or media — and any time you're creating components, pages, or routes.
+| Schema/read value                | Component     | Use                                       |
+| -------------------------------- | ------------- | ----------------------------------------- |
+| string/text/date as `FimoString` | `Text`        | editable text and `t()` values            |
+| richtext as `FimoRichText`       | `RichText`    | Tiptap JSONContent                        |
+| media as `FimoMedia`             | `Image`       | schema media images                       |
+| non-schema URL                   | `StaticImage` | decorative/static image URLs              |
+| media as `FimoMedia`             | `Video`       | schema media videos                       |
+| date as `FimoString`             | `Date`        | schema dates                              |
+| boolean as `FimoBoolean`         | `Boolean`     | schema booleans                           |
+| source-tagged plain JSON         | `Json`        | schema JSON                               |
+| number                           | normal JSX    | numbers stay plain; no `Number` primitive |
+| reference                        | target fields | populate before rendering                 |
+| blocks                           | nested fields | render each value with its primitive      |
 
-## `fimo/ui` components
+```tsx
+<Text value={article.title} as="h1" />
+<RichText value={article.body} />
+<Image value={article.cover} width={1200} height={630} />
+<Date value={article.publishedAt} />
+```
 
-Use these to render content-type field values consistently. They carry source metadata for inline editing in the Fimo admin — **always prefer them over raw HTML** when the value comes from a schema or `t()`.
+Pass the tracked value directly. Do not replace `<Text>` with `<h1>{article.title}</h1>`, unwrap media into raw `<img>`, or hand-roll richtext rendering.
 
-| Component       | Use for                                                             | Example                                                       |
-| --------------- | ------------------------------------------------------------------- | ------------------------------------------------------------- |
-| `<Text>`        | Schema text fields + `t()` output                                   | `<Text value={post.title} as="h1" />`                         |
-| `<RichText>`    | Schema `richtext` fields (Tiptap JSONContent)                       | `<RichText value={post.body} className="prose" />`            |
-| `<Image>`       | Schema `media` image fields                                         | `<Image value={post.coverImage} width={1200} height={630} />` |
-| `<StaticImage>` | Non-schema images (hard-coded decorative imagery, hero backgrounds) | `<StaticImage src="/hero.jpg" alt="..." width={1200} />`      |
-| `<Video>`       | Schema `media` video fields                                         | `<Video value={post.heroVideo} />`                            |
-| `<Date>`        | Schema date fields                                                  | `<Date value={post.publishDate} />`                           |
-| `<Boolean>`     | Schema boolean fields                                               | `<Boolean value={product.inStock} />`                         |
-| `<Json>`        | Schema `json` fields                                                | `<Json value={post.metadata} as="pre" />`                     |
-| `` fimo`...` `` | Compose tracked values (mix `t()` + schema text)                    | ``<Text value={fimo`${t('by')} ${post.author}`} />``          |
-| `useLabels()`   | `t('key')` hook                                                     | see `references/labels.md`                                    |
-| `useLocale()`   | Active locale and route locale metadata                             | see `references/locales.md`                                   |
+Use `<StaticImage>` only when the image is deliberately not editor-managed. Use `String(value)` for attributes/third-party APIs that cannot accept a `FimoString`; keep editable visible text in `<Text>`.
 
-### Rules of thumb
+Never construct `FimoString`, `FimoRichText`, `FimoBoolean`, or `FimoMedia` manually. Generated clients and label readers attach the correct source path.
 
-1. **Schema text → `<Text>`**, never `<h1>{post.title}</h1>`.
-2. **Schema media → `<Image>` / `<Video>`**, never `<img src={post.coverImage.url} />`. Provide `width` / `height` when known so Fimo can optimize and reserve layout space.
-3. **Non-schema images** (decorative, hard-coded URLs, generated assets referenced directly) → `<StaticImage>`. Never hand-construct a `FimoMedia` to feed `<Image>`.
-4. **Label text → `<Text value={t('key')} />`**, not `<h1>{t(...)}</h1>`. Label values live in the DB for `i18n.defaultLocale` from `.fimo/config.json` unless a non-default locale is explicitly targeted. See `references/labels.md`.
-5. **Mixed schema + translated text** → the `` fimo`...` `` template literal inside `<Text>`.
-6. **Never hand-roll richtext rendering** — always `<RichText>`. To restyle a node, pass `components={{ heading: ..., link: ..., ... }}`.
-7. **Schema `json` → `<Json>`**, not a hand-rolled `<pre data-fimo-source={getFimoSource(post.metadata)}>{JSON.stringify(post.metadata)}</pre>`. Default renders as a `<span>`; pass `as="pre"` (with a `whitespace-pre-wrap` class) for a formatted block, or a children render function for custom display of specific keys.
+## Imports
 
-## App code conventions
+Choose the framework surface:
 
-The template uses **Vite + React 19 + TypeScript + Tailwind v4 + shadcn/ui + react-router**. Keep generated code consistent.
+- Next Server Components and data functions → `fimo/next`
+- Next Client Components → `fimo/next/client`
+- React Router/Vite client → `fimo/ui`
 
-### Component structure
+Load the framework reference before copying an example. Next server and client imports are deliberately separate so React Query/client code does not leak into server bundles.
 
-- Components small and focused (< 50 lines where possible). Place page-specific components under `src/components/[pageName]/`; shared ones under `src/components/shared/`.
-- Use shadcn/ui primitives from `src/components/ui/` rather than rolling your own.
-- Split files when they grow past ~300 lines.
+## Component ownership
 
-### Routing
-
-- This template uses React Router 8 framework mode (file-based route config in `src/routes.ts`). Use `<FimoLink>` from `fimo/react-router` for locale-aware internal links, especially in projects with more than one configured locale. Use React Router `<Link>` / `<NavLink>` only when you intentionally do not want Fimo's locale behavior. Never raw `<a href="/...">` for internal navigation because it causes full page reloads.
-- Reserve `<a>` for external links, with `target="_blank" rel="noreferrer"`.
-
-### Loading states
-
-- Skeletons > spinners > text placeholders. Never render the literal string "Loading…".
-- Render a skeleton approximating the final layout (title bar, text lines, media aspect box).
-- For images, reserve the aspect ratio with a skeleton — never a placeholder image. Layout must not jump.
-
-### Tailwind v4
-
-- Use utility classes with `cn()` from `@/lib/utils` for conditional classes.
-- Prefer flexbox for 1D layouts and grid for 2D layouts; avoid floats and absolute positioning.
-- Theme via shadcn CSS variables in `src/index.css` (`--background`, `--foreground`, `--primary`, `--accent`, `--ring`, etc.). Use semantic Tailwind classes (`bg-background`, `text-foreground`, `bg-primary`) instead of raw colors so light/dark stays coherent.
-- Tailwind v4 syntax (e.g., `size-*`, container queries) — don't assume v3 conventions.
-
-### Starter replacement
-
-- `src/pages/Index.tsx` is disposable scaffold so a fresh `fimo init` project renders immediately.
-- **On the first real website generation, replace that starter page's copy, layout, and visual system entirely** instead of decorating the existing Fimo-branded design.
-- Reuse only the app shell, route contracts, and legal pages unless the user explicitly wants the starter aesthetic.
-
-### Legal pages
-
-- `src/pages/Privacy.tsx` and `src/pages/Terms.tsx` ship with the template but are not yet wired in `src/routes.ts` — add `route('privacy', './pages/Privacy.tsx')` and `route('terms', './pages/Terms.tsx')` when building a public site. They are required for public sites.
-- Adapt their styling to match the project's visual language and translate their copy via `t()`.
-- Use `privacy@fimo.ai` as the default legal contact email unless the user provides one.
-
-### Branding
-
-- **No Fimo branding** in the generated user-facing site unless the user explicitly asks for it.
-
-## Anti-patterns (JSX-side)
-
-- Raw `<a href>` for internal nav → use `<FimoLink>` for locale-aware paths or React Router `<Link>` / `<NavLink>` only when intentionally bypassing Fimo locale helpers.
-- Raw `<img>` for schema media → use `<Image>` (with width/height).
-- Raw `<pre data-fimo-source={getFimoSource(...)}>` for schema `json` fields → use `<Json>`.
-- Hardcoded strings in JSX → wrap in `t('key')` and add the DB value with `fimo labels set`.
-- Calling `t()` with a dynamic first argument → key must be a string literal.
-- Editing generated `.ts` files under `src/schemas/` or `src/forms/` → regenerate them through `fimo validate` or the matching push command.
-- Writing raw HTML into a `richtext` field → must be Tiptap JSONContent.
-- Hand-constructing a `FimoMedia` object to pass into `<Image>` → use `<StaticImage>` for non-schema images.
-- Decorating `src/pages/Index.tsx` → replace it on first real generation.
-- "Loading…" text placeholder → render a skeleton matching the final layout.
+Fimo does not prescribe component folders, styling, routing, loading UI, or design system. Preserve the application's existing conventions. Use skeletons or its established loading surface for client queries; do not introduce a new UI kit merely to render Fimo values.

package/dist/cli/bundle.json

@@ -1,8 +1,8 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-08-11T09:16:53.645Z",
-  "cliVersion": "0.12.0",
+  "bundledAt": "2026-08-11T13:10:15.212Z",
+  "cliVersion": "0.12.1",
   "external": [
     "oxc-parser",
     "fsevents",