fumapress 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-KMVUUT6X.js

@@ -0,0 +1,10 @@
+// src/config/global.ts
+function defineConfig(config) {
+  return {
+    appDir: config.appDir ?? "./app"
+  };
+}
+
+export {
+  defineConfig
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import "../chunk-MLKGABMK.js";
+
+// src/cli/index.ts
+import { program } from "commander";
+
+// src/vite/build.ts
+import { createBuilder } from "vite";
+async function viteBuild({
+  assetsInlineLimit,
+  clearScreen,
+  config: configFile,
+  emptyOutDir,
+  force,
+  logLevel,
+  minify,
+  mode,
+  sourcemapClient,
+  sourcemapServer
+} = {}) {
+  try {
+    const builder = await createBuilder({
+      mode,
+      configFile,
+      build: {
+        assetsInlineLimit,
+        emptyOutDir,
+        minify
+      },
+      optimizeDeps: { force },
+      clearScreen,
+      logLevel,
+      plugins: [
+        {
+          name: "fumapress:cli-config",
+          configEnvironment(name) {
+            if (sourcemapClient && name === "client") {
+              return {
+                build: {
+                  sourcemap: sourcemapClient
+                }
+              };
+            }
+            if (sourcemapServer && name !== "client") {
+              return {
+                build: {
+                  sourcemap: sourcemapServer
+                }
+              };
+            }
+          }
+        }
+      ]
+    });
+    await builder.buildApp();
+    console.log("Build completed successfully");
+  } catch (error) {
+    console.error("Build failed:", error);
+  }
+}
+
+// src/vite/dev.ts
+import { createServer } from "vite";
+async function dev({
+  clearScreen,
+  config: configFile,
+  cors,
+  force,
+  host,
+  logLevel,
+  mode,
+  open,
+  port,
+  strictPort
+} = {}) {
+  const server = await createServer({
+    mode,
+    configFile,
+    server: { open, cors, host, port, strictPort },
+    optimizeDeps: { force },
+    clearScreen,
+    logLevel
+  });
+  await server.listen();
+  server.printUrls();
+}
+
+// src/cli/index.ts
+program.command("build").action(async () => {
+  await viteBuild();
+});
+program.command("dev").action(async () => {
+  await dev();
+});
+program.command("typegen").action(async () => {
+});
+void program.parseAsync(process.argv);

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { unstable_RSCRouteConfigEntry } from 'react-router';
+
+type RouteConfigParentEntry = Exclude<unstable_RSCRouteConfigEntry, {
+    index: true;
+}>;
+interface RoutesConfig {
+    /**
+     * the root entry
+     */
+    root?: RouteConfigParentEntry;
+    /**
+     * Layout name -> layout entry
+     */
+    layouts?: Record<string, RouteConfigParentEntry>;
+    /**
+     * entry for content pages
+     */
+    page?: unstable_RSCRouteConfigEntry;
+    /**
+     * Add additional entries
+     */
+    extends?: unstable_RSCRouteConfigEntry;
+}
+declare function defineRoutes(config: RoutesConfig): RoutesConfig;
+
+interface FumapressConfig {
+    /**
+     * the directory for app files (relative to project root)
+     *
+     * @defaultValue './app'
+     */
+    appDir: string;
+}
+declare function defineConfig(config: Partial<FumapressConfig>): FumapressConfig;
+
+export { type FumapressConfig, type RoutesConfig, defineConfig, defineRoutes };

package/dist/index.js

@@ -0,0 +1,13 @@
+import {
+  defineConfig
+} from "./chunk-KMVUUT6X.js";
+import "./chunk-MLKGABMK.js";
+
+// src/config/routes.ts
+function defineRoutes(config) {
+  return config;
+}
+export {
+  defineConfig,
+  defineRoutes
+};

package/dist/vite.d.ts

@@ -0,0 +1,5 @@
+import { PluginOption } from 'vite';
+
+declare function fumapress(): PluginOption[];
+
+export { fumapress };

package/dist/vite.js

@@ -0,0 +1,124 @@
+import {
+  defineConfig
+} from "./chunk-KMVUUT6X.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/vite/index.ts
+import react from "@vitejs/plugin-react";
+import rsc from "@vitejs/plugin-rsc";
+import mdx from "fumadocs-mdx/vite";
+import path2 from "path";
+
+// src/config/content.ts
+var content_exports = {};
+__export(content_exports, {
+  default: () => content_default,
+  docs: () => docs
+});
+import { defineConfig as defineConfig2, defineDocs } from "fumadocs-mdx/config";
+var docs = defineDocs({
+  dir: "content"
+});
+var content_default = defineConfig2();
+
+// src/constants.ts
+import { fileURLToPath } from "url";
+import path from "path";
+var baseDir = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../"
+);
+
+// src/lib/get-config.ts
+import { glob } from "tinyglobby";
+var DefaultConfig = defineConfig({});
+var DefaultConfigPatterns = ["fumapress.config.{js,jsx,ts,tsx,md,mdx}"];
+async function findConfigPath() {
+  const paths = await glob(DefaultConfigPatterns);
+  return paths.length > 0 ? paths[0] : null;
+}
+async function loadConfig(configPath) {
+  if (configPath === null) return DefaultConfig;
+  if (configPath === void 0) return loadConfig(await findConfigPath());
+  try {
+    const { default: userConfig } = await import(configPath);
+    return checkConfig(userConfig);
+  } catch (error) {
+    console.error(
+      `Failed to load config from ${configPath}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return DefaultConfig;
+  }
+}
+function checkConfig(loaded) {
+  if (typeof loaded !== "object" || loaded === null) {
+    throw new Error(`Config file ${loaded} must export an object.`);
+  }
+  return loaded;
+}
+
+// src/lib/find-file.ts
+import { access } from "fs/promises";
+async function findFile(paths) {
+  for (const path3 of paths) {
+    try {
+      await access(path3);
+      return path3;
+    } catch {
+      continue;
+    }
+  }
+}
+
+// src/vite/index.ts
+var mdxConfigPath = path2.join(baseDir, "src/config/fumadocs-mdx.ts");
+var extnames = [".js", ".ts", ".jsx", ".tsx"];
+function fumapress() {
+  return [
+    resolveDir(),
+    react(),
+    rsc({
+      entries: {
+        client: path2.join(baseDir, "src/entry.browser.tsx"),
+        rsc: path2.join(baseDir, "src/entry.rsc.tsx"),
+        ssr: path2.join(baseDir, "src/entry.ssr.tsx")
+      }
+    }),
+    mdx(content_exports, { configPath: mdxConfigPath, generateIndexFile: false })
+  ];
+}
+function resolveDir() {
+  let configPath;
+  let config;
+  return {
+    name: "fumapress/resolve-dir",
+    enforce: "pre",
+    async configResolved() {
+      configPath = await findConfigPath();
+      config = await loadConfig(configPath);
+    },
+    resolveId(id) {
+      const appDir = "virtual:app/";
+      if (id.startsWith(appDir)) {
+        const name = path2.join(config.appDir, id.slice(appDir.length));
+        return findFile(extnames.map((ext) => name + ext));
+      }
+    },
+    configureServer(server) {
+      server.watcher.on("change", async (file) => {
+        if (!configPath) return;
+        const fullConfigPath = path2.resolve(configPath);
+        if (fullConfigPath === file) {
+          console.log(`Config changed: ${file}. Restarting dev server.`);
+          await server.restart();
+        }
+      });
+    }
+  };
+}
+export {
+  fumapress
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "fumapress",
+  "version": "0.0.1",
+  "description": "The minimal setup for Fumadocs",
+  "keywords": [
+    "Fumadocs",
+    "Docs"
+  ],
+  "homepage": "https://fumadocs.dev",
+  "repository": "github:fuma-nama/fumadocs",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "type": "module",
+  "files": [
+    "src/*",
+    "dist/*"
+  ],
+  "bin": {
+    "fumapress": "./dist/cli/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@vitejs/plugin-react": "^5.0.3",
+    "@vitejs/plugin-rsc": "^0.4.32",
+    "commander": "^14.0.1",
+    "picocolors": "^1.1.1",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-router": "^7.9.3",
+    "tinyglobby": "^0.2.15",
+    "vite": "^7.1.7",
+    "fumadocs-core": "15.8.2",
+    "fumadocs-mdx": "12.0.1",
+    "fumadocs-ui": "15.8.2"
+  },
+  "devDependencies": {
+    "@types/mdx": "^2.0.13",
+    "@types/node": "^24.5.2",
+    "@types/react": "^19.1.14",
+    "@types/react-dom": "^19.1.9",
+    "typescript": "^5.9.2",
+    "eslint-config-custom": "0.0.0",
+    "tsconfig": "0.0.0"
+  },
+  "peerDependencies": {
+    "@types/react": "*"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { viteBuild } from '../vite/build';
+import { dev } from '../vite/dev';
+
+program.command('build').action(async () => {
+  await viteBuild();
+});
+
+program.command('dev').action(async () => {
+  await dev();
+});
+
+program.command('typegen').action(async () => {
+  // TODO: typegen content shapes
+});
+
+void program.parseAsync(process.argv);

package/src/config/content.ts

@@ -0,0 +1,7 @@
+import { defineConfig, defineDocs } from 'fumadocs-mdx/config';
+
+export const docs = defineDocs({
+  dir: 'content',
+});
+
+export default defineConfig();

package/src/config/global.ts

@@ -0,0 +1,16 @@
+export interface FumapressConfig {
+  /**
+   * the directory for app files (relative to project root)
+   *
+   * @defaultValue './app'
+   */
+  appDir: string;
+}
+
+export function defineConfig(
+  config: Partial<FumapressConfig>,
+): FumapressConfig {
+  return {
+    appDir: config.appDir ?? './app',
+  };
+}

package/src/config/routes.ts

@@ -0,0 +1,29 @@
+import type { unstable_RSCRouteConfigEntry as RSCRouteConfigEntry } from 'react-router';
+
+type RouteConfigParentEntry = Exclude<RSCRouteConfigEntry, { index: true }>;
+
+export interface RoutesConfig {
+  /**
+   * the root entry
+   */
+  root?: RouteConfigParentEntry;
+
+  /**
+   * Layout name -> layout entry
+   */
+  layouts?: Record<string, RouteConfigParentEntry>;
+
+  /**
+   * entry for content pages
+   */
+  page?: RSCRouteConfigEntry;
+
+  /**
+   * Add additional entries
+   */
+  extends?: RSCRouteConfigEntry;
+}
+
+export function defineRoutes(config: RoutesConfig): RoutesConfig {
+  return config;
+}

package/src/constants.ts

@@ -0,0 +1,7 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+export const baseDir = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../',
+);

package/src/entry.browser.tsx

@@ -0,0 +1,52 @@
+import {
+  createFromReadableStream,
+  createTemporaryReferenceSet,
+  encodeReply,
+  setServerCallback,
+} from '@vitejs/plugin-rsc/browser';
+import { startTransition, StrictMode } from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import {
+  type DataRouter,
+  unstable_createCallServer as createCallServer,
+  unstable_getRSCStream as getRSCStream,
+  unstable_RSCHydratedRouter as RSCHydratedRouter,
+  type unstable_RSCPayload as RSCServerPayload,
+} from 'react-router';
+
+// Create and set the callServer function to support post-hydration server actions.
+setServerCallback(
+  createCallServer({
+    createFromReadableStream,
+    createTemporaryReferenceSet,
+    encodeReply,
+  }),
+);
+
+// Get and decode the initial server payload
+createFromReadableStream<RSCServerPayload>(getRSCStream()).then((payload) => {
+  startTransition(async () => {
+    const formState =
+      payload.type === 'render' ? await payload.formState : undefined;
+
+    hydrateRoot(
+      document,
+      <StrictMode>
+        <RSCHydratedRouter
+          createFromReadableStream={createFromReadableStream}
+          payload={payload}
+        />
+      </StrictMode>,
+      {
+        // @ts-expect-error - no types for this yet
+        formState,
+      },
+    );
+  });
+});
+
+if (import.meta.hot) {
+  import.meta.hot.on('rsc:update', () => {
+    (window as unknown as { __router: DataRouter }).__router.revalidate();
+  });
+}

package/src/entry.rsc.tsx

@@ -0,0 +1,46 @@
+import {
+  createTemporaryReferenceSet,
+  decodeAction,
+  decodeFormState,
+  decodeReply,
+  loadServerAction,
+  renderToReadableStream,
+} from '@vitejs/plugin-rsc/rsc';
+import { unstable_matchRSCServerRequest as matchRSCServerRequest } from 'react-router';
+
+import { routes } from './routes/config';
+
+async function fetchServer(request: Request) {
+  return matchRSCServerRequest({
+    // Provide the React Server touchpoints.
+    createTemporaryReferenceSet,
+    decodeAction,
+    decodeFormState,
+    decodeReply,
+    loadServerAction,
+    // The incoming request.
+    request,
+    // The app routes.
+    routes: await routes(),
+    // Encode the match with the React Server implementation.
+    generateResponse(match, options) {
+      return new Response(renderToReadableStream(match.payload, options), {
+        status: match.statusCode,
+        headers: match.headers,
+      });
+    },
+  });
+}
+
+export default async function handler(request: Request) {
+  // Import the generateHTML function from the client environment
+  const ssr = await import.meta.viteRsc.loadModule<
+    typeof import('./entry.ssr')
+  >('ssr', 'index');
+
+  return ssr.generateHTML(request, fetchServer);
+}
+
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}

package/src/entry.ssr.tsx

@@ -0,0 +1,38 @@
+import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr';
+import { renderToReadableStream as renderHTMLToReadableStream } from 'react-dom/server.edge';
+import {
+  unstable_routeRSCServerRequest as routeRSCServerRequest,
+  unstable_RSCStaticRouter as RSCStaticRouter,
+} from 'react-router';
+
+export async function generateHTML(
+  request: Request,
+  fetchServer: (request: Request) => Promise<Response>,
+): Promise<Response> {
+  return await routeRSCServerRequest({
+    // The incoming request.
+    request,
+    // How to call the React Server.
+    fetchServer,
+    // Provide the React Server touchpoints.
+    createFromReadableStream,
+    // Render the router to HTML.
+    async renderHTML(getPayload) {
+      const payload = await getPayload();
+      const formState =
+        payload.type === 'render' ? await payload.formState : undefined;
+
+      const bootstrapScriptContent =
+        await import.meta.viteRsc.loadBootstrapScriptContent('index');
+
+      return await renderHTMLToReadableStream(
+        <RSCStaticRouter getPayload={getPayload} />,
+        {
+          bootstrapScriptContent,
+          // @ts-expect-error - no types for this yet
+          formState,
+        },
+      );
+    },
+  });
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './config/routes';
+export * from './config/global';

package/src/lib/find-file.ts

@@ -0,0 +1,12 @@
+import { access } from 'node:fs/promises';
+
+export async function findFile(paths: string[]): Promise<string | undefined> {
+  for (const path of paths) {
+    try {
+      await access(path);
+      return path;
+    } catch {
+      continue;
+    }
+  }
+}

package/src/lib/get-config.ts

@@ -0,0 +1,42 @@
+import { defineConfig, type FumapressConfig } from '../config/global';
+import { glob } from 'tinyglobby';
+
+const DefaultConfig = defineConfig({});
+
+/**
+ * Default glob patterns for finding config file
+ */
+const DefaultConfigPatterns = ['fumapress.config.{js,jsx,ts,tsx,md,mdx}'];
+
+export async function findConfigPath(): Promise<string | null> {
+  const paths = await glob(DefaultConfigPatterns);
+
+  return paths.length > 0 ? paths[0] : null;
+}
+
+export async function loadConfig(
+  configPath?: string | null,
+): Promise<FumapressConfig> {
+  if (configPath === null) return DefaultConfig;
+  if (configPath === undefined) return loadConfig(await findConfigPath());
+
+  try {
+    const { default: userConfig } = await import(configPath);
+
+    return checkConfig(userConfig);
+  } catch (error) {
+    console.error(
+      `Failed to load config from ${configPath}:`,
+      error instanceof Error ? error.message : String(error),
+    );
+    return DefaultConfig;
+  }
+}
+
+function checkConfig(loaded: unknown): FumapressConfig {
+  if (typeof loaded !== 'object' || loaded === null) {
+    throw new Error(`Config file ${loaded} must export an object.`);
+  }
+
+  return loaded as FumapressConfig;
+}

package/src/lib/layout.shared.tsx

@@ -0,0 +1,9 @@
+import type { BaseLayoutProps } from 'fumadocs-ui/layouts/shared';
+
+export function baseOptions(): BaseLayoutProps {
+  return {
+    nav: {
+      title: 'React Router',
+    },
+  };
+}

package/src/lib/root-layout.tsx

@@ -0,0 +1,26 @@
+'use client';
+import { RootProvider } from 'fumadocs-ui/provider/react-router';
+import type { ReactNode } from 'react';
+import { Links, Meta, Outlet, Scripts, ScrollRestoration } from 'react-router';
+
+export function Layout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <Meta />
+        <Links />
+      </head>
+      <body className="flex flex-col min-h-screen">
+        <RootProvider>{children}</RootProvider>
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
+
+export default function App() {
+  return <Outlet />;
+}

package/src/lib/source.ts

@@ -0,0 +1,35 @@
+/// <reference types="fumadocs-mdx" />
+import { loader } from 'fumadocs-core/source';
+import { fromConfig } from 'fumadocs-mdx/runtime/vite';
+import type * as Config from '../config/content';
+
+export const create = fromConfig<typeof Config>();
+
+export const docs = {
+  doc: create.doc(
+    'docs',
+    './content',
+    import.meta.glob(['./**/*.{mdx,md}'], {
+      base: '/content',
+      query: {
+        collection: 'docs',
+      },
+    }),
+  ),
+  meta: create.meta(
+    'docs',
+    './content',
+    import.meta.glob(['./**/*.{json,yaml}'], {
+      import: 'default',
+      base: '/content',
+      query: {
+        collection: 'docs',
+      },
+    }),
+  ),
+};
+
+export const source = loader({
+  source: await create.sourceAsync(docs.doc, docs.meta),
+  baseUrl: '/docs',
+});

package/src/routes/config.ts

@@ -0,0 +1,28 @@
+import type { unstable_RSCRouteConfig as RSCRouteConfig } from 'react-router';
+
+export async function routes() {
+  const { default: config } = await import('virtual:app/routes');
+  const root = config.root ?? {
+    id: 'root',
+    path: '',
+    lazy: () => import('./root'),
+  };
+
+  return [
+    {
+      ...root,
+      children: [
+        {
+          id: 'home',
+          index: true,
+          lazy: () => import('./home'),
+        },
+        {
+          id: 'docs/*',
+          path: 'docs/*',
+          lazy: () => import('./docs/page'),
+        },
+      ],
+    },
+  ] satisfies RSCRouteConfig;
+}

package/src/routes/docs/page.tsx

@@ -0,0 +1,36 @@
+import { DocsLayout } from 'fumadocs-ui/layouts/docs';
+import {
+  DocsBody,
+  DocsDescription,
+  DocsPage,
+  DocsTitle,
+} from 'fumadocs-ui/page';
+import { source } from '../../lib/source';
+import defaultMdxComponents from 'fumadocs-ui/mdx';
+import { baseOptions } from '../../lib/layout.shared';
+
+export default function ServerComponent({
+  params,
+}: {
+  params: Record<string, string>;
+}) {
+  const slugs = params['*'].split('/').filter((v) => v.length > 0);
+  const page = source.getPage(slugs);
+  if (!page) throw new Response('Not found', { status: 404 });
+
+  const { body: MDX } = page.data;
+
+  return (
+    <DocsLayout {...baseOptions()} tree={source.pageTree}>
+      <DocsPage toc={page.data.toc}>
+        <title>{page.data.title}</title>
+        <meta name="description" content={page.data.description} />
+        <DocsTitle>{page.data.title}</DocsTitle>
+        <DocsDescription>{page.data.description}</DocsDescription>
+        <DocsBody>
+          <MDX components={{ ...defaultMdxComponents }} />
+        </DocsBody>
+      </DocsPage>
+    </DocsLayout>
+  );
+}

package/src/routes/docs/search.ts

@@ -0,0 +1,11 @@
+import { createFromSource } from 'fumadocs-core/search/server';
+import type { LoaderFunctionArgs } from 'react-router';
+import { source } from '../../lib/source';
+
+const server = createFromSource(source, {
+  language: 'english',
+});
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  return server.GET(request);
+}

package/src/routes/home.tsx

@@ -0,0 +1,24 @@
+import { HomeLayout } from 'fumadocs-ui/layouts/home';
+import { Link } from 'react-router';
+import { baseOptions } from '../lib/layout.shared';
+
+export default function ServerComponent() {
+  return (
+    <HomeLayout {...baseOptions()}>
+      <meta name="title" content="Fumapress" />
+      <meta name="description" content="Fumapress" />
+      <div className="p-4 flex flex-col items-center justify-center text-center flex-1">
+        <h1 className="text-xl font-bold mb-2">Fumadocs on React Router.</h1>
+        <p className="text-fd-muted-foreground mb-4">
+          The truly flexible docs framework on React.js.
+        </p>
+        <Link
+          className="text-sm bg-fd-primary text-fd-primary-foreground rounded-full font-medium px-4 py-2.5"
+          to="/docs"
+        >
+          Open Docs
+        </Link>
+      </div>
+    </HomeLayout>
+  );
+}

package/src/routes/root/client.tsx

@@ -0,0 +1,50 @@
+'use client';
+
+import {
+  isRouteErrorResponse,
+  Links,
+  Meta,
+  Scripts,
+  ScrollRestoration,
+  useRouteError,
+} from 'react-router';
+import { RootProvider } from 'fumadocs-ui/provider/react-router';
+
+export function Layout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" type="image/x-icon" href="/favicon.ico" />
+        <Meta />
+        <Links />
+      </head>
+      <body className="flex flex-col min-h-screen">
+        <RootProvider>{children}</RootProvider>
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
+
+export function ErrorBoundary() {
+  const error = useRouteError();
+  let status = 500;
+  let message = 'An unexpected error occurred.';
+
+  if (isRouteErrorResponse(error)) {
+    status = error.status;
+    message = status === 404 ? 'Page not found.' : error.statusText || message;
+  }
+
+  return (
+    <main className="mx-auto max-w-screen-xl px-4 py-8 lg:py-12">
+      <article className="prose mx-auto">
+        <h1>{status}</h1>
+        <p>{message}</p>
+      </article>
+    </main>
+  );
+}

package/src/routes/root/index.tsx

@@ -0,0 +1,12 @@
+import { Outlet } from 'react-router';
+import { Layout as ClientLayout } from './client';
+
+export { ErrorBoundary } from './client';
+
+export function Layout({ children }: { children: React.ReactNode }) {
+  return <ClientLayout>{children}</ClientLayout>;
+}
+
+export default function Component() {
+  return <Outlet />;
+}

package/src/vite/build.ts

@@ -0,0 +1,69 @@
+import { BuildOptions, createBuilder, LogLevel } from 'vite';
+
+export interface ViteBuildOptions {
+  assetsInlineLimit?: number;
+  clearScreen?: boolean;
+  config?: string;
+  emptyOutDir?: boolean;
+  force?: boolean;
+  logLevel?: LogLevel;
+  minify?: BuildOptions['minify'];
+  mode?: string;
+  profile?: boolean;
+  sourcemapClient?: boolean | 'inline' | 'hidden';
+  sourcemapServer?: boolean | 'inline' | 'hidden';
+}
+
+export async function viteBuild({
+  assetsInlineLimit,
+  clearScreen,
+  config: configFile,
+  emptyOutDir,
+  force,
+  logLevel,
+  minify,
+  mode,
+  sourcemapClient,
+  sourcemapServer,
+}: ViteBuildOptions = {}) {
+  try {
+    const builder = await createBuilder({
+      mode,
+      configFile,
+      build: {
+        assetsInlineLimit,
+        emptyOutDir,
+        minify,
+      },
+      optimizeDeps: { force },
+      clearScreen,
+      logLevel,
+      plugins: [
+        {
+          name: 'fumapress:cli-config',
+          configEnvironment(name) {
+            if (sourcemapClient && name === 'client') {
+              return {
+                build: {
+                  sourcemap: sourcemapClient,
+                },
+              };
+            }
+
+            if (sourcemapServer && name !== 'client') {
+              return {
+                build: {
+                  sourcemap: sourcemapServer,
+                },
+              };
+            }
+          },
+        },
+      ],
+    });
+    await builder.buildApp();
+    console.log('Build completed successfully');
+  } catch (error) {
+    console.error('Build failed:', error);
+  }
+}

package/src/vite/dev.ts

@@ -0,0 +1,41 @@
+import type * as Vite from 'vite';
+import { createServer } from 'vite';
+
+export interface ViteDevOptions {
+  clearScreen?: boolean;
+  config?: string;
+  cors?: boolean;
+  force?: boolean;
+  host?: boolean | string;
+  logLevel?: Vite.LogLevel;
+  mode?: string;
+  open?: boolean | string;
+  port?: number;
+  strictPort?: boolean;
+  profile?: boolean;
+}
+
+export async function dev({
+  clearScreen,
+  config: configFile,
+  cors,
+  force,
+  host,
+  logLevel,
+  mode,
+  open,
+  port,
+  strictPort,
+}: ViteDevOptions = {}) {
+  const server = await createServer({
+    mode,
+    configFile,
+    server: { open, cors, host, port, strictPort },
+    optimizeDeps: { force },
+    clearScreen,
+    logLevel,
+  });
+
+  await server.listen();
+  server.printUrls();
+}

package/src/vite/index.ts

@@ -0,0 +1,62 @@
+import type { Plugin, PluginOption } from 'vite';
+import react from '@vitejs/plugin-react';
+import rsc from '@vitejs/plugin-rsc';
+import mdx from 'fumadocs-mdx/vite';
+import path from 'node:path';
+import * as MdxConfig from '../config/content';
+import { baseDir } from '../constants';
+import { findConfigPath, loadConfig } from '../lib/get-config';
+import type { FumapressConfig } from '../config/global';
+import { findFile } from '../lib/find-file';
+
+const mdxConfigPath = path.join(baseDir, 'src/config/fumadocs-mdx.ts');
+const extnames = ['.js', '.ts', '.jsx', '.tsx'];
+
+export function fumapress(): PluginOption[] {
+  return [
+    resolveDir(),
+    react(),
+    rsc({
+      entries: {
+        client: path.join(baseDir, 'src/entry.browser.tsx'),
+        rsc: path.join(baseDir, 'src/entry.rsc.tsx'),
+        ssr: path.join(baseDir, 'src/entry.ssr.tsx'),
+      },
+    }),
+    mdx(MdxConfig, { configPath: mdxConfigPath, generateIndexFile: false }),
+  ];
+}
+
+function resolveDir(): Plugin {
+  let configPath: string | null;
+  let config: FumapressConfig;
+
+  return {
+    name: 'fumapress/resolve-dir',
+    enforce: 'pre',
+    async configResolved() {
+      configPath = await findConfigPath();
+      config = await loadConfig(configPath);
+    },
+    resolveId(id) {
+      const appDir = 'virtual:app/';
+
+      if (id.startsWith(appDir)) {
+        const name = path.join(config.appDir, id.slice(appDir.length));
+
+        return findFile(extnames.map((ext) => name + ext));
+      }
+    },
+    configureServer(server) {
+      server.watcher.on('change', async (file) => {
+        if (!configPath) return;
+
+        const fullConfigPath = path.resolve(configPath);
+        if (fullConfigPath === file) {
+          console.log(`Config changed: ${file}. Restarting dev server.`);
+          await server.restart();
+        }
+      });
+    },
+  };
+}

package/src/vite-env.d.ts

@@ -0,0 +1,6 @@
+declare module 'virtual:app/routes' {
+  import type { RoutesConfig } from './config/routes';
+
+  const routes: RoutesConfig;
+  export = routes;
+}