@catmint/vite 0.0.0-prealpha.1

package/dist/build-entries.js

@@ -0,0 +1,1139 @@
+// @catmint/vite/build-entries — Virtual entry modules for production builds
+//
+// Provides virtual modules consumed by catmint build:
+//
+// Legacy (non-RSC) entries:
+// 1. virtual:catmint/client-entry
+//    Client-side hydration entry with per-route code splitting.
+// 2. virtual:catmint/server-entry
+//    Server-side render function using renderToPipeableStream.
+//
+// RSC entries (three-environment build):
+// 3. virtual:catmint/rsc-entry
+//    RSC environment entry: imports pages+layouts, exports render(url)
+//    that builds element tree and calls renderToReadableStream from
+//    @vitejs/plugin-rsc/rsc to produce an RSC flight stream.
+// 4. virtual:catmint/ssr-rsc-entry
+//    SSR environment entry for RSC mode: exports renderToHtml(rscStream)
+//    that converts flight stream to HTML, plus endpoint handling.
+// 5. virtual:catmint/client-rsc-entry
+//    Client environment entry for RSC mode: reads embedded RSC payload
+//    from the HTML and hydrates via hydrateRoot.
+import { dirname, join, relative, resolve, sep, posix } from "node:path";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { deterministicHash, toPosixPath, CLIENT_NAVIGATION_RUNTIME, } from "./utils.js";
+const CLIENT_ENTRY_ID = "virtual:catmint/client-entry";
+const SERVER_ENTRY_ID = "virtual:catmint/server-entry";
+const RSC_ENTRY_ID = "virtual:catmint/rsc-entry";
+const SSR_RSC_ENTRY_ID = "virtual:catmint/ssr-rsc-entry";
+const CLIENT_RSC_ENTRY_ID = "virtual:catmint/client-rsc-entry";
+const RESOLVED_CLIENT_ID = "\0" + CLIENT_ENTRY_ID;
+const RESOLVED_SERVER_ID = "\0" + SERVER_ENTRY_ID;
+const RESOLVED_RSC_ID = "\0" + RSC_ENTRY_ID;
+const RESOLVED_SSR_RSC_ID = "\0" + SSR_RSC_ENTRY_ID;
+const RESOLVED_CLIENT_RSC_ID = "\0" + CLIENT_RSC_ENTRY_ID;
+/**
+ * Scan the app directory for status page files (e.g. 404.tsx, 500.tsx).
+ *
+ * Recursively walks the app directory looking for files named `{code}.tsx`
+ * (or `.jsx`, `.ts`, `.js`) where `code` is a 3-digit HTTP status code.
+ * Returns them sorted from most specific (deepest) to least specific (root).
+ */
+export function scanStatusPages(appDir) {
+    const STATUS_PAGE_REGEX = /^(\d{3})\.(tsx|jsx|ts|js)$/;
+    const normalizedAppDir = resolve(appDir);
+    const results = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const match = STATUS_PAGE_REGEX.exec(entry);
+            if (match) {
+                const statusCode = parseInt(match[1], 10);
+                // Compute URL prefix: /app/admin/404.tsx → "/admin"
+                const relDir = relative(normalizedAppDir, dir);
+                const urlPrefix = relDir
+                    ? "/" + relDir.split(sep).join(posix.sep)
+                    : "/";
+                results.push({ statusCode, filePath: fullPath, urlPrefix });
+            }
+            try {
+                if (statSync(fullPath).isDirectory()) {
+                    // Skip node_modules and hidden dirs
+                    if (!entry.startsWith(".") && entry !== "node_modules") {
+                        walk(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Skip inaccessible entries
+            }
+        }
+    }
+    walk(normalizedAppDir);
+    // Sort: most specific (longest prefix) first, so resolution picks the nearest
+    results.sort((a, b) => b.urlPrefix.length - a.urlPrefix.length);
+    return results;
+}
+/**
+ * Layout file names to check, in priority order.
+ */
+const LAYOUT_FILENAMES = ["layout.tsx", "layout.jsx", "layout.ts", "layout.js"];
+/**
+ * Walk up from a page file's directory to the app root, collecting
+ * layout files in order from outermost (root) to innermost.
+ */
+function collectLayouts(pageFilePath, appDir) {
+    const layouts = [];
+    let dir = dirname(pageFilePath);
+    const normalizedAppDir = resolve(appDir);
+    while (dir.startsWith(normalizedAppDir)) {
+        for (const filename of LAYOUT_FILENAMES) {
+            const layoutPath = join(dir, filename);
+            if (existsSync(layoutPath)) {
+                layouts.unshift(layoutPath);
+                break;
+            }
+        }
+        if (dir === normalizedAppDir)
+            break;
+        dir = dirname(dir);
+    }
+    return layouts;
+}
+/**
+ * Convert an absolute file path to a Vite-resolvable import path
+ * relative to the project root (e.g. '/app/layout.tsx').
+ */
+function toVitePath(filePath, root) {
+    return "/" + relative(root, filePath).split(sep).join(posix.sep);
+}
+/**
+ * Deduplicate an array preserving order.
+ */
+function unique(arr) {
+    return [...new Set(arr)];
+}
+/**
+ * Create the build entries plugin.
+ *
+ * Must be provided with routes and appDir from the build command.
+ * Only active during production builds (not in dev mode).
+ */
+export function buildEntriesPlugin(options) {
+    const { routes, endpoints, appDir, serverFnFiles, statusPages, softNavigation = true, i18n: i18nConfig = null, } = options;
+    let root = "";
+    return {
+        name: "catmint:build-entries",
+        configResolved(config) {
+            root = config.root;
+        },
+        resolveId(id) {
+            if (id === CLIENT_ENTRY_ID)
+                return RESOLVED_CLIENT_ID;
+            if (id === SERVER_ENTRY_ID)
+                return RESOLVED_SERVER_ID;
+            if (id === RSC_ENTRY_ID)
+                return RESOLVED_RSC_ID;
+            if (id === SSR_RSC_ENTRY_ID)
+                return RESOLVED_SSR_RSC_ID;
+            if (id === CLIENT_RSC_ENTRY_ID)
+                return RESOLVED_CLIENT_RSC_ID;
+            return null;
+        },
+        load(id) {
+            if (id === RESOLVED_CLIENT_ID) {
+                return generateClientEntry(routes, appDir, root, i18nConfig);
+            }
+            if (id === RESOLVED_SERVER_ID) {
+                return generateServerEntry(routes, endpoints, appDir, root, i18nConfig);
+            }
+            if (id === RESOLVED_RSC_ID) {
+                return generateRscEntry(routes, appDir, root, i18nConfig, statusPages ?? []);
+            }
+            if (id === RESOLVED_SSR_RSC_ID) {
+                return generateSsrRscEntry(endpoints, root, serverFnFiles ?? []);
+            }
+            if (id === RESOLVED_CLIENT_RSC_ID) {
+                return generateClientRscEntry(softNavigation);
+            }
+            return null;
+        },
+    };
+}
+/**
+ * Generate the client-side hydration entry module.
+ *
+ * Creates a route map where each route lazily imports its page component.
+ * At runtime, matches the current URL against the route patterns and
+ * hydrates with the correct page + layout chain.
+ *
+ * Layout components are eagerly imported since they're shared across
+ * many routes and needed immediately for hydration.
+ */
+function generateClientEntry(routes, appDir, root, i18nConfig = null) {
+    // Collect all unique layout files across all routes
+    const allLayoutPaths = [];
+    const routeLayoutMap = new Map();
+    for (const route of routes) {
+        const layouts = collectLayouts(route.filePath, appDir);
+        routeLayoutMap.set(route.pattern, layouts);
+        for (const lp of layouts) {
+            if (!allLayoutPaths.includes(lp)) {
+                allLayoutPaths.push(lp);
+            }
+        }
+    }
+    const lines = [
+        "// Auto-generated client entry by catmint build",
+        "// Per-route code splitting with lazy page imports",
+        "",
+        "import { hydrateRoot } from 'react-dom/client'",
+        "import { createElement, lazy, Suspense } from 'react'",
+        "import { AppProviders } from 'catmint/runtime/app-providers'",
+        "",
+    ];
+    // Eagerly import all layouts (shared across routes)
+    for (let i = 0; i < allLayoutPaths.length; i++) {
+        const vitePath = toVitePath(allLayoutPaths[i], root);
+        lines.push(`import Layout_${i} from '${vitePath}'`);
+    }
+    lines.push("");
+    // Create the route map with lazy page imports
+    lines.push("const routeMap = {");
+    for (const route of routes) {
+        const vitePath = toVitePath(route.filePath, root);
+        // Use JSON.stringify for the key to handle patterns with special chars
+        lines.push(`  ${JSON.stringify(route.pattern)}: {`);
+        lines.push(`    page: () => import('${vitePath}'),`);
+        // Map this route's layouts to their indices in allLayoutPaths
+        const layouts = routeLayoutMap.get(route.pattern) ?? [];
+        const layoutIndices = layouts.map((lp) => allLayoutPaths.indexOf(lp));
+        lines.push(`    layouts: [${layoutIndices.map((i) => `Layout_${i}`).join(", ")}],`);
+        lines.push(`  },`);
+    }
+    lines.push("}");
+    lines.push("");
+    // Serialize i18n config for injection into generated code
+    const i18nConfigJson = i18nConfig ? JSON.stringify(i18nConfig) : "null";
+    // Generate the route matching and hydration logic
+    lines.push(`
+// Match the current URL to a route pattern
+function matchRoute(pathname) {
+  // First try exact match
+  if (routeMap[pathname]) return { route: routeMap[pathname], params: {} }
+
+  // Try pattern matching for dynamic routes
+  for (const [pattern, route] of Object.entries(routeMap)) {
+    const params = matchPattern(pattern, pathname)
+    if (params) return { route, params }
+  }
+  return null
+}
+
+// Match a URL pattern like '/user/:id' or '/docs/*slug' against a pathname
+function matchPattern(pattern, pathname) {
+  const patternParts = pattern.split('/').filter(Boolean)
+  const pathParts = pathname.split('/').filter(Boolean)
+
+  const params = {}
+
+  for (let i = 0; i < patternParts.length; i++) {
+    const pp = patternParts[i]
+
+    // Catch-all segment
+    if (pp.startsWith('*')) {
+      const paramName = pp.endsWith('?') ? pp.slice(1, -1) : pp.slice(1)
+      params[paramName] = pathParts.slice(i)
+      return params
+    }
+
+    // Dynamic segment
+    if (pp.startsWith(':')) {
+      if (i >= pathParts.length) return null
+      params[pp.slice(1)] = pathParts[i]
+      continue
+    }
+
+    // Static segment
+    if (i >= pathParts.length || pp !== pathParts[i]) return null
+  }
+
+  // Optional catch-all: pattern has fewer parts and last is optional
+  if (patternParts.length < pathParts.length) return null
+  if (patternParts.length > pathParts.length) {
+    // Check if remaining are optional catch-all
+    const remaining = patternParts[pathParts.length]
+    if (remaining && remaining.startsWith('*') && remaining.endsWith('?')) {
+      const paramName = remaining.slice(1, -1)
+      params[paramName] = []
+      return params
+    }
+    return null
+  }
+
+  return params
+}
+
+// Hydrate the current page
+var __i18nConfig = ${i18nConfigJson}
+var pathname = window.location.pathname
+var matched = matchRoute(pathname)
+
+if (matched) {
+  matched.route.page().then(function(pageMod) {
+    var Page = pageMod.default
+    var layouts = matched.route.layouts
+
+    // Build component tree: outermost layout wraps innermost wraps page
+    var element = createElement(Page, null)
+    for (var i = layouts.length - 1; i >= 0; i--) {
+      element = createElement(layouts[i], null, element)
+    }
+
+    // Wrap with framework providers
+    var providerProps = { pathname: pathname, params: matched.params }
+    if (__i18nConfig) providerProps.i18nConfig = __i18nConfig
+    element = createElement(AppProviders, providerProps, element)
+
+    hydrateRoot(document, element)
+  })
+} else {
+  console.warn('[catmint] No matching route for', pathname)
+}
+`);
+    return lines.join("\n");
+}
+/**
+ * Generate the server-side render entry module (legacy, non-RSC mode).
+ *
+ * Exports a `render(url, options)` function that:
+ * 1. Matches the URL to a route
+ * 2. Loads the page + layout chain
+ * 3. Renders with renderToPipeableStream
+ * 4. Returns a pipeable stream
+ */
+function generateServerEntry(routes, endpoints, appDir, root, i18nConfig = null) {
+    // Collect all unique layout files
+    const allLayoutPaths = [];
+    const routeLayoutMap = new Map();
+    for (const route of routes) {
+        const layouts = collectLayouts(route.filePath, appDir);
+        routeLayoutMap.set(route.pattern, layouts);
+        for (const lp of layouts) {
+            if (!allLayoutPaths.includes(lp)) {
+                allLayoutPaths.push(lp);
+            }
+        }
+    }
+    const lines = [
+        "// Auto-generated server entry by catmint build",
+        "",
+        "import { createElement } from 'react'",
+        "import { renderToPipeableStream } from 'react-dom/server'",
+        "import { AppProviders } from 'catmint/runtime/app-providers'",
+        "",
+    ];
+    // Import all page components
+    for (let i = 0; i < routes.length; i++) {
+        const vitePath = toVitePath(routes[i].filePath, root);
+        lines.push(`import Page_${i} from '${vitePath}'`);
+    }
+    lines.push("");
+    // Import all layout components
+    for (let i = 0; i < allLayoutPaths.length; i++) {
+        const vitePath = toVitePath(allLayoutPaths[i], root);
+        lines.push(`import Layout_${i} from '${vitePath}'`);
+    }
+    lines.push("");
+    // Create the route map
+    lines.push("const routeMap = {");
+    for (let i = 0; i < routes.length; i++) {
+        const route = routes[i];
+        const layouts = routeLayoutMap.get(route.pattern) ?? [];
+        const layoutIndices = layouts.map((lp) => allLayoutPaths.indexOf(lp));
+        lines.push(`  ${JSON.stringify(route.pattern)}: {`);
+        lines.push(`    page: Page_${i},`);
+        lines.push(`    layouts: [${layoutIndices.map((j) => `Layout_${j}`).join(", ")}],`);
+        lines.push(`  },`);
+    }
+    lines.push("}");
+    lines.push("");
+    // Route matching function
+    lines.push(ROUTE_MATCH_CODE);
+    // Serialize i18n config for injection into generated code
+    const i18nConfigJson = i18nConfig ? JSON.stringify(i18nConfig) : "null";
+    // Export the render function
+    lines.push(`
+var __i18nConfig = ${i18nConfigJson}
+
+/**
+ * Render a URL to a pipeable stream.
+ *
+ * @param {string} url - The URL pathname to render
+ * @param {object} [options] - Render options
+ * @param {string[]} [options.bootstrapModules] - Client JS modules to inject as <script> tags
+ * @returns {{ stream: import('react-dom/server').PipeableStream, statusCode: number } | null}
+ */
+export function render(url, options) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  const matched = matchRoute(pathname)
+
+  if (!matched) return null
+
+  const { route, params } = matched
+  const { page: Page, layouts } = route
+
+  // Build component tree: Layout0(Layout1(...(Page)))
+  let element = createElement(Page, null)
+  for (let i = layouts.length - 1; i >= 0; i--) {
+    element = createElement(layouts[i], null, element)
+  }
+
+  // Wrap with framework providers
+  var providerProps = { pathname: pathname, params: params }
+  if (__i18nConfig) providerProps.i18nConfig = __i18nConfig
+  element = createElement(AppProviders, providerProps, element)
+
+  const streamOptions = {}
+  if (options && options.bootstrapModules) {
+    streamOptions.bootstrapModules = options.bootstrapModules
+  }
+
+  const stream = renderToPipeableStream(element, streamOptions)
+
+  return { stream, statusCode: 200, params }
+}
+
+/**
+ * Check if a URL matches any page route.
+ */
+export function hasRoute(url) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  return matchRoute(pathname) !== null
+}
+
+/**
+ * Get all registered route patterns.
+ */
+export function getRoutePatterns() {
+  return Object.keys(routeMap)
+}
+`);
+    // --- Endpoint handling ---
+    if (endpoints.length > 0) {
+        lines.push("");
+        // Import all endpoint modules
+        for (let i = 0; i < endpoints.length; i++) {
+            const vitePath = toVitePath(endpoints[i].filePath, root);
+            lines.push(`import * as Endpoint_${i} from '${vitePath}'`);
+        }
+        lines.push("");
+        // Create the endpoint route map
+        lines.push("const endpointMap = {");
+        for (let i = 0; i < endpoints.length; i++) {
+            const ep = endpoints[i];
+            lines.push(`  ${JSON.stringify(ep.pattern)}: {`);
+            lines.push(`    mod: Endpoint_${i},`);
+            lines.push(`    methods: ${JSON.stringify(ep.methods)},`);
+            lines.push(`  },`);
+        }
+        lines.push("}");
+        lines.push(`
+
+function matchEndpoint(pathname) {
+  if (endpointMap[pathname]) return { endpoint: endpointMap[pathname], params: {} }
+  for (const [pattern, endpoint] of Object.entries(endpointMap)) {
+    const params = matchPattern(pattern, pathname)
+    if (params) return { endpoint, params }
+  }
+  return null
+}
+
+/**
+ * Handle an API endpoint request.
+ */
+export async function handleEndpoint(url, method, request) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  const matched = matchEndpoint(pathname)
+
+  if (!matched) return null
+
+  const { endpoint, params } = matched
+  const mod = endpoint.mod
+
+  const handler = mod[method] || mod.ANY || mod.default
+  if (!handler) return null
+
+  const ctx = { params }
+  const response = await handler(request, ctx)
+  return { response }
+}
+
+/**
+ * Check if a URL matches any endpoint route.
+ */
+export function hasEndpoint(url) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  return matchEndpoint(pathname) !== null
+}
+`);
+    }
+    else {
+        lines.push(`
+export async function handleEndpoint() { return null }
+export function hasEndpoint() { return false }
+`);
+    }
+    return lines.join("\n");
+}
+// --------------------------------------------------------------------------
+// RSC build entry generators
+// --------------------------------------------------------------------------
+/**
+ * Generate the RSC environment entry module.
+ *
+ * This module runs in the RSC environment (with `react-server` resolve conditions).
+ * It imports all pages and layouts, and exports a `render(url)` function that:
+ * 1. Matches the URL to a route
+ * 2. Builds the React element tree (page + layouts)
+ * 3. Calls `renderToReadableStream` from @vitejs/plugin-rsc/rsc
+ * 4. Returns the RSC flight ReadableStream
+ *
+ * The RSC plugin automatically handles "use client" directives, replacing
+ * client components with client reference proxies in this environment.
+ */
+function generateRscEntry(routes, appDir, root, i18nConfig = null, statusPages = []) {
+    const allLayoutPaths = [];
+    const routeLayoutMap = new Map();
+    for (const route of routes) {
+        const layouts = collectLayouts(route.filePath, appDir);
+        routeLayoutMap.set(route.pattern, layouts);
+        for (const lp of layouts) {
+            if (!allLayoutPaths.includes(lp)) {
+                allLayoutPaths.push(lp);
+            }
+        }
+    }
+    const lines = [
+        "// Auto-generated RSC entry by catmint build",
+        "// Runs in the RSC environment with react-server resolve conditions",
+        "",
+        "import { createElement } from 'react'",
+        "import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc'",
+        "import { AppProviders } from 'catmint/runtime/app-providers'",
+        "",
+    ];
+    // Import all page components (default export + full module for generateMetadata)
+    for (let i = 0; i < routes.length; i++) {
+        const vitePath = toVitePath(routes[i].filePath, root);
+        lines.push(`import Page_${i}, * as PageMod_${i} from '${vitePath}'`);
+    }
+    lines.push("");
+    // Import all layout components (default export + full module for generateMetadata)
+    for (let i = 0; i < allLayoutPaths.length; i++) {
+        const vitePath = toVitePath(allLayoutPaths[i], root);
+        lines.push(`import Layout_${i}, * as LayoutMod_${i} from '${vitePath}'`);
+    }
+    lines.push("");
+    // Create the route map (includes module references for generateMetadata)
+    lines.push("const routeMap = {");
+    for (let i = 0; i < routes.length; i++) {
+        const route = routes[i];
+        const layouts = routeLayoutMap.get(route.pattern) ?? [];
+        const layoutIndices = layouts.map((lp) => allLayoutPaths.indexOf(lp));
+        lines.push(`  ${JSON.stringify(route.pattern)}: {`);
+        lines.push(`    page: Page_${i},`);
+        lines.push(`    pageMod: PageMod_${i},`);
+        lines.push(`    layouts: [${layoutIndices.map((j) => `Layout_${j}`).join(", ")}],`);
+        lines.push(`    layoutMods: [${layoutIndices.map((j) => `LayoutMod_${j}`).join(", ")}],`);
+        lines.push(`  },`);
+    }
+    lines.push("}");
+    // Serialize i18n config for injection into generated code
+    const i18nConfigJson = i18nConfig ? JSON.stringify(i18nConfig) : "null";
+    // Route matching + render function (with generateMetadata support)
+    lines.push(`
+${ROUTE_MATCH_CODE}
+
+var __i18nConfig = ${i18nConfigJson}
+
+/**
+ * Merge multiple HeadConfig objects (last wins for title and meta keys).
+ */
+function __mergeHeadConfigs(configs) {
+  var merged = {}
+  var metaMap = new Map()
+  var links = []
+
+  for (var i = 0; i < configs.length; i++) {
+    var config = configs[i]
+    if (config.title !== undefined) merged.title = config.title
+    if (config.meta) {
+      for (var j = 0; j < config.meta.length; j++) {
+        var meta = config.meta[j]
+        var key = meta.name ? 'name:' + meta.name : meta.property ? 'property:' + meta.property : 'content:' + meta.content
+        metaMap.set(key, meta)
+      }
+    }
+    if (config.link) links = links.concat(config.link)
+  }
+
+  if (metaMap.size > 0) merged.meta = Array.from(metaMap.values())
+  if (links.length > 0) merged.link = links
+
+  return merged
+}
+
+/**
+ * Resolve generateMetadata exports from page and layout modules.
+ * Layouts first (outermost to innermost), page last (page wins on conflict).
+ */
+async function __resolveGenerateMetadata(pageMod, layoutMods, params, url) {
+  var urlObj = new URL(url, 'http://localhost')
+  var search = {}
+  for (var [key, value] of urlObj.searchParams.entries()) {
+    search[key] = value
+  }
+
+  var metadataArgs = { params: params || {}, search: search }
+  var configs = []
+
+  for (var i = 0; i < layoutMods.length; i++) {
+    if (typeof layoutMods[i].generateMetadata === 'function') {
+      try {
+        var config = await layoutMods[i].generateMetadata(metadataArgs)
+        if (config && typeof config === 'object') configs.push(config)
+      } catch (e) { /* skip */ }
+    }
+  }
+
+  if (typeof pageMod.generateMetadata === 'function') {
+    try {
+      var config = await pageMod.generateMetadata(metadataArgs)
+      if (config && typeof config === 'object') configs.push(config)
+    } catch (e) { /* skip */ }
+  }
+
+  if (configs.length === 0) return undefined
+  return __mergeHeadConfigs(configs)
+}
+
+/**
+ * Render a URL to an RSC flight ReadableStream with optional head metadata.
+ *
+ * @param {string} url - The URL pathname to render
+ * @returns {Promise<{ stream: ReadableStream<Uint8Array>, headConfig?: object } | null>}
+ */
+export async function render(url) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  const matched = matchRoute(pathname)
+
+  if (!matched) return null
+
+  const { route, params } = matched
+  const { page: Page, pageMod, layouts, layoutMods } = route
+
+  // Resolve generateMetadata from page + layout modules
+  var headConfig = await __resolveGenerateMetadata(pageMod, layoutMods, params, url)
+
+  // Build component tree: Layout0(Layout1(...(Page)))
+  let element = createElement(Page, null)
+  for (let i = layouts.length - 1; i >= 0; i--) {
+    element = createElement(layouts[i], null, element)
+  }
+
+  // Wrap with framework providers (AppProviders is a client reference in RSC env)
+  var providerProps = { pathname: pathname, params: params }
+  if (__i18nConfig) providerProps.i18nConfig = __i18nConfig
+  if (headConfig) providerProps.headConfig = headConfig
+  element = createElement(AppProviders, providerProps, element)
+
+  return { stream: renderToReadableStream(element), headConfig: headConfig }
+}
+
+/**
+ * Check if a URL matches any page route.
+ */
+export function hasRoute(url) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  return matchRoute(pathname) !== null
+}
+`);
+    // --- Status page rendering ---
+    if (statusPages.length > 0) {
+        lines.push("");
+        lines.push("// Status page imports");
+        // Import each status page component (default + module namespace for generateMetadata)
+        for (let i = 0; i < statusPages.length; i++) {
+            const vitePath = toVitePath(statusPages[i].filePath, root);
+            lines.push(`import StatusPage_${i}, * as StatusPageMod_${i} from '${vitePath}'`);
+        }
+        lines.push("");
+        // Collect layouts for each status page
+        const statusPageLayoutMap = new Map();
+        for (let i = 0; i < statusPages.length; i++) {
+            const layouts = collectLayouts(statusPages[i].filePath, appDir);
+            statusPageLayoutMap.set(i, layouts);
+            // Add any new layout paths that aren't already tracked
+            for (const lp of layouts) {
+                if (!allLayoutPaths.includes(lp)) {
+                    const vitePath = toVitePath(lp, root);
+                    lines.push(`import Layout_${allLayoutPaths.length}, * as LayoutMod_${allLayoutPaths.length} from '${vitePath}'`);
+                    allLayoutPaths.push(lp);
+                }
+            }
+        }
+        lines.push("");
+        // Build the status page map: { [statusCode]: [{ urlPrefix, component, componentMod, layouts, layoutMods }] }
+        // Entries are ordered most-specific first (longest urlPrefix first)
+        lines.push("const statusPageMap = {");
+        const byCode = new Map();
+        for (let i = 0; i < statusPages.length; i++) {
+            const sp = statusPages[i];
+            if (!byCode.has(sp.statusCode))
+                byCode.set(sp.statusCode, []);
+            byCode.get(sp.statusCode).push({ index: i, urlPrefix: sp.urlPrefix });
+        }
+        for (const [code, entries] of byCode) {
+            // Already sorted most-specific first from scanStatusPages
+            lines.push(`  ${code}: [`);
+            for (const entry of entries) {
+                const layouts = statusPageLayoutMap.get(entry.index) ?? [];
+                const layoutIndices = layouts.map((lp) => allLayoutPaths.indexOf(lp));
+                lines.push(`    {`);
+                lines.push(`      urlPrefix: ${JSON.stringify(entry.urlPrefix)},`);
+                lines.push(`      component: StatusPage_${entry.index},`);
+                lines.push(`      componentMod: StatusPageMod_${entry.index},`);
+                lines.push(`      layouts: [${layoutIndices.map((j) => `Layout_${j}`).join(", ")}],`);
+                lines.push(`      layoutMods: [${layoutIndices.map((j) => `LayoutMod_${j}`).join(", ")}],`);
+                lines.push(`    },`);
+            }
+            lines.push(`  ],`);
+        }
+        lines.push("}");
+        lines.push(`
+
+/**
+ * Render a status page to an RSC flight ReadableStream with optional head metadata.
+ *
+ * Finds the most specific status page for the given code and pathname,
+ * renders it through the RSC pipeline with layouts and AppProviders.
+ *
+ * @param {number} statusCode - HTTP status code (e.g. 404, 500)
+ * @param {string} pathname - The request pathname (for resolution + provider props)
+ * @param {object} [data] - Optional data to pass as props to the status page
+ * @returns {Promise<{ stream: ReadableStream<Uint8Array>, headConfig?: object } | null>}
+ */
+export async function renderStatusPage(statusCode, pathname, data) {
+  var candidates = statusPageMap[statusCode]
+  if (!candidates || candidates.length === 0) return null
+
+  // Find the most specific status page whose urlPrefix matches the pathname
+  var match = null
+  for (var i = 0; i < candidates.length; i++) {
+    var c = candidates[i]
+    if (c.urlPrefix === "/" || pathname.startsWith(c.urlPrefix + "/") || pathname === c.urlPrefix) {
+      match = c
+      break
+    }
+  }
+  if (!match) return null
+
+  var StatusPage = match.component
+  var layouts = match.layouts
+
+  // Resolve generateMetadata from status page + layout modules
+  var headConfig = await __resolveGenerateMetadata(match.componentMod, match.layoutMods, {}, pathname)
+
+  // Build component tree with status props
+  var statusProps = { status: statusCode }
+  if (data) { for (var k in data) statusProps[k] = data[k] }
+  var element = createElement(StatusPage, statusProps)
+
+  // Wrap with layouts
+  for (var i = layouts.length - 1; i >= 0; i--) {
+    element = createElement(layouts[i], null, element)
+  }
+
+  // Wrap with AppProviders
+  var providerProps = { pathname: pathname, params: {} }
+  if (__i18nConfig) providerProps.i18nConfig = __i18nConfig
+  if (headConfig) providerProps.headConfig = headConfig
+  element = createElement(AppProviders, providerProps, element)
+
+  return { stream: renderToReadableStream(element), headConfig: headConfig }
+}
+`);
+    }
+    else {
+        lines.push(`
+export function renderStatusPage() { return null }
+`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Generate the SSR environment entry for RSC mode.
+ *
+ * This module runs in the SSR environment. It exports:
+ * - `renderToHtml(rscStream)` — takes an RSC flight stream, converts it
+ *   to HTML via react-dom/server, and injects the RSC payload for client hydration
+ * - Endpoint handling functions (handleEndpoint, hasEndpoint)
+ *
+ * The RSC plugin handles "use client" references via its SSR module transforms,
+ * so client components are resolved to their correct chunk references.
+ */
+function generateSsrRscEntry(endpoints, root, serverFnFiles) {
+    const lines = [
+        "// Auto-generated SSR-RSC entry by catmint build",
+        "// Runs in the SSR environment for RSC → HTML conversion",
+        "",
+        "import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr'",
+        "import { renderToReadableStream } from 'react-dom/server.edge'",
+        "import { injectRSCPayload } from 'rsc-html-stream/server'",
+        "import assetsManifest from 'virtual:vite-rsc/assets-manifest'",
+        "",
+    ];
+    // Import server function modules at the top (alongside other imports)
+    if (serverFnFiles.length > 0) {
+        lines.push("// Server function module imports");
+        for (let i = 0; i < serverFnFiles.length; i++) {
+            const vitePath = toVitePath(serverFnFiles[i].filePath, root);
+            lines.push(`import * as ServerFn_${i} from '${vitePath}'`);
+        }
+        lines.push("");
+    }
+    // Export the RSC → HTML rendering function
+    lines.push(`
+/**
+ * Escape a string for safe insertion into an HTML attribute value.
+ */
+function __escapeHtmlAttr(str) {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}
+
+/**
+ * Serialize a HeadConfig into HTML tags for injection into <head>.
+ */
+function __renderHeadToString(config) {
+  var parts = []
+
+  if (config.title !== undefined) {
+    parts.push('<title>' + __escapeHtmlAttr(config.title) + '</title>')
+  }
+
+  if (config.meta) {
+    for (var i = 0; i < config.meta.length; i++) {
+      var meta = config.meta[i]
+      var attrs = []
+      if (meta.name) attrs.push('name="' + __escapeHtmlAttr(meta.name) + '"')
+      if (meta.property) attrs.push('property="' + __escapeHtmlAttr(meta.property) + '"')
+      attrs.push('content="' + __escapeHtmlAttr(meta.content) + '"')
+      parts.push('<meta ' + attrs.join(' ') + '>')
+    }
+  }
+
+  if (config.link) {
+    for (var i = 0; i < config.link.length; i++) {
+      var linkDef = config.link[i]
+      var attrs = [
+        'rel="' + __escapeHtmlAttr(linkDef.rel) + '"',
+        'href="' + __escapeHtmlAttr(linkDef.href) + '"',
+      ]
+      for (var key in linkDef) {
+        if (key !== 'rel' && key !== 'href') {
+          attrs.push(key + '="' + __escapeHtmlAttr(linkDef[key]) + '"')
+        }
+      }
+      parts.push('<link ' + attrs.join(' ') + '>')
+    }
+  }
+
+  return parts.join('\\n')
+}
+
+/**
+ * Strip existing <title> from SSR-rendered HTML so the framework-injected
+ * title from generateMetadata takes precedence.
+ */
+function __stripExistingHeadTags(html, config) {
+  var result = html
+  if (config.title !== undefined) {
+    result = result.replace(/<title>[^<]*<\\/title>/i, '')
+  }
+  return result
+}
+
+/**
+ * Convert an RSC flight stream to an HTML ReadableStream.
+ *
+ * 1. Tees the RSC stream — one fork for SSR, one for browser injection
+ * 2. createFromReadableStream → React VDOM
+ * 3. renderToReadableStream → HTML stream (with bootstrapScriptContent for client JS)
+ * 4. injectRSCPayload → embeds RSC payload as <script> tags in HTML
+ * 5. If headConfig is provided, injects <title>/<meta>/<link> tags before </head>
+ *
+ * The bootstrapScriptContent comes from the RSC assets manifest and tells the
+ * browser to load the client entry JS module for hydration.
+ *
+ * @param {ReadableStream} rscStream - The RSC flight stream
+ * @param {object} [headConfig] - Optional HeadConfig to inject into <head>
+ * @returns {Promise<ReadableStream>} HTML stream with embedded RSC payload
+ */
+export async function renderToHtml(rscStream, headConfig) {
+  const [rscForSsr, rscForBrowser] = rscStream.tee()
+  const root = createFromReadableStream(rscForSsr)
+  const htmlStream = await renderToReadableStream(root, {
+    bootstrapScriptContent: assetsManifest.bootstrapScriptContent,
+  })
+  var finalStream = htmlStream.pipeThrough(injectRSCPayload(rscForBrowser))
+
+  // If headConfig is provided, inject head tags before </head>
+  if (headConfig) {
+    var headTags = __renderHeadToString(headConfig)
+    var decoder = new TextDecoder()
+    var encoder = new TextEncoder()
+    var injected = false
+    var buffer = ''
+
+    finalStream = finalStream.pipeThrough(new TransformStream({
+      transform(chunk, controller) {
+        if (injected) {
+          controller.enqueue(chunk)
+          return
+        }
+        buffer += decoder.decode(chunk, { stream: true })
+        var idx = buffer.indexOf('</head>')
+        if (idx !== -1) {
+          injected = true
+          var before = __stripExistingHeadTags(buffer.slice(0, idx), headConfig)
+          var after = buffer.slice(idx)
+          controller.enqueue(encoder.encode(before + headTags + '\\n' + after))
+          buffer = ''
+        }
+      },
+      flush(controller) {
+        if (!injected && buffer) {
+          controller.enqueue(encoder.encode(buffer + headTags))
+        } else if (buffer) {
+          controller.enqueue(encoder.encode(buffer))
+        }
+      }
+    }))
+  }
+
+  return finalStream
+}
+`);
+    // Route matching function (needed for endpoint matching)
+    lines.push(ROUTE_MATCH_CODE);
+    // --- Endpoint handling ---
+    if (endpoints.length > 0) {
+        lines.push("");
+        for (let i = 0; i < endpoints.length; i++) {
+            const vitePath = toVitePath(endpoints[i].filePath, root);
+            lines.push(`import * as Endpoint_${i} from '${vitePath}'`);
+        }
+        lines.push("");
+        lines.push("const endpointMap = {");
+        for (let i = 0; i < endpoints.length; i++) {
+            const ep = endpoints[i];
+            lines.push(`  ${JSON.stringify(ep.pattern)}: {`);
+            lines.push(`    mod: Endpoint_${i},`);
+            lines.push(`    methods: ${JSON.stringify(ep.methods)},`);
+            lines.push(`  },`);
+        }
+        lines.push("}");
+        lines.push(`
+
+function matchEndpoint(pathname) {
+  if (endpointMap[pathname]) return { endpoint: endpointMap[pathname], params: {} }
+  for (const [pattern, endpoint] of Object.entries(endpointMap)) {
+    const params = matchPattern(pattern, pathname)
+    if (params) return { endpoint, params }
+  }
+  return null
+}
+
+export async function handleEndpoint(url, method, request) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  const matched = matchEndpoint(pathname)
+
+  if (!matched) return null
+
+  const { endpoint, params } = matched
+  const mod = endpoint.mod
+
+  const handler = mod[method] || mod.ANY || mod.default
+  if (!handler) return null
+
+  const ctx = { params }
+  const response = await handler(request, ctx)
+  return { response }
+}
+
+export function hasEndpoint(url) {
+  const pathname = new URL(url, 'http://localhost').pathname
+  return matchEndpoint(pathname) !== null
+}
+`);
+    }
+    else {
+        lines.push(`
+export async function handleEndpoint() { return null }
+export function hasEndpoint() { return false }
+`);
+    }
+    // --- Server function RPC handling ---
+    if (serverFnFiles.length > 0) {
+        lines.push("");
+        // Build the hash → function lookup map
+        lines.push("// Hash → function lookup for server function RPC");
+        lines.push("const serverFnMap = {");
+        for (let i = 0; i < serverFnFiles.length; i++) {
+            const file = serverFnFiles[i];
+            const relativePath = toPosixPath(relative(root, file.filePath));
+            for (const exportName of file.exports) {
+                const hash = deterministicHash(`${relativePath}:${exportName}`);
+                const basePath = relativePath.replace(/\.(fn\.ts|fn\.tsx?)$/, "");
+                const key = `${basePath}/${hash}`;
+                if (exportName === "default") {
+                    lines.push(`  ${JSON.stringify(key)}: ServerFn_${i}.default,`);
+                }
+                else {
+                    lines.push(`  ${JSON.stringify(key)}: ServerFn_${i}.${exportName},`);
+                }
+            }
+        }
+        lines.push("}");
+        lines.push(`
+
+/**
+ * Handle a server function RPC call.
+ *
+ * @param {string} pathname - The URL pathname (e.g. '/__catmint/fn/app/examples/server-fn/actions/c875b945')
+ * @param {unknown} body - The parsed request body (JSON input to the function)
+ * @returns {Promise<{ result: unknown } | null>} The function result, or null if no match
+ */
+export async function handleServerFn(pathname, body) {
+  const prefix = '/__catmint/fn/'
+  if (!pathname.startsWith(prefix)) return null
+
+  const key = pathname.slice(prefix.length)
+  const fn = serverFnMap[key]
+  if (!fn) return null
+  if (typeof fn !== 'function') return null
+
+  const result = await fn(body)
+  return { result }
+}
+`);
+    }
+    else {
+        lines.push(`
+export async function handleServerFn() { return null }
+`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Generate the client entry for RSC mode.
+ *
+ * This module runs in the browser. It:
+ * 1. Reads the embedded RSC payload from the HTML via rsc-html-stream/client
+ * 2. Deserializes it via createFromReadableStream from @vitejs/plugin-rsc/browser
+ * 3. Hydrates the document via hydrateRoot from react-dom/client
+ * 4. If soft navigation is enabled, installs click handlers to intercept
+ *    relative link clicks and perform RSC-powered client-side transitions
+ *
+ * The RSC plugin handles client reference resolution automatically — when
+ * the browser encounters a client reference in the RSC payload, it loads
+ * the appropriate client component chunk.
+ */
+function generateClientRscEntry(softNavigation) {
+    return `// Auto-generated client RSC entry by catmint build
+// Hydrates from embedded RSC payload in the HTML
+
+import { rscStream } from 'rsc-html-stream/client'
+import { createFromReadableStream } from '@vitejs/plugin-rsc/browser'
+import { hydrateRoot } from 'react-dom/client'
+
+let root = null
+
+${CLIENT_NAVIGATION_RUNTIME}
+
+async function hydrate() {
+  const initialRoot = await createFromReadableStream(rscStream)
+  root = hydrateRoot(document, initialRoot)
+}
+
+hydrate().then(function() {
+  if (${softNavigation ? "true" : "false"}) {
+    setupClientNavigation(root)
+  }
+})
+`;
+}
+// --------------------------------------------------------------------------
+// Shared route matching code (used by both RSC and legacy entries)
+// --------------------------------------------------------------------------
+/**
+ * Route matching JavaScript code shared between entry generators.
+ * Extracted to avoid duplication.
+ */
+const ROUTE_MATCH_CODE = `
+function matchRoute(pathname) {
+  if (routeMap[pathname]) return { route: routeMap[pathname], params: {} }
+  for (const [pattern, route] of Object.entries(routeMap)) {
+    const params = matchPattern(pattern, pathname)
+    if (params) return { route, params }
+  }
+  return null
+}
+
+function matchPattern(pattern, pathname) {
+  const patternParts = pattern.split('/').filter(Boolean)
+  const pathParts = pathname.split('/').filter(Boolean)
+  const params = {}
+
+  for (let i = 0; i < patternParts.length; i++) {
+    const pp = patternParts[i]
+    if (pp.startsWith('*')) {
+      const paramName = pp.endsWith('?') ? pp.slice(1, -1) : pp.slice(1)
+      params[paramName] = pathParts.slice(i)
+      return params
+    }
+    if (pp.startsWith(':')) {
+      if (i >= pathParts.length) return null
+      params[pp.slice(1)] = pathParts[i]
+      continue
+    }
+    if (i >= pathParts.length || pp !== pathParts[i]) return null
+  }
+
+  if (patternParts.length < pathParts.length) return null
+  if (patternParts.length > pathParts.length) {
+    const remaining = patternParts[pathParts.length]
+    if (remaining && remaining.startsWith('*') && remaining.endsWith('?')) {
+      const paramName = remaining.slice(1, -1)
+      params[paramName] = []
+      return params
+    }
+    return null
+  }
+
+  return params
+}
+`;
+//# sourceMappingURL=build-entries.js.map