@jay-framework/jay-stack-cli 0.25.0 → 0.25.2

package/dist/{index-l6QVpvnY.js → index-B5oavmfA.js}

@@ -5,18 +5,18 @@ import { JayRouteParamType, scanRoutes, parseRouteSegments } from "@jay-framewor
 import { getLogger } from "@jay-framework/logger";
 import path__default from "node:path";
 import fs from "node:fs/promises";
-import { createRequire } from "node:module";
-import { runLoadParams, scanPlugins, makePassthroughInstanceComponent, DevSlowlyChangingPhase, slowRenderInstances } from "@jay-framework/stack-server-runtime";
+import crypto, { createHash } from "node:crypto";
+import { jayRuntime } from "@jay-framework/vite-plugin";
 import { parseJayFile, JAY_IMPORT_RESOLVER, assignCoordinatesToJayHtml, discoverHeadlessInstances, generateElementHydrateFile, generateServerElementFile } from "@jay-framework/compiler-jay-html";
 import { normalizeActionEntry, checkValidationErrors, RuntimeMode } from "@jay-framework/compiler-shared";
-import crypto, { createHash } from "node:crypto";
+import { parse } from "node-html-parser";
+import { transform } from "esbuild";
+import { createRequire } from "node:module";
+import { runLoadParams, scanPlugins, makePassthroughInstanceComponent, DevSlowlyChangingPhase, slowRenderInstances } from "@jay-framework/stack-server-runtime";
 import * as productionServer from "@jay-framework/production-server";
-import { generateSitemap } from "@jay-framework/production-server";
+import { generateSiteJsonLd, generateSitemap, generateRobotsTxtIfAbsent, generateLlmsTxt } from "@jay-framework/production-server";
 export * from "@jay-framework/production-server";
 import fs__default from "node:fs";
-import { jayRuntime } from "@jay-framework/vite-plugin";
-import { parse } from "node-html-parser";
-import { transform } from "esbuild";
 function isCompilableTypeScriptFile(fileName) {
   return fileName.endsWith(".ts") && !fileName.endsWith(".d.ts") && fileName !== "page.ts";
 }
@@ -40,7 +40,7 @@ async function collectTypeScriptEntries(rootDir, entryPrefix, pages) {
 }
 async function discoverServerEntries(projectRoot, pagesRoot) {
   const logger = getLogger();
-  const routes = await scanRoutes(pagesRoot, {
+  const { routes, errorPages } = await scanRoutes(pagesRoot, {
     jayHtmlFilename: "page.jay-html",
     compFilename: "page.ts"
   });
@@ -52,6 +52,13 @@ async function discoverServerEntries(projectRoot, pagesRoot) {
       pages[entryName] = route.compPath;
     }
   }
+  for (const errorPage of errorPages) {
+    if (errorPage.compPath) {
+      const relativePath = path__default.relative(projectRoot, errorPage.compPath);
+      const entryName = relativePath.replace(/^src\//, "").replace(/\.ts$/, "");
+      pages[entryName] = errorPage.compPath;
+    }
+  }
   const actions = {};
   const actionsDir = path__default.join(projectRoot, "src", "actions");
   try {
@@ -96,9 +103,9 @@ async function discoverServerEntries(projectRoot, pagesRoot) {
   }
   const entries = { init, pages, actions };
   logger.info(
-    `[Build] Discovered: ${Object.keys(pages).length} pages, ${Object.keys(actions).length} actions, init: ${init ? "yes" : "no"}`
+    `[Build] Discovered: ${Object.keys(pages).length} pages, ${Object.keys(actions).length} actions, ${errorPages.length} error pages, init: ${init ? "yes" : "no"}`
   );
-  return { entries, routes };
+  return { entries, routes, errorPages };
 }
 async function buildServerCode(entries, jayOptions, outputDir, projectRoot) {
   const logger = getLogger();
@@ -145,127 +152,314 @@ async function buildServerCode(entries, jayOptions, outputDir, projectRoot) {
   });
   logger.info(`[Build] Server code compiled to ${outputDir}`);
 }
-createRequire(import.meta.url);
-const FRAMEWORK_PACKAGES = [
-  "@jay-framework/stack-client-runtime",
-  "@jay-framework/component",
-  "@jay-framework/reactive",
-  "@jay-framework/runtime",
-  "@jay-framework/view-state-merge",
-  "@jay-framework/fullstack-component"
-];
-async function buildSharedChunks(outputDir, _projectRoot, minify = true, pluginClientPackages = []) {
-  const logger = getLogger();
-  logger.info("[Build] Building shared client chunks...");
+async function compileServerElement(jayHtmlContent, jayHtmlFilename, jayHtmlDir, outputPath, projectRoot, tsConfigFilePath, sourceDir, minifyCss = true) {
+  const jayFile = await parseJayFile(
+    jayHtmlContent,
+    jayHtmlFilename,
+    jayHtmlDir,
+    { relativePath: tsConfigFilePath },
+    JAY_IMPORT_RESOLVER,
+    projectRoot,
+    sourceDir
+  );
+  const parsedJayFile = checkValidationErrors(jayFile);
+  const serverElementCode = checkValidationErrors(generateServerElementFile(parsedJayFile));
+  const outputDir = path__default.dirname(outputPath);
   await fs.mkdir(outputDir, { recursive: true });
-  const allPackages = [...FRAMEWORK_PACKAGES, ...pluginClientPackages];
-  const entries = {};
-  for (const pkg of allPackages) {
-    const varName = pkgToVarName(pkg);
-    const entryPath = path__default.join(outputDir, `_shared_${varName}.js`);
-    await fs.writeFile(entryPath, `export * from '${pkg}';
-`);
-    entries[varName] = entryPath;
+  const tsPath = outputPath.replace(/\.js$/, ".ts");
+  await fs.writeFile(tsPath, serverElementCode, "utf-8");
+  const jayOptions = { tsConfigFilePath };
+  await build({
+    root: projectRoot,
+    publicDir: false,
+    plugins: [jayRuntime(jayOptions)],
+    build: {
+      outDir: outputDir,
+      emptyOutDir: false,
+      minify: false,
+      ssr: true,
+      rollupOptions: {
+        input: { [path__default.basename(outputPath, ".js")]: tsPath },
+        external: [/^node:/, /^@jay-framework\//],
+        output: {
+          entryFileNames: "[name].js",
+          format: "es"
+        }
+      }
+    },
+    logLevel: "warn"
+  });
+  await fs.rm(tsPath, { force: true });
+  let cssFile;
+  let cssImports;
+  const css = parsedJayFile.css;
+  if (css) {
+    cssImports = extractCssImportUrls(css);
+    const cssContent = minifyCss ? (await transform(css, { loader: "css", minify: true })).code : css;
+    const hash = createHash("sha256").update(cssContent).digest("hex").slice(0, 8);
+    const baseName = path__default.basename(outputPath, ".server-element.js");
+    const cssFilename = `${baseName}-${hash}.css`;
+    await fs.writeFile(path__default.join(outputDir, cssFilename), cssContent, "utf-8");
+    cssFile = cssFilename;
   }
-  const dedupePackages = [...allPackages, "@jay-framework/list-compare"];
+  getLogger().info(`[Build] Compiled server element: ${path__default.basename(outputPath)}`);
+  return {
+    cssFile,
+    cssImports,
+    headMeta: parsedJayFile.headMeta,
+    scripts: parsedJayFile.scripts
+  };
+}
+async function compileRouteServerElement(jayHtmlPath, outputPath, projectRoot, tsConfigFilePath, minifyCss = true) {
+  const jayHtmlContent = await fs.readFile(jayHtmlPath, "utf-8");
+  const sourceDir = path__default.dirname(jayHtmlPath);
+  const outputDir = path__default.dirname(outputPath);
+  const jayHtml = resolveJayHtmlPaths(jayHtmlContent, sourceDir, outputDir);
+  return compileServerElement(
+    jayHtml,
+    path__default.basename(jayHtmlPath),
+    outputDir,
+    outputPath,
+    projectRoot,
+    tsConfigFilePath,
+    sourceDir,
+    minifyCss
+  );
+}
+async function compileRouteHydrateScript(jayHtmlPath, outputDir, projectRoot, tsConfigFilePath, minify = true) {
+  const jayHtmlContent = await fs.readFile(jayHtmlPath, "utf-8");
+  const sourceDir = path__default.dirname(jayHtmlPath);
+  const jayHtml = resolveJayHtmlPaths(jayHtmlContent, sourceDir, outputDir);
+  const jayFile = await parseJayFile(
+    jayHtml,
+    path__default.basename(jayHtmlPath),
+    outputDir,
+    { relativePath: tsConfigFilePath },
+    JAY_IMPORT_RESOLVER,
+    projectRoot,
+    sourceDir
+  );
+  const parsedJayFile = checkValidationErrors(jayFile);
+  const hydrateCode = checkValidationErrors(
+    generateElementHydrateFile(parsedJayFile, RuntimeMode.MainTrusted)
+  );
+  await fs.mkdir(outputDir, { recursive: true });
+  const tsPath = path__default.join(outputDir, "route.hydrate.ts");
+  await fs.writeFile(tsPath, hydrateCode, "utf-8");
+  const jayOptions = { tsConfigFilePath };
   await build({
+    root: projectRoot,
     publicDir: false,
+    plugins: [...jayStackCompiler(jayOptions)],
     build: {
       outDir: outputDir,
-      emptyOutDir: true,
+      emptyOutDir: false,
       minify,
-      manifest: "vite-manifest.json",
+      manifest: "route-hydrate-manifest.json",
       rollupOptions: {
-        input: entries,
+        input: { "route.hydrate": tsPath },
+        external: (id) => id.startsWith("@jay-framework/"),
         output: {
           entryFileNames: "[name]-[hash].js",
-          chunkFileNames: "[name]-[hash].js",
           format: "es"
         },
         preserveEntrySignatures: "exports-only"
       }
     },
-    resolve: {
-      dedupe: dedupePackages
-    },
     logLevel: "warn"
   });
-  for (const pkg of allPackages) {
-    const varName = pkgToVarName(pkg);
-    await fs.rm(path__default.join(outputDir, `_shared_${varName}.js`), { force: true });
-  }
-  const manifest = await parseViteManifest(outputDir, allPackages);
-  logger.info(`[Build] Shared chunks built: ${Object.keys(manifest).length} entries`);
-  return { manifest, outputDir };
-}
-function pkgToVarName(pkg) {
-  return pkg.replace("@jay-framework/", "").replace(/[/-]/g, "_");
+  await fs.rm(tsPath, { force: true });
+  const manifestPath = path__default.join(outputDir, "route-hydrate-manifest.json");
+  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
+  await fs.rm(manifestPath, { force: true });
+  const entryKey = Object.keys(manifest).find((k) => manifest[k].isEntry);
+  if (!entryKey) throw new Error("No entry in route hydrate manifest");
+  const jsFile = manifest[entryKey].file;
+  getLogger().info(`[Build] Compiled route hydrate script: ${jsFile}`);
+  return { jsFile };
 }
-async function parseViteManifest(outputDir, packages) {
-  const viteManifestPath = path__default.join(outputDir, "vite-manifest.json");
-  const raw = JSON.parse(await fs.readFile(viteManifestPath, "utf-8"));
-  const varNameToPackage = /* @__PURE__ */ new Map();
-  for (const pkg of packages) {
-    varNameToPackage.set(pkgToVarName(pkg), pkg);
+function resolveJayHtmlPaths(html, sourceDir, targetDir) {
+  const root = parse(html, {
+    comment: true,
+    blockTextElements: { script: true, style: true }
+  });
+  const rewrite = (el, attr) => {
+    const val = el.getAttribute(attr);
+    if (val && (val.startsWith("./") || val.startsWith("../"))) {
+      const abs = path__default.resolve(sourceDir, val);
+      let rel = path__default.relative(targetDir, abs);
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      el.setAttribute(attr, rel);
+    }
+  };
+  for (const el of root.querySelectorAll('script[type="application/jay-data"]')) {
+    rewrite(el, "contract");
   }
-  const manifest = {};
-  for (const [, entry] of Object.entries(raw)) {
-    if (!entry.isEntry) continue;
-    const outputBase = path__default.basename(entry.file, ".js");
-    for (const [varName, pkg] of varNameToPackage) {
-      if (outputBase.startsWith(varName)) {
-        manifest[pkg] = entry.file;
-        break;
-      }
+  for (const el of root.querySelectorAll('script[type="application/jay-headless"]')) {
+    rewrite(el, "src");
+    rewrite(el, "contract");
+  }
+  for (const el of root.querySelectorAll('script[type="application/jay-headfull"]')) {
+    rewrite(el, "src");
+    rewrite(el, "contract");
+  }
+  for (const el of root.querySelectorAll('link[rel="stylesheet"]')) {
+    rewrite(el, "href");
+  }
+  return root.toString();
+}
+function extractCssImportUrls(css) {
+  const imports = [];
+  const re = /@import\s*(?:url\(\s*['"]?([^'")]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
+  let match;
+  while ((match = re.exec(css)) !== null) {
+    const url = match[1] || match[2];
+    if (url.startsWith("https://")) {
+      imports.push(url);
     }
   }
-  const sharedManifestPath = path__default.join(outputDir, "shared-manifest.json");
-  await fs.writeFile(sharedManifestPath, JSON.stringify(manifest, null, 2));
-  await fs.rm(viteManifestPath, { force: true });
-  return manifest;
+  return imports;
 }
-const require$1 = createRequire(import.meta.url);
-async function loadProductionPageParts(route, pageModule, jayHtmlContent, projectRoot, tsConfigFilePath, serverBuildDir) {
-  const exportName = route.componentExport || "page";
-  const compDefinition = pageModule[exportName] ?? pageModule.default;
-  const parts = compDefinition ? [{ compDefinition, clientImport: "", clientPart: "" }] : [];
-  const dirName = path__default.dirname(route.jayHtmlPath);
-  const fileName = path__default.basename(route.jayHtmlPath);
-  const jayHtmlWithValidations = await parseJayFile(
-    jayHtmlContent,
-    fileName,
-    dirName,
-    { relativePath: tsConfigFilePath },
-    JAY_IMPORT_RESOLVER,
-    projectRoot
-  );
-  const jayHtml = checkValidationErrors(jayHtmlWithValidations);
-  const headlessInstanceComponents = [];
-  const keyedPartModules = [];
-  const headlessModuleInfos = [];
-  const headlessImports = jayHtml.headlessImports ?? [];
-  getLogger().info(
-    `[Build] headlessImports for ${fileName}: ${headlessImports.length}, keys: ${Object.keys(jayHtml).join(",")}`
-  );
-  for (const headlessImport of headlessImports) {
-    const module = headlessImport.codeLink.module;
-    const name = headlessImport.codeLink.names[0].name;
-    const isLocalModule = module[0] === "." || module[0] === "/";
-    let modulePath;
-    if (isLocalModule) {
-      const sourcePath = path__default.resolve(dirName, module);
-      if (serverBuildDir) {
-        const relativeToSrc = path__default.relative(path__default.join(projectRoot, "src"), sourcePath);
-        let compiledPath = path__default.join(serverBuildDir, relativeToSrc);
-        compiledPath = compiledPath.replace(/\.ts$/, ".js");
-        if (!compiledPath.endsWith(".js")) {
-          const indexPath = path__default.join(compiledPath, "index.js");
-          try {
-            await fs.access(indexPath);
-            compiledPath = indexPath;
-          } catch {
-            compiledPath += ".js";
-          }
+async function generateRouteHydrationEntry(options) {
+  const {
+    hydrateImport,
+    pageModulePath,
+    pageExportName = "page",
+    trackByMap,
+    outputPath,
+    keyedParts = [],
+    clientInits = []
+  } = options;
+  const partImports = keyedParts.map((p, i) => `import { ${p.exportName} as keyedPart${i} } from '${p.modulePath}';`).join("\n");
+  const hasPageModule = pageModulePath && pageExportName;
+  const pagePartExpr = hasPageModule ? `pagePart && pagePart.comp ? { comp: pagePart.comp, contextMarkers: pagePart.contexts || [] } : null` : `null`;
+  const partsArray = [
+    pagePartExpr,
+    ...keyedParts.map(
+      (p, i) => `keyedPart${i} && keyedPart${i}.comp ? { comp: keyedPart${i}.comp, contextMarkers: keyedPart${i}.contexts || [], key: '${p.key}' } : null`
+    )
+  ];
+  const pageImport = hasPageModule ? `import { ${pageExportName} as pagePart } from '${pageModulePath}';` : "";
+  const initImports = clientInits.map((ci, i) => `import { ${ci.exportName} as clientInit${i} } from '${ci.modulePath}';`).join("\n");
+  const initCalls = clientInits.map(
+    (ci, i) => `    if (clientInit${i}?._clientInit) await clientInit${i}._clientInit(clientInitData['${ci.key}'] || {});`
+  ).join("\n");
+  const code = `import { hydrateCompositeJayComponent } from '@jay-framework/stack-client-runtime';
+import { deepMergeViewStates } from '@jay-framework/view-state-merge';
+import { hydrate } from '${hydrateImport}';
+${pageImport}
+${partImports}
+${initImports}
+
+const trackByMap = ${JSON.stringify(trackByMap)};
+
+export async function init(slowViewState, fastViewState, fastCarryForward, clientInitData) {
+${initCalls}
+    const viewState = deepMergeViewStates(slowViewState, fastViewState, trackByMap);
+    const target = document.getElementById('target');
+    const rootElement = target.firstElementChild;
+    const parts = [
+        ${partsArray.join(",\n        ")}
+    ].filter(p => p !== null);
+    const pageComp = hydrateCompositeJayComponent(
+        hydrate, viewState, fastCarryForward,
+        parts, trackByMap, rootElement
+    );
+    return pageComp({});
+}
+`;
+  const outputDir = path__default.dirname(outputPath);
+  await fs.mkdir(outputDir, { recursive: true });
+  await fs.writeFile(outputPath, code, "utf-8");
+  getLogger().info(`[Build] Generated route hydration entry: ${path__default.basename(outputPath)}`);
+}
+async function buildInstanceClient(hydrateEntryPath, instanceId, outputDir, projectRoot, jayOptions, minify = true, pagesRoot, buildDir) {
+  const logger = getLogger();
+  await fs.mkdir(outputDir, { recursive: true });
+  const fullJayOptions = {
+    ...jayOptions,
+    ...pagesRoot && buildDir ? { pagesRoot, buildFolder: buildDir } : {}
+  };
+  await build({
+    root: projectRoot,
+    publicDir: false,
+    plugins: [...jayStackCompiler(fullJayOptions)],
+    build: {
+      outDir: outputDir,
+      emptyOutDir: false,
+      minify,
+      manifest: `${instanceId}-manifest.json`,
+      rollupOptions: {
+        input: { [instanceId]: hydrateEntryPath },
+        external: (id) => id.startsWith("@jay-framework/") || id === "jay-route-hydrate",
+        output: {
+          entryFileNames: "[name]-[hash].js",
+          chunkFileNames: "chunks/[name]-[hash].js",
+          assetFileNames: "[name]-[hash].[ext]",
+          format: "es"
+        },
+        preserveEntrySignatures: "exports-only"
+      }
+    },
+    logLevel: "warn"
+  });
+  const manifestPath = path__default.join(outputDir, `${instanceId}-manifest.json`);
+  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
+  await fs.rm(manifestPath, { force: true });
+  const entryKey = Object.keys(manifest).find((k) => manifest[k].isEntry);
+  if (!entryKey) {
+    throw new Error(`No entry found in instance build manifest for ${instanceId}`);
+  }
+  const entry = manifest[entryKey];
+  const result = {
+    jsFile: entry.file,
+    cssFile: entry.css?.[0]
+  };
+  logger.info(`[Build] Client bundle: ${result.jsFile}`);
+  return result;
+}
+const require$1 = createRequire(import.meta.url);
+async function loadProductionPageParts(route, pageModule, jayHtmlContent, projectRoot, tsConfigFilePath, serverBuildDir) {
+  const exportName = route.componentExport || "page";
+  const compDefinition = pageModule[exportName] ?? pageModule.default;
+  const parts = compDefinition ? [{ compDefinition, clientImport: "", clientPart: "" }] : [];
+  const dirName = path__default.dirname(route.jayHtmlPath);
+  const fileName = path__default.basename(route.jayHtmlPath);
+  const jayHtmlWithValidations = await parseJayFile(
+    jayHtmlContent,
+    fileName,
+    dirName,
+    { relativePath: tsConfigFilePath },
+    JAY_IMPORT_RESOLVER,
+    projectRoot
+  );
+  const jayHtml = checkValidationErrors(jayHtmlWithValidations);
+  const headlessInstanceComponents = [];
+  const keyedPartModules = [];
+  const headlessModuleInfos = [];
+  const headlessImports = jayHtml.headlessImports ?? [];
+  getLogger().info(
+    `[Build] headlessImports for ${fileName}: ${headlessImports.length}, keys: ${Object.keys(jayHtml).join(",")}`
+  );
+  for (const headlessImport of headlessImports) {
+    const module = headlessImport.codeLink.module;
+    const name = headlessImport.codeLink.names[0].name;
+    const isLocalModule = module[0] === "." || module[0] === "/";
+    let modulePath;
+    if (isLocalModule) {
+      const sourcePath = path__default.resolve(dirName, module);
+      if (serverBuildDir) {
+        const relativeToSrc = path__default.relative(path__default.join(projectRoot, "src"), sourcePath);
+        let compiledPath = path__default.join(serverBuildDir, relativeToSrc);
+        compiledPath = compiledPath.replace(/\.ts$/, ".js");
+        if (!compiledPath.endsWith(".js")) {
+          const indexPath = path__default.join(compiledPath, "index.js");
+          try {
+            await fs.access(indexPath);
+            compiledPath = indexPath;
+          } catch {
+            compiledPath += ".js";
+          }
         }
         modulePath = compiledPath;
       } else {
@@ -411,664 +605,622 @@ function buildPagePartsConfig(pageParts, pageServerModule, pageExportName, build
     }))
   };
 }
-function hashParams(params, suffix) {
-  const sorted = Object.keys(params).sort().reduce(
-    (acc, key) => {
-      acc[key] = params[key];
-      return acc;
-    },
-    {}
-  );
-  const json = JSON.stringify(sorted);
-  if (json === "{}" && !suffix) return "";
-  const input = suffix ? json + ":" + suffix : json;
-  return "_" + crypto.createHash("md5").update(input).digest("hex").substring(0, 8);
-}
-async function buildInstance(route, params, pageModule, ctx, routeServerElementPath, routeCssPath, routeHydratePath, routeClientBundlePath) {
+async function buildErrorPages(errorPages, ctx, projectRoot, pagesRoot, tsConfigFilePath, minify, sharedManifest, buildDir) {
   const logger = getLogger();
-  const routeDir = route.rawRoute.replace(/^\//, "") || "index";
-  const paramHash = hashParams(params, ctx.rebuildSuffix);
-  const instanceId = `page${paramHash}`;
-  const backendInstanceDir = path__default.join(ctx.backendDir, "pre-rendered", routeDir);
-  const frontendInstanceDir = path__default.join(ctx.frontendDir, "pages", routeDir);
-  await fs.mkdir(backendInstanceDir, { recursive: true });
-  await fs.mkdir(frontendInstanceDir, { recursive: true });
-  const jayHtmlContent = await fs.readFile(route.jayHtmlPath, "utf-8");
-  path__default.dirname(route.jayHtmlPath);
-  const serverBuildDir = path__default.join(ctx.backendDir, "server");
-  const pageParts = await loadProductionPageParts(
-    route,
-    pageModule,
-    jayHtmlContent,
-    ctx.projectRoot,
-    ctx.tsConfigFilePath,
-    serverBuildDir
-  );
-  const contracts = [
-    .../* @__PURE__ */ new Set([
-      ...pageParts.headlessInstanceComponents.map((c) => c.contractName),
-      ...pageParts.parts.filter((p) => p.contractInfo?.contractName).map((p) => p.contractInfo.contractName)
-    ])
-  ];
-  const pagePartsConfigPath = path__default.join(backendInstanceDir, "page-parts.json");
-  const exportName = route.componentExport || "page";
-  let pageServerModule = "";
-  let pageIsPlugin = false;
-  if (route.compPath) {
-    if (route.componentExport) {
-      pageServerModule = route.packageName || route.compPath;
-      pageIsPlugin = true;
-    } else {
-      const relativePath = path__default.relative(ctx.projectRoot, route.compPath);
-      pageServerModule = relativePath.replace(/^src\//, "server/").replace(/\.ts$/, ".js").replace(/\[/g, "_").replace(/\]/g, "_");
+  const result = {};
+  for (const errorPage of errorPages) {
+    if (!errorPage.jayHtmlPath) {
+      logger.warn(`[Build] Error page ${errorPage.token} has no page.jay-html — skipped`);
+      continue;
     }
-  }
-  const config = buildPagePartsConfig(
-    pageParts,
-    pageServerModule,
-    exportName,
-    ctx.backendDir,
-    pageIsPlugin
-  );
-  await fs.writeFile(pagePartsConfigPath, JSON.stringify(config, null, 2));
-  logger.info(`[Build] Page parts config: ${routeDir}/page-parts.json`);
-  const slowPhase = new DevSlowlyChangingPhase();
-  const slowResult = await slowPhase.runSlowlyForPage(
-    params,
-    { params },
-    pageParts.parts,
-    pageParts.discoveredInstances,
-    pageParts.headlessInstanceComponents,
-    route.jayHtmlPath
-  );
-  if (slowResult.kind !== "PhaseOutput") {
-    if (slowResult.kind === "ClientError" || slowResult.kind === "Redirect") {
-      return {
-        status: "skipped",
-        reason: `${slowResult.kind} ${slowResult.status ?? ""} ${slowResult.message ?? ""}`.trim()
-      };
+    const outputDirName = path__default.join("_errors", errorPage.token);
+    const backendPageDir = path__default.join(ctx.backendDir, "pre-rendered", outputDirName);
+    const frontendPageDir = path__default.join(ctx.frontendDir, "pages", outputDirName);
+    await fs.mkdir(backendPageDir, { recursive: true });
+    await fs.mkdir(frontendPageDir, { recursive: true });
+    const entry = {
+      token: errorPage.token,
+      serverElementPath: ""
+    };
+    const serverElementPath = path__default.join(backendPageDir, "route.server-element.js");
+    try {
+      const seResult = await compileRouteServerElement(
+        errorPage.jayHtmlPath,
+        serverElementPath,
+        projectRoot,
+        tsConfigFilePath,
+        minify
+      );
+      entry.serverElementPath = path__default.relative(ctx.backendDir, serverElementPath);
+      if (seResult.cssFile) {
+        const srcCss = path__default.join(backendPageDir, seResult.cssFile);
+        const dstCss = path__default.join(frontendPageDir, seResult.cssFile);
+        try {
+          await fs.rename(srcCss, dstCss);
+        } catch {
+          await fs.copyFile(srcCss, dstCss);
+          await fs.rm(srcCss, { force: true });
+        }
+        entry.routeCssPath = path__default.relative(ctx.frontendDir, dstCss);
+      }
+      if (seResult.cssImports?.length) entry.cssImports = seResult.cssImports;
+      if (seResult.headMeta) entry.headMeta = seResult.headMeta;
+      if (seResult.scripts?.length) entry.scripts = seResult.scripts;
+      logger.important(`[Build] Error page server element: ${errorPage.token}`);
+    } catch (err) {
+      logger.error(
+        `[Build] Error page server element FAILED ${errorPage.token}: ${err.message}`
+      );
+      continue;
     }
-    throw new Error(
-      `Slow render failed for ${route.rawRoute} with params ${JSON.stringify(params)}: ${slowResult.kind}`
-    );
-  }
-  const slowViewState = slowResult.rendered;
-  const carryForward = slowResult.carryForward;
-  if (pageParts.discoveredInstances.length > 0 && pageParts.headlessInstanceComponents.length > 0) {
-    const slowResult2 = await slowRenderInstances(
-      pageParts.discoveredInstances,
-      pageParts.headlessInstanceComponents,
-      {
-        pageViewState: slowViewState,
-        pageParams: params,
-        pageProps: { language: "en", url: "" }
+    try {
+      const hydrateResult = await compileRouteHydrateScript(
+        errorPage.jayHtmlPath,
+        frontendPageDir,
+        projectRoot,
+        tsConfigFilePath,
+        minify
+      );
+      entry.routeHydratePath = path__default.relative(
+        ctx.frontendDir,
+        path__default.join(frontendPageDir, hydrateResult.jsFile)
+      );
+      try {
+        const hydrateCode = await fs.readFile(
+          path__default.join(frontendPageDir, hydrateResult.jsFile),
+          "utf-8"
+        );
+        const importMatches = hydrateCode.match(/from\s*"([^"]+)"/g) || [];
+        const deps = importMatches.map((m) => m.replace(/^from\s*"/, "").replace(/"$/, "")).filter((dep) => sharedManifest[dep]);
+        if (deps.length > 0) entry.sharedDeps = deps;
+      } catch {
       }
-    );
-    if (slowResult2) {
-      const existingInstances = carryForward.__instances || {
-        discovered: [],
-        carryForwards: {}
-      };
-      carryForward.__instances = {
-        discovered: [
-          ...existingInstances.discovered,
-          ...slowResult2.instancePhaseData.discovered
-        ],
-        carryForwards: {
-          ...existingInstances.carryForwards,
-          ...slowResult2.instancePhaseData.carryForwards
-        },
-        slowViewStates: {
-          ...existingInstances.slowViewStates || {},
-          ...slowResult2.instancePhaseData.slowViewStates
-        }
-      };
+      logger.important(`[Build] Error page hydrate script: ${errorPage.token}`);
+    } catch (err) {
+      logger.error(
+        `[Build] Error page hydrate script FAILED ${errorPage.token}: ${err.message}`
+      );
+      result[errorPage.token] = entry;
+      continue;
     }
+    try {
+      const ROUTE_HYDRATE_KEY = "jay-route-hydrate";
+      let pageModulePath = "";
+      if (errorPage.compPath) {
+        pageModulePath = "./" + path__default.relative(frontendPageDir, errorPage.compPath);
+      }
+      const pageParts = await loadProductionPageParts(
+        { jayHtmlPath: errorPage.jayHtmlPath },
+        {},
+        await fs.readFile(errorPage.jayHtmlPath, "utf-8"),
+        projectRoot,
+        tsConfigFilePath,
+        path__default.join(ctx.backendDir, "server")
+      );
+      entry.trackByMap = pageParts.serverTrackByMap || pageParts.clientTrackByMap;
+      const entryPath = path__default.join(frontendPageDir, "route.entry.ts");
+      await generateRouteHydrationEntry({
+        hydrateImport: ROUTE_HYDRATE_KEY,
+        pageModulePath,
+        pageExportName: "page",
+        trackByMap: pageParts.clientTrackByMap || {},
+        outputPath: entryPath,
+        keyedParts: pageParts.keyedPartModules,
+        clientInits: ctx.clientInits
+      });
+      const clientResult = await buildInstanceClient(
+        entryPath,
+        "route.client",
+        frontendPageDir,
+        projectRoot,
+        { tsConfigFilePath },
+        minify,
+        pagesRoot,
+        buildDir
+      );
+      await fs.rm(entryPath, { force: true });
+      entry.routeClientBundlePath = path__default.relative(
+        ctx.frontendDir,
+        path__default.join(frontendPageDir, clientResult.jsFile)
+      );
+      try {
+        const clientCode = await fs.readFile(
+          path__default.join(frontendPageDir, clientResult.jsFile),
+          "utf-8"
+        );
+        const clientImports = (clientCode.match(/from\s*"([^"]+)"/g) || []).map((m) => m.replace(/^from\s*"/, "").replace(/"$/, "")).filter((dep) => sharedManifest[dep]);
+        const existing = new Set(entry.sharedDeps || []);
+        for (const dep of clientImports) existing.add(dep);
+        if (existing.size > 0) entry.sharedDeps = [...existing];
+      } catch {
+      }
+      logger.important(`[Build] Error page client bundle: ${errorPage.token}`);
+    } catch (err) {
+      logger.error(
+        `[Build] Error page client bundle FAILED ${errorPage.token}: ${err.message}`
+      );
+    }
+    result[errorPage.token] = entry;
   }
-  if (pageParts.forEachInstances.length > 0) {
-    const existingInstances = carryForward.__instances || {
-      discovered: [],
-      carryForwards: {}
-    };
-    existingInstances.forEachInstances = pageParts.forEachInstances;
-    carryForward.__instances = existingInstances;
-  }
-  const cachePath = path__default.join(backendInstanceDir, `${instanceId}.cache.json`);
-  await fs.writeFile(
-    cachePath,
-    JSON.stringify({
-      slowViewState,
-      carryForward
-    }),
-    "utf-8"
-  );
-  logger.info(`[Build] Instance data: ${routeDir}/${instanceId}`);
-  const serverElementPath = routeServerElementPath ? path__default.join(ctx.backendDir, routeServerElementPath) : path__default.join(backendInstanceDir, `${instanceId}.server-element.js`);
-  const instanceEntry = {
-    params,
-    cachePath: path__default.relative(ctx.backendDir, cachePath),
-    serverElementPath: path__default.relative(ctx.backendDir, serverElementPath),
-    clientBundlePath: routeClientBundlePath || "",
-    clientCssPath: routeCssPath
-  };
-  return { status: "success", instanceEntry, slowViewState, carryForward, contracts };
+  return result;
 }
-function convertSegments(segments) {
-  return segments.map((s) => {
-    if (typeof s === "string") {
-      return { type: "static", value: s };
-    }
-    switch (s.type) {
-      case JayRouteParamType.single:
-        return { type: "param", value: s.name };
-      case JayRouteParamType.catchAll:
-        return { type: "catchAll", value: s.name };
-      case JayRouteParamType.optional:
-        return { type: "optional", value: s.name };
-    }
+createRequire(import.meta.url);
+const FRAMEWORK_PACKAGES = [
+  "@jay-framework/stack-client-runtime",
+  "@jay-framework/component",
+  "@jay-framework/reactive",
+  "@jay-framework/runtime",
+  "@jay-framework/view-state-merge",
+  "@jay-framework/fullstack-component"
+];
+async function buildSharedChunks(outputDir, _projectRoot, minify = true, pluginClientPackages = []) {
+  const logger = getLogger();
+  logger.info("[Build] Building shared client chunks...");
+  await fs.mkdir(outputDir, { recursive: true });
+  const allPackages = [...FRAMEWORK_PACKAGES, ...pluginClientPackages];
+  const entries = {};
+  for (const pkg of allPackages) {
+    const varName = pkgToVarName(pkg);
+    const entryPath = path__default.join(outputDir, `_shared_${varName}.js`);
+    await fs.writeFile(entryPath, `export * from '${pkg}';
+`);
+    entries[varName] = entryPath;
+  }
+  const dedupePackages = [...allPackages, "@jay-framework/list-compare"];
+  await build({
+    publicDir: false,
+    build: {
+      outDir: outputDir,
+      emptyOutDir: true,
+      minify,
+      manifest: "vite-manifest.json",
+      rollupOptions: {
+        input: entries,
+        output: {
+          entryFileNames: "[name]-[hash].js",
+          chunkFileNames: "[name]-[hash].js",
+          format: "es"
+        },
+        preserveEntrySignatures: "exports-only"
+      }
+    },
+    resolve: {
+      dedupe: dedupePackages
+    },
+    logLevel: "warn"
   });
+  for (const pkg of allPackages) {
+    const varName = pkgToVarName(pkg);
+    await fs.rm(path__default.join(outputDir, `_shared_${varName}.js`), { force: true });
+  }
+  const manifest = await parseViteManifest(outputDir, allPackages);
+  logger.info(`[Build] Shared chunks built: ${Object.keys(manifest).length} entries`);
+  return { manifest, outputDir };
 }
-function buildRouteEntry(route, serverModulePath) {
-  return {
-    pattern: route.rawRoute,
-    segments: convertSegments(route.segments),
-    serverModule: serverModulePath,
-    componentExport: route.componentExport,
-    instances: [],
-    ...route.devOnly && { devOnly: true }
-  };
+function pkgToVarName(pkg) {
+  return pkg.replace("@jay-framework/", "").replace(/[/-]/g, "_");
 }
-async function discoverActions(actionPaths, serverOutputDir, buildDir, projectRoot) {
-  const actions = [];
-  const plugins = [];
-  for (const [entryName, sourcePath] of Object.entries(actionPaths)) {
-    try {
-      const code = await fs.readFile(sourcePath, "utf-8");
-      const extracted = extractActionsFromSource(code, sourcePath);
-      if (extracted.length > 0) {
-        actions.push({
-          serverModule: path__default.relative(
-            buildDir,
-            path__default.join(serverOutputDir, entryName + ".js")
-          ),
-          isPlugin: false,
-          actionNames: extracted.map((a) => a.actionName)
-        });
+async function parseViteManifest(outputDir, packages) {
+  const viteManifestPath = path__default.join(outputDir, "vite-manifest.json");
+  const raw = JSON.parse(await fs.readFile(viteManifestPath, "utf-8"));
+  const varNameToPackage = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    varNameToPackage.set(pkgToVarName(pkg), pkg);
+  }
+  const manifest = {};
+  for (const [, entry] of Object.entries(raw)) {
+    if (!entry.isEntry) continue;
+    const outputBase = path__default.basename(entry.file, ".js");
+    for (const [varName, pkg] of varNameToPackage) {
+      if (outputBase.startsWith(varName)) {
+        manifest[pkg] = entry.file;
+        break;
       }
-    } catch {
-      getLogger().warn(`[Build] Could not extract actions from ${sourcePath}`);
     }
   }
-  try {
-    const scannedPlugins = await scanPlugins({ projectRoot });
-    for (const [packageName, plugin] of scannedPlugins) {
-      if (plugin.isLocal) continue;
-      plugins.push({ name: plugin.manifest.name, packageName });
-      const pluginActions = plugin.manifest.actions;
-      if (pluginActions && pluginActions.length > 0) {
-        const productionActions = pluginActions.map(normalizeActionEntry).filter((a) => !a.devOnly);
-        const devOnlyCount = pluginActions.length - productionActions.length;
-        if (productionActions.length > 0) {
-          actions.push({
-            serverModule: "",
-            packageName,
-            isPlugin: true,
-            actionNames: productionActions.map((a) => a.name)
-          });
+  const sharedManifestPath = path__default.join(outputDir, "shared-manifest.json");
+  await fs.writeFile(sharedManifestPath, JSON.stringify(manifest, null, 2));
+  await fs.rm(viteManifestPath, { force: true });
+  return manifest;
+}
+function crossProductParams(parts) {
+  if (parts.length === 0) return [];
+  if (parts.length === 1) return parts[0].values;
+  const logger = getLogger();
+  for (let i = 0; i < parts.length; i++) {
+    for (let j = i + 1; j < parts.length; j++) {
+      for (const key of parts[i].keys) {
+        if (parts[j].keys.has(key)) {
+          logger.warn(
+            `[Build] Multiple loadParams provide key "${key}" — using first provider`
+          );
         }
-        getLogger().info(
-          `[Build] Plugin actions from ${packageName}: ${productionActions.length}` + (devOnlyCount > 0 ? ` (excluded ${devOnlyCount} devOnly)` : "")
-        );
       }
     }
-  } catch (err) {
-    getLogger().warn(`[Build] Plugin action scan failed: ${err.message}`);
   }
-  return { actions, plugins };
+  let result = parts[0].values;
+  for (let i = 1; i < parts.length; i++) {
+    const next = parts[i].values;
+    const combined = [];
+    for (const a of result) {
+      for (const b of next) {
+        combined.push({ ...a, ...b });
+      }
+    }
+    result = combined;
+  }
+  return result;
 }
-async function writeRouteManifest(manifest, buildDir) {
-  const manifestPath = path__default.join(buildDir, "route-manifest.json");
-  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-  getLogger().info(
-    `[Build] Route manifest written: ${manifest.routes.length} routes, ${manifest.routes.reduce((n, r) => n + r.instances.length, 0)} instances`
-  );
+function paramsMatchInferred(params, inferredParams, optionalSegments) {
+  return Object.entries(inferredParams).every(([k, v]) => {
+    if (optionalSegments?.has(k)) return true;
+    return params[k] === v;
+  });
 }
-createRequire(import.meta.url);
-async function scanPluginRoutes(projectRoot, projectRoutes) {
-  const logger = getLogger();
-  const plugins = await scanPlugins({ projectRoot });
-  const projectPaths = new Set(projectRoutes.map((r) => r.rawRoute));
-  const pluginRoutes = [];
-  for (const [, plugin] of plugins) {
-    if (plugin.isLocal) continue;
-    if (!plugin.manifest.routes) continue;
-    for (const route of plugin.manifest.routes) {
-      if (projectPaths.has(route.path)) {
-        logger.info(
-          `[Routes] Plugin "${plugin.manifest.name}" route ${route.path} skipped — project route takes precedence`
-        );
+function computeSpecificity(route) {
+  const dynamicCount = (route.rawRoute.match(/\[/g) || []).length;
+  const inferredCount = route.inferredParams ? Object.keys(route.inferredParams).length : 0;
+  const unresolvedCount = Math.max(0, dynamicCount - inferredCount);
+  return 0 - unresolvedCount;
+}
+function buildUrl(route, params) {
+  return route.rawRoute.replace(/\[\[(\w+)\]\]/g, (_, name) => {
+    const value = params[name];
+    if (!value) return "";
+    if (route.inferredParams?.[name] === value) return "";
+    return value;
+  }).replace(/\[(\w+)\]/g, (_, name) => params[name] || "").replace(/\/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function materializeRouteParams(routes, loadParamsResults) {
+  const entries = [];
+  for (const route of routes) {
+    const specificity = computeSpecificity(route);
+    if (!route.hasDynamicParams) {
+      const params = route.inferredParams || {};
+      entries.push({ route, params, url: route.rawRoute, specificity });
+      continue;
+    }
+    const allParams = loadParamsResults.get(route) || [];
+    for (const params of allParams) {
+      if (route.inferredParams && !paramsMatchInferred(params, route.inferredParams, route.optionalSegments)) {
         continue;
       }
-      const jayHtmlPath = resolvePluginExport(plugin.pluginPath, route.jayHtml);
-      if (!jayHtmlPath) {
-        logger.warn(
-          `[Routes] Plugin "${plugin.manifest.name}" route ${route.path}: jayHtml "${route.jayHtml}" not found`
-        );
-        continue;
+      let mergedParams = params;
+      if (route.inferredParams) {
+        mergedParams = { ...params };
+        for (const [k, v] of Object.entries(route.inferredParams)) {
+          if (!(k in mergedParams)) {
+            mergedParams[k] = v;
+          }
+        }
       }
-      const compPath = resolvePluginModule(plugin.pluginPath);
-      const componentExport = route.component;
-      pluginRoutes.push({
-        segments: parseRouteSegments(route.path),
-        rawRoute: route.path,
-        jayHtmlPath,
-        compPath,
-        componentExport,
-        packageName: plugin.packageName,
-        ...route.devOnly === true && { devOnly: true }
-      });
-      logger.info(
-        `[Routes] Plugin "${plugin.manifest.name}" provides route ${route.path}${route.devOnly ? " (dev-only)" : ""}`
-      );
+      const url = buildUrl(route, mergedParams);
+      entries.push({ route, params: mergedParams, url, specificity });
     }
   }
-  return pluginRoutes;
+  return entries;
 }
-function resolvePluginExport(pluginPath, exportSubpath) {
-  const normalized = exportSubpath.replace(/^\.\//, "");
-  const packageJsonPath = path__default.join(pluginPath, "package.json");
-  try {
-    const packageJson = JSON.parse(fs__default.readFileSync(packageJsonPath, "utf-8"));
-    if (packageJson.exports) {
-      const exportKey = "./" + normalized;
-      const exportValue = packageJson.exports[exportKey];
-      if (exportValue) {
-        const resolved = typeof exportValue === "string" ? exportValue : exportValue.default || exportValue.import || exportValue.require;
-        if (resolved) return path__default.join(pluginPath, resolved);
-      }
-    }
-  } catch {
-  }
-  for (const dir of ["dist", "lib", ""]) {
-    const candidate = path__default.join(pluginPath, dir, normalized);
-    try {
-      fs__default.accessSync(candidate);
-      return candidate;
-    } catch {
+function dedupeByUrl(entries) {
+  const logger = getLogger();
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = byUrl.get(entry.url);
+    if (!existing) {
+      byUrl.set(entry.url, entry);
+    } else if (entry.specificity > existing.specificity) {
+      byUrl.set(entry.url, entry);
     }
   }
-  return void 0;
-}
-function resolvePluginModule(pluginPath) {
-  const pkgJsonPath = path__default.join(pluginPath, "package.json");
-  try {
-    const pkg = JSON.parse(fs__default.readFileSync(pkgJsonPath, "utf-8"));
-    const mainExport = pkg.exports?.["."];
-    const mainPath = typeof mainExport === "string" ? mainExport : mainExport?.default || mainExport?.import || pkg.main;
-    if (mainPath) {
-      const resolved = path__default.join(pluginPath, mainPath);
-      if (fs__default.existsSync(resolved)) return resolved;
-    }
-  } catch {
+  const deduped = [...byUrl.values()];
+  if (deduped.length < entries.length) {
+    logger.info(
+      `[Build] Deduplication: ${entries.length} materialized → ${deduped.length} unique URLs`
+    );
   }
-  return path__default.join(pluginPath, "dist", "index.js");
+  return deduped;
 }
-async function compileServerElement(jayHtmlContent, jayHtmlFilename, jayHtmlDir, outputPath, projectRoot, tsConfigFilePath, sourceDir, minifyCss = true) {
-  const jayFile = await parseJayFile(
-    jayHtmlContent,
-    jayHtmlFilename,
-    jayHtmlDir,
-    { relativePath: tsConfigFilePath },
-    JAY_IMPORT_RESOLVER,
-    projectRoot,
-    sourceDir
-  );
-  const parsedJayFile = checkValidationErrors(jayFile);
-  const serverElementCode = checkValidationErrors(generateServerElementFile(parsedJayFile));
-  const outputDir = path__default.dirname(outputPath);
-  await fs.mkdir(outputDir, { recursive: true });
-  const tsPath = outputPath.replace(/\.js$/, ".ts");
-  await fs.writeFile(tsPath, serverElementCode, "utf-8");
-  const jayOptions = { tsConfigFilePath };
-  await build({
-    root: projectRoot,
-    publicDir: false,
-    plugins: [jayRuntime(jayOptions)],
-    build: {
-      outDir: outputDir,
-      emptyOutDir: false,
-      minify: false,
-      ssr: true,
-      rollupOptions: {
-        input: { [path__default.basename(outputPath, ".js")]: tsPath },
-        external: [/^node:/, /^@jay-framework\//],
-        output: {
-          entryFileNames: "[name].js",
-          format: "es"
-        }
-      }
+function hashParams(params, suffix) {
+  const sorted = Object.keys(params).sort().reduce(
+    (acc, key) => {
+      acc[key] = params[key];
+      return acc;
     },
-    logLevel: "warn"
-  });
-  await fs.rm(tsPath, { force: true });
-  let cssFile;
-  let cssImports;
-  const css = parsedJayFile.css;
-  if (css) {
-    cssImports = extractCssImportUrls(css);
-    const cssContent = minifyCss ? (await transform(css, { loader: "css", minify: true })).code : css;
-    const hash = createHash("sha256").update(cssContent).digest("hex").slice(0, 8);
-    const baseName = path__default.basename(outputPath, ".server-element.js");
-    const cssFilename = `${baseName}-${hash}.css`;
-    await fs.writeFile(path__default.join(outputDir, cssFilename), cssContent, "utf-8");
-    cssFile = cssFilename;
-  }
-  getLogger().info(`[Build] Compiled server element: ${path__default.basename(outputPath)}`);
-  return { cssFile, cssImports, headMeta: parsedJayFile.headMeta };
-}
-async function compileRouteServerElement(jayHtmlPath, outputPath, projectRoot, tsConfigFilePath, minifyCss = true) {
-  const jayHtmlContent = await fs.readFile(jayHtmlPath, "utf-8");
-  const sourceDir = path__default.dirname(jayHtmlPath);
-  const outputDir = path__default.dirname(outputPath);
-  const jayHtml = resolveJayHtmlPaths(jayHtmlContent, sourceDir, outputDir);
-  return compileServerElement(
-    jayHtml,
-    path__default.basename(jayHtmlPath),
-    outputDir,
-    outputPath,
-    projectRoot,
-    tsConfigFilePath,
-    sourceDir,
-    minifyCss
+    {}
   );
+  const json = JSON.stringify(sorted);
+  if (json === "{}" && !suffix) return "";
+  const input = suffix ? json + ":" + suffix : json;
+  return "_" + crypto.createHash("md5").update(input).digest("hex").substring(0, 8);
 }
-async function compileRouteHydrateScript(jayHtmlPath, outputDir, projectRoot, tsConfigFilePath, minify = true) {
-  const jayHtmlContent = await fs.readFile(jayHtmlPath, "utf-8");
-  const sourceDir = path__default.dirname(jayHtmlPath);
-  const jayHtml = resolveJayHtmlPaths(jayHtmlContent, sourceDir, outputDir);
-  const jayFile = await parseJayFile(
-    jayHtml,
-    path__default.basename(jayHtmlPath),
-    outputDir,
-    { relativePath: tsConfigFilePath },
-    JAY_IMPORT_RESOLVER,
-    projectRoot,
-    sourceDir
-  );
-  const parsedJayFile = checkValidationErrors(jayFile);
-  const hydrateCode = checkValidationErrors(
-    generateElementHydrateFile(parsedJayFile, RuntimeMode.MainTrusted)
+async function buildInstance(route, params, pageModule, ctx, routeServerElementPath, routeCssPath, routeHydratePath, routeClientBundlePath) {
+  const logger = getLogger();
+  const routeDir = route.rawRoute.replace(/^\//, "") || "index";
+  const paramHash = hashParams(params, ctx.rebuildSuffix);
+  const instanceId = `page${paramHash}`;
+  const backendInstanceDir = path__default.join(ctx.backendDir, "pre-rendered", routeDir);
+  const frontendInstanceDir = path__default.join(ctx.frontendDir, "pages", routeDir);
+  await fs.mkdir(backendInstanceDir, { recursive: true });
+  await fs.mkdir(frontendInstanceDir, { recursive: true });
+  const jayHtmlContent = await fs.readFile(route.jayHtmlPath, "utf-8");
+  path__default.dirname(route.jayHtmlPath);
+  const serverBuildDir = path__default.join(ctx.backendDir, "server");
+  const pageParts = await loadProductionPageParts(
+    route,
+    pageModule,
+    jayHtmlContent,
+    ctx.projectRoot,
+    ctx.tsConfigFilePath,
+    serverBuildDir
   );
-  await fs.mkdir(outputDir, { recursive: true });
-  const tsPath = path__default.join(outputDir, "route.hydrate.ts");
-  await fs.writeFile(tsPath, hydrateCode, "utf-8");
-  const jayOptions = { tsConfigFilePath };
-  await build({
-    root: projectRoot,
-    publicDir: false,
-    plugins: [...jayStackCompiler(jayOptions)],
-    build: {
-      outDir: outputDir,
-      emptyOutDir: false,
-      minify,
-      manifest: "route-hydrate-manifest.json",
-      rollupOptions: {
-        input: { "route.hydrate": tsPath },
-        external: (id) => id.startsWith("@jay-framework/"),
-        output: {
-          entryFileNames: "[name]-[hash].js",
-          format: "es"
-        },
-        preserveEntrySignatures: "exports-only"
-      }
-    },
-    logLevel: "warn"
-  });
-  await fs.rm(tsPath, { force: true });
-  const manifestPath = path__default.join(outputDir, "route-hydrate-manifest.json");
-  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
-  await fs.rm(manifestPath, { force: true });
-  const entryKey = Object.keys(manifest).find((k) => manifest[k].isEntry);
-  if (!entryKey) throw new Error("No entry in route hydrate manifest");
-  const jsFile = manifest[entryKey].file;
-  getLogger().info(`[Build] Compiled route hydrate script: ${jsFile}`);
-  return { jsFile };
-}
-function resolveJayHtmlPaths(html, sourceDir, targetDir) {
-  const root = parse(html, {
-    comment: true,
-    blockTextElements: { script: true, style: true }
-  });
-  const rewrite = (el, attr) => {
-    const val = el.getAttribute(attr);
-    if (val && (val.startsWith("./") || val.startsWith("../"))) {
-      const abs = path__default.resolve(sourceDir, val);
-      let rel = path__default.relative(targetDir, abs);
-      if (!rel.startsWith(".")) rel = "./" + rel;
-      el.setAttribute(attr, rel);
+  const contracts = [
+    .../* @__PURE__ */ new Set([
+      ...pageParts.headlessInstanceComponents.map((c) => c.contractName),
+      ...pageParts.parts.filter((p) => p.contractInfo?.contractName).map((p) => p.contractInfo.contractName)
+    ])
+  ];
+  const pagePartsConfigPath = path__default.join(backendInstanceDir, "page-parts.json");
+  const exportName = route.componentExport || "page";
+  let pageServerModule = "";
+  let pageIsPlugin = false;
+  if (route.compPath) {
+    if (route.componentExport) {
+      pageServerModule = route.packageName || route.compPath;
+      pageIsPlugin = true;
+    } else {
+      const relativePath = path__default.relative(ctx.projectRoot, route.compPath);
+      pageServerModule = relativePath.replace(/^src\//, "server/").replace(/\.ts$/, ".js").replace(/\[/g, "_").replace(/\]/g, "_");
     }
-  };
-  for (const el of root.querySelectorAll('script[type="application/jay-data"]')) {
-    rewrite(el, "contract");
-  }
-  for (const el of root.querySelectorAll('script[type="application/jay-headless"]')) {
-    rewrite(el, "src");
-    rewrite(el, "contract");
   }
-  for (const el of root.querySelectorAll('script[type="application/jay-headfull"]')) {
-    rewrite(el, "src");
-    rewrite(el, "contract");
-  }
-  for (const el of root.querySelectorAll('link[rel="stylesheet"]')) {
-    rewrite(el, "href");
-  }
-  return root.toString();
-}
-function extractCssImportUrls(css) {
-  const imports = [];
-  const re = /@import\s*(?:url\(\s*['"]?([^'")]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
-  let match;
-  while ((match = re.exec(css)) !== null) {
-    const url = match[1] || match[2];
-    if (url.startsWith("https://")) {
-      imports.push(url);
+  const config = buildPagePartsConfig(
+    pageParts,
+    pageServerModule,
+    exportName,
+    ctx.backendDir,
+    pageIsPlugin
+  );
+  await fs.writeFile(pagePartsConfigPath, JSON.stringify(config, null, 2));
+  logger.info(`[Build] Page parts config: ${routeDir}/page-parts.json`);
+  const pageUrl = buildUrl(route, params);
+  const slowPhase = new DevSlowlyChangingPhase();
+  const slowResult = await slowPhase.runSlowlyForPage(
+    params,
+    { language: "en", url: pageUrl },
+    pageParts.parts,
+    pageParts.discoveredInstances,
+    pageParts.headlessInstanceComponents,
+    route.jayHtmlPath
+  );
+  if (slowResult.kind !== "PhaseOutput") {
+    if (slowResult.kind === "ClientError" || slowResult.kind === "Redirect") {
+      return {
+        status: "skipped",
+        reason: `${slowResult.kind} ${slowResult.status ?? ""} ${slowResult.message ?? ""}`.trim()
+      };
     }
+    throw new Error(
+      `Slow render failed for ${route.rawRoute} with params ${JSON.stringify(params)}: ${slowResult.kind}`
+    );
   }
-  return imports;
-}
-async function generateRouteHydrationEntry(options) {
-  const {
-    hydrateImport,
-    pageModulePath,
-    pageExportName = "page",
-    trackByMap,
-    outputPath,
-    keyedParts = [],
-    clientInits = []
-  } = options;
-  const partImports = keyedParts.map((p, i) => `import { ${p.exportName} as keyedPart${i} } from '${p.modulePath}';`).join("\n");
-  const hasPageModule = pageModulePath && pageExportName;
-  const pagePartExpr = hasPageModule ? `pagePart && pagePart.comp ? { comp: pagePart.comp, contextMarkers: pagePart.contexts || [] } : null` : `null`;
-  const partsArray = [
-    pagePartExpr,
-    ...keyedParts.map(
-      (p, i) => `keyedPart${i} && keyedPart${i}.comp ? { comp: keyedPart${i}.comp, contextMarkers: keyedPart${i}.contexts || [], key: '${p.key}' } : null`
-    )
-  ];
-  const pageImport = hasPageModule ? `import { ${pageExportName} as pagePart } from '${pageModulePath}';` : "";
-  const initImports = clientInits.map((ci, i) => `import { ${ci.exportName} as clientInit${i} } from '${ci.modulePath}';`).join("\n");
-  const initCalls = clientInits.map(
-    (ci, i) => `    if (clientInit${i}?._clientInit) await clientInit${i}._clientInit(clientInitData['${ci.key}'] || {});`
-  ).join("\n");
-  const code = `import { hydrateCompositeJayComponent } from '@jay-framework/stack-client-runtime';
-import { deepMergeViewStates } from '@jay-framework/view-state-merge';
-import { hydrate } from '${hydrateImport}';
-${pageImport}
-${partImports}
-${initImports}
-
-const trackByMap = ${JSON.stringify(trackByMap)};
-
-export async function init(slowViewState, fastViewState, fastCarryForward, clientInitData) {
-${initCalls}
-    const viewState = deepMergeViewStates(slowViewState, fastViewState, trackByMap);
-    const target = document.getElementById('target');
-    const rootElement = target.firstElementChild;
-    const parts = [
-        ${partsArray.join(",\n        ")}
-    ].filter(p => p !== null);
-    const pageComp = hydrateCompositeJayComponent(
-        hydrate, viewState, fastCarryForward,
-        parts, trackByMap, rootElement
+  const slowViewState = slowResult.rendered;
+  const carryForward = slowResult.carryForward;
+  if (pageParts.discoveredInstances.length > 0 && pageParts.headlessInstanceComponents.length > 0) {
+    const slowResult2 = await slowRenderInstances(
+      pageParts.discoveredInstances,
+      pageParts.headlessInstanceComponents,
+      {
+        pageViewState: slowViewState,
+        pageParams: params,
+        pageProps: { language: "en", url: pageUrl }
+      }
     );
-    return pageComp({});
-}
-`;
-  const outputDir = path__default.dirname(outputPath);
-  await fs.mkdir(outputDir, { recursive: true });
-  await fs.writeFile(outputPath, code, "utf-8");
-  getLogger().info(`[Build] Generated route hydration entry: ${path__default.basename(outputPath)}`);
-}
-async function buildInstanceClient(hydrateEntryPath, instanceId, outputDir, projectRoot, jayOptions, minify = true, pagesRoot, buildDir) {
-  const logger = getLogger();
-  await fs.mkdir(outputDir, { recursive: true });
-  const fullJayOptions = {
-    ...jayOptions,
-    ...pagesRoot && buildDir ? { pagesRoot, buildFolder: buildDir } : {}
-  };
-  await build({
-    root: projectRoot,
-    publicDir: false,
-    plugins: [...jayStackCompiler(fullJayOptions)],
-    build: {
-      outDir: outputDir,
-      emptyOutDir: false,
-      minify,
-      manifest: `${instanceId}-manifest.json`,
-      rollupOptions: {
-        input: { [instanceId]: hydrateEntryPath },
-        external: (id) => id.startsWith("@jay-framework/") || id === "jay-route-hydrate",
-        output: {
-          entryFileNames: "[name]-[hash].js",
-          chunkFileNames: "chunks/[name]-[hash].js",
-          assetFileNames: "[name]-[hash].[ext]",
-          format: "es"
+    if (slowResult2) {
+      const existingInstances = carryForward.__instances || {
+        discovered: [],
+        carryForwards: {}
+      };
+      carryForward.__instances = {
+        discovered: [
+          ...existingInstances.discovered,
+          ...slowResult2.instancePhaseData.discovered
+        ],
+        carryForwards: {
+          ...existingInstances.carryForwards,
+          ...slowResult2.instancePhaseData.carryForwards
         },
-        preserveEntrySignatures: "exports-only"
-      }
-    },
-    logLevel: "warn"
+        slowViewStates: {
+          ...existingInstances.slowViewStates || {},
+          ...slowResult2.instancePhaseData.slowViewStates
+        }
+      };
+    }
+  }
+  if (pageParts.forEachInstances.length > 0) {
+    const existingInstances = carryForward.__instances || {
+      discovered: [],
+      carryForwards: {}
+    };
+    existingInstances.forEachInstances = pageParts.forEachInstances;
+    carryForward.__instances = existingInstances;
+  }
+  const cachePath = path__default.join(backendInstanceDir, `${instanceId}.cache.json`);
+  await fs.writeFile(
+    cachePath,
+    JSON.stringify({
+      slowViewState,
+      carryForward
+    }),
+    "utf-8"
+  );
+  logger.info(`[Build] Instance data: ${routeDir}/${instanceId}`);
+  const serverElementPath = routeServerElementPath ? path__default.join(ctx.backendDir, routeServerElementPath) : path__default.join(backendInstanceDir, `${instanceId}.server-element.js`);
+  const instanceEntry = {
+    params,
+    cachePath: path__default.relative(ctx.backendDir, cachePath),
+    serverElementPath: path__default.relative(ctx.backendDir, serverElementPath),
+    clientBundlePath: routeClientBundlePath || "",
+    clientCssPath: routeCssPath
+  };
+  return { status: "success", instanceEntry, slowViewState, carryForward, contracts };
+}
+function convertSegments(segments) {
+  return segments.map((s) => {
+    if (typeof s === "string") {
+      return { type: "static", value: s };
+    }
+    switch (s.type) {
+      case JayRouteParamType.single:
+        return { type: "param", value: s.name };
+      case JayRouteParamType.catchAll:
+        return { type: "catchAll", value: s.name };
+      case JayRouteParamType.optional:
+        return { type: "optional", value: s.name };
+    }
   });
-  const manifestPath = path__default.join(outputDir, `${instanceId}-manifest.json`);
-  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
-  await fs.rm(manifestPath, { force: true });
-  const entryKey = Object.keys(manifest).find((k) => manifest[k].isEntry);
-  if (!entryKey) {
-    throw new Error(`No entry found in instance build manifest for ${instanceId}`);
-  }
-  const entry = manifest[entryKey];
-  const result = {
-    jsFile: entry.file,
-    cssFile: entry.css?.[0]
+}
+function buildRouteEntry(route, serverModulePath) {
+  return {
+    pattern: route.rawRoute,
+    segments: convertSegments(route.segments),
+    serverModule: serverModulePath,
+    componentExport: route.componentExport,
+    instances: [],
+    ...route.devOnly && { devOnly: true }
   };
-  logger.info(`[Build] Client bundle: ${result.jsFile}`);
-  return result;
 }
-function crossProductParams(parts) {
-  if (parts.length === 0) return [];
-  if (parts.length === 1) return parts[0].values;
-  const logger = getLogger();
-  for (let i = 0; i < parts.length; i++) {
-    for (let j = i + 1; j < parts.length; j++) {
-      for (const key of parts[i].keys) {
-        if (parts[j].keys.has(key)) {
-          logger.warn(
-            `[Build] Multiple loadParams provide key "${key}" — using first provider`
-          );
-        }
+async function discoverActions(actionPaths, serverOutputDir, buildDir, projectRoot) {
+  const actions = [];
+  const plugins = [];
+  for (const [entryName, sourcePath] of Object.entries(actionPaths)) {
+    try {
+      const code = await fs.readFile(sourcePath, "utf-8");
+      const extracted = extractActionsFromSource(code, sourcePath);
+      if (extracted.length > 0) {
+        actions.push({
+          serverModule: path__default.relative(
+            buildDir,
+            path__default.join(serverOutputDir, entryName + ".js")
+          ),
+          isPlugin: false,
+          actionNames: extracted.map((a) => a.actionName)
+        });
       }
+    } catch {
+      getLogger().warn(`[Build] Could not extract actions from ${sourcePath}`);
     }
   }
-  let result = parts[0].values;
-  for (let i = 1; i < parts.length; i++) {
-    const next = parts[i].values;
-    const combined = [];
-    for (const a of result) {
-      for (const b of next) {
-        combined.push({ ...a, ...b });
+  try {
+    const scannedPlugins = await scanPlugins({ projectRoot });
+    for (const [packageName, plugin] of scannedPlugins) {
+      if (plugin.isLocal) continue;
+      plugins.push({ name: plugin.manifest.name, packageName });
+      const pluginActions = plugin.manifest.actions;
+      if (pluginActions && pluginActions.length > 0) {
+        const productionActions = pluginActions.map(normalizeActionEntry).filter((a) => !a.devOnly);
+        const devOnlyCount = pluginActions.length - productionActions.length;
+        if (productionActions.length > 0) {
+          actions.push({
+            serverModule: "",
+            packageName,
+            isPlugin: true,
+            actionNames: productionActions.map((a) => a.name)
+          });
+        }
+        getLogger().info(
+          `[Build] Plugin actions from ${packageName}: ${productionActions.length}` + (devOnlyCount > 0 ? ` (excluded ${devOnlyCount} devOnly)` : "")
+        );
       }
     }
-    result = combined;
+  } catch (err) {
+    getLogger().warn(`[Build] Plugin action scan failed: ${err.message}`);
   }
-  return result;
-}
-function paramsMatchInferred(params, inferredParams, optionalSegments) {
-  return Object.entries(inferredParams).every(([k, v]) => {
-    if (optionalSegments?.has(k)) return true;
-    return params[k] === v;
-  });
-}
-function computeSpecificity(route) {
-  const dynamicCount = (route.rawRoute.match(/\[/g) || []).length;
-  const inferredCount = route.inferredParams ? Object.keys(route.inferredParams).length : 0;
-  const unresolvedCount = Math.max(0, dynamicCount - inferredCount);
-  return 0 - unresolvedCount;
+  return { actions, plugins };
 }
-function buildUrl(route, params) {
-  return route.rawRoute.replace(/\[\[(\w+)\]\]/g, (_, name) => {
-    const value = params[name];
-    if (!value) return "";
-    if (route.inferredParams?.[name] === value) return "";
-    return value;
-  }).replace(/\[(\w+)\]/g, (_, name) => params[name] || "").replace(/\/\/+/g, "/").replace(/\/$/, "") || "/";
+async function writeRouteManifest(manifest, buildDir) {
+  const manifestPath = path__default.join(buildDir, "route-manifest.json");
+  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  getLogger().info(
+    `[Build] Route manifest written: ${manifest.routes.length} routes, ${manifest.routes.reduce((n, r) => n + r.instances.length, 0)} instances`
+  );
 }
-function materializeRouteParams(routes, loadParamsResults) {
-  const entries = [];
-  for (const route of routes) {
-    const specificity = computeSpecificity(route);
-    if (!route.hasDynamicParams) {
-      const params = route.inferredParams || {};
-      entries.push({ route, params, url: route.rawRoute, specificity });
-      continue;
-    }
-    const allParams = loadParamsResults.get(route) || [];
-    for (const params of allParams) {
-      if (route.inferredParams && !paramsMatchInferred(params, route.inferredParams, route.optionalSegments)) {
+createRequire(import.meta.url);
+async function scanPluginRoutes(projectRoot, projectRoutes) {
+  const logger = getLogger();
+  const plugins = await scanPlugins({ projectRoot });
+  const projectPaths = new Set(projectRoutes.map((r) => r.rawRoute));
+  const pluginRoutes = [];
+  for (const [, plugin] of plugins) {
+    if (plugin.isLocal) continue;
+    if (!plugin.manifest.routes) continue;
+    for (const route of plugin.manifest.routes) {
+      if (projectPaths.has(route.path)) {
+        logger.info(
+          `[Routes] Plugin "${plugin.manifest.name}" route ${route.path} skipped — project route takes precedence`
+        );
         continue;
       }
-      let mergedParams = params;
-      if (route.inferredParams) {
-        mergedParams = { ...params };
-        for (const [k, v] of Object.entries(route.inferredParams)) {
-          if (!(k in mergedParams)) {
-            mergedParams[k] = v;
-          }
-        }
+      const jayHtmlPath = resolvePluginExport(plugin.pluginPath, route.jayHtml);
+      if (!jayHtmlPath) {
+        logger.warn(
+          `[Routes] Plugin "${plugin.manifest.name}" route ${route.path}: jayHtml "${route.jayHtml}" not found`
+        );
+        continue;
       }
-      const url = buildUrl(route, mergedParams);
-      entries.push({ route, params: mergedParams, url, specificity });
+      const compPath = resolvePluginModule(plugin.pluginPath);
+      const componentExport = route.component;
+      pluginRoutes.push({
+        segments: parseRouteSegments(route.path),
+        rawRoute: route.path,
+        jayHtmlPath,
+        compPath,
+        componentExport,
+        packageName: plugin.packageName,
+        ...route.devOnly === true && { devOnly: true }
+      });
+      logger.info(
+        `[Routes] Plugin "${plugin.manifest.name}" provides route ${route.path}${route.devOnly ? " (dev-only)" : ""}`
+      );
     }
   }
-  return entries;
+  return pluginRoutes;
 }
-function dedupeByUrl(entries) {
-  const logger = getLogger();
-  const byUrl = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const existing = byUrl.get(entry.url);
-    if (!existing) {
-      byUrl.set(entry.url, entry);
-    } else if (entry.specificity > existing.specificity) {
-      byUrl.set(entry.url, entry);
+function resolvePluginExport(pluginPath, exportSubpath) {
+  const normalized = exportSubpath.replace(/^\.\//, "");
+  const packageJsonPath = path__default.join(pluginPath, "package.json");
+  try {
+    const packageJson = JSON.parse(fs__default.readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.exports) {
+      const exportKey = "./" + normalized;
+      const exportValue = packageJson.exports[exportKey];
+      if (exportValue) {
+        const resolved = typeof exportValue === "string" ? exportValue : exportValue.default || exportValue.import || exportValue.require;
+        if (resolved) return path__default.join(pluginPath, resolved);
+      }
     }
+  } catch {
   }
-  const deduped = [...byUrl.values()];
-  if (deduped.length < entries.length) {
-    logger.info(
-      `[Build] Deduplication: ${entries.length} materialized → ${deduped.length} unique URLs`
-    );
+  for (const dir of ["dist", "lib", ""]) {
+    const candidate = path__default.join(pluginPath, dir, normalized);
+    try {
+      fs__default.accessSync(candidate);
+      return candidate;
+    } catch {
+    }
   }
-  return deduped;
+  return void 0;
+}
+function resolvePluginModule(pluginPath) {
+  const pkgJsonPath = path__default.join(pluginPath, "package.json");
+  try {
+    const pkg = JSON.parse(fs__default.readFileSync(pkgJsonPath, "utf-8"));
+    const mainExport = pkg.exports?.["."];
+    const mainPath = typeof mainExport === "string" ? mainExport : mainExport?.default || mainExport?.import || pkg.main;
+    if (mainPath) {
+      const resolved = path__default.join(pluginPath, mainPath);
+      if (fs__default.existsSync(resolved)) return resolved;
+    }
+  } catch {
+  }
+  return path__default.join(pluginPath, "dist", "index.js");
 }
 async function discoverPluginClientPackages(projectRoot) {
   const projectRequire = createRequire(path__default.join(projectRoot, "package.json"));
@@ -1147,7 +1299,10 @@ async function buildVersion(options) {
   logger.important(`[Build] Project: ${options.projectRoot}`);
   await fs.mkdir(backendDir, { recursive: true });
   await fs.mkdir(frontendDir, { recursive: true });
-  const { entries, routes } = await discoverServerEntries(options.projectRoot, options.pagesRoot);
+  const { entries, routes, errorPages } = await discoverServerEntries(
+    options.projectRoot,
+    options.pagesRoot
+  );
   const serverOutputDir = path__default.join(backendDir, "server");
   await buildServerCode(
     entries,
@@ -1404,6 +1559,9 @@ async function buildVersion(options) {
           entry.noIndex = true;
         }
       }
+      if (seResult.scripts?.length) {
+        entry.scripts = seResult.scripts;
+      }
       logger.important(`[Build] Route server element: ${routeDir}`);
     } catch (err) {
       logger.error(`[Build] Route server element FAILED ${route.rawRoute}: ${err.message}`);
@@ -1545,13 +1703,33 @@ async function buildVersion(options) {
       }
     }
   }
+  let errorPageEntries;
+  if (errorPages.length > 0) {
+    errorPageEntries = await buildErrorPages(
+      errorPages,
+      instanceCtx,
+      options.projectRoot,
+      options.pagesRoot,
+      options.tsConfigFilePath,
+      options.minify ?? true,
+      sharedManifest,
+      buildDir
+    );
+    logger.important(
+      `[Build] Error pages compiled: ${Object.keys(errorPageEntries).join(", ")}`
+    );
+  }
+  const siteConfig = options.site ?? (options.siteBaseUrl ? { baseUrl: options.siteBaseUrl } : void 0);
+  const siteHeadTags = generateSiteJsonLd(siteConfig);
   const manifest = {
     version: options.version,
     projectRoot: options.projectRoot,
     sharedManifest,
     routes: routeEntries.map((r) => r.entry),
     actions,
-    plugins
+    plugins,
+    ...siteHeadTags.length > 0 && { siteHeadTags },
+    ...errorPageEntries && Object.keys(errorPageEntries).length > 0 && { errorPages: errorPageEntries }
   };
   await writeRouteManifest(manifest, backendDir);
   const publicFolder = path__default.join(options.projectRoot, "public");
@@ -1566,6 +1744,24 @@ async function buildVersion(options) {
     const urlCount = await generateSitemap(manifest, options.siteBaseUrl, sitemapPath);
     logger.important(`[Build] Sitemap generated: ${urlCount} URLs`);
   }
+  const robotsWritten = await generateRobotsTxtIfAbsent(
+    path__default.join(frontendDir, "robots.txt"),
+    siteConfig?.baseUrl
+  );
+  if (robotsWritten) logger.important("[Build] robots.txt generated");
+  if (siteConfig?.name) {
+    const llmsPath = path__default.join(frontendDir, "llms.txt");
+    let authored = false;
+    try {
+      await fs.access(llmsPath);
+      authored = true;
+    } catch {
+    }
+    if (!authored) {
+      const count = await generateLlmsTxt(manifest, siteConfig, backendDir, llmsPath);
+      logger.important(`[Build] llms.txt generated: ${count} pages`);
+    }
+  }
   const sourceHash = await computeBuildHash(buildDir);
   const metadata = {
     version: options.version,