@jay-framework/production-server 0.24.1 → 0.24.3

package/dist/index.js

@@ -1,450 +1,13 @@
-import { build } from "vite";
-import { jayStackCompiler, extractActionsFromSource } from "@jay-framework/compiler-jay-stack";
-import { scanRoutes, JayRouteParamType, parseRouteSegments } from "@jay-framework/stack-route-scanner";
-import { getLogger } from "@jay-framework/logger";
-import path from "node:path";
 import fs from "node:fs/promises";
-import { createRequire } from "node:module";
-import { DevSlowlyChangingPhase, slowRenderInstances, scanPlugins, runLoadParams, parseCookies } from "@jay-framework/stack-server-runtime";
-import { l as loadProductionPageParts, g as buildPagePartsConfig, F as FilesystemArtifactStore, i as initializeServices, r as registerActionsFromManifest, d as isActionRequest, f as fetchActionRequest, b as fetchStaticFile, m as matchRequest, a as fetchPageRequest } from "./init-services-Dy2SiHzw.js";
-import { c, e } from "./init-services-Dy2SiHzw.js";
-import crypto, { createHash } from "node:crypto";
-import fs$1 from "node:fs";
-import { jayRuntime } from "@jay-framework/vite-plugin";
-import { injectHeadfullFSTemplates, JAY_IMPORT_RESOLVER, parseJayFile, generateElementHydrateFile, generateServerElementFile } from "@jay-framework/compiler-jay-html";
-import { checkValidationErrors, RuntimeMode } from "@jay-framework/compiler-shared";
-import { parse } from "node-html-parser";
-import { transform } from "esbuild";
 import http from "node:http";
 import { Readable } from "node:stream";
+import path from "node:path";
+import { getLogger } from "@jay-framework/logger";
+import { F as FilesystemArtifactStore, i as initializeServices, r as registerActionsFromManifest, d as isActionRequest, f as fetchActionRequest, b as fetchStaticFile, m as matchRequest, a as fetchPageRequest, l as loadPagePartsFromConfig } from "./init-services-CnM6IinC.js";
+import { c, e } from "./init-services-CnM6IinC.js";
+import { parseCookies, scanPlugins, DevSlowlyChangingPhase, slowRenderInstances } from "@jay-framework/stack-server-runtime";
 import { isJayWebhook } from "@jay-framework/fullstack-component";
-function isCompilableTypeScriptFile(fileName) {
-  return fileName.endsWith(".ts") && !fileName.endsWith(".d.ts") && fileName !== "page.ts";
-}
-async function collectTypeScriptEntries(rootDir, entryPrefix, pages) {
-  async function walk(currentDir, relativePath) {
-    const entries = await fs.readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        const nextRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-        await walk(fullPath, nextRelative);
-        continue;
-      }
-      if (!isCompilableTypeScriptFile(entry.name)) continue;
-      const stem = entry.name.replace(/\.ts$/, "");
-      const entryName = relativePath ? `${entryPrefix}/${relativePath}/${stem}` : `${entryPrefix}/${stem}`;
-      pages[entryName] = fullPath;
-    }
-  }
-  await walk(rootDir, "");
-}
-async function discoverServerEntries(projectRoot, pagesRoot) {
-  const logger = getLogger();
-  const routes = await scanRoutes(pagesRoot, {
-    jayHtmlFilename: "page.jay-html",
-    compFilename: "page.ts"
-  });
-  const pages = {};
-  for (const route of routes) {
-    if (route.compPath) {
-      const relativePath = path.relative(projectRoot, route.compPath);
-      const entryName = relativePath.replace(/^src\//, "").replace(/\.ts$/, "");
-      pages[entryName] = route.compPath;
-    }
-  }
-  const actions = {};
-  const actionsDir = path.join(projectRoot, "src", "actions");
-  try {
-    const files = await fs.readdir(actionsDir);
-    for (const file of files) {
-      if (file.endsWith(".actions.ts")) {
-        const entryName = "actions/" + file.replace(/\.ts$/, "");
-        actions[entryName] = path.join(actionsDir, file);
-      }
-    }
-  } catch {
-  }
-  for (const subDir of ["plugins", "components"]) {
-    const scanDir = path.join(projectRoot, "src", subDir);
-    try {
-      const entries2 = await fs.readdir(scanDir, { withFileTypes: true });
-      for (const entry of entries2) {
-        const entryPath = path.join(scanDir, entry.name);
-        if (entry.isDirectory()) {
-          await collectTypeScriptEntries(entryPath, `${subDir}/${entry.name}`, pages);
-          continue;
-        }
-        if (!isCompilableTypeScriptFile(entry.name)) continue;
-        const stem = entry.name.replace(/\.ts$/, "");
-        pages[`${subDir}/${stem}`] = entryPath;
-      }
-    } catch {
-    }
-  }
-  let init;
-  const initPaths = [
-    path.join(projectRoot, "src", "lib", "init.ts"),
-    path.join(projectRoot, "src", "init.ts")
-  ];
-  for (const initPath of initPaths) {
-    try {
-      await fs.access(initPath);
-      init = initPath;
-      break;
-    } catch {
-    }
-  }
-  const entries = { init, pages, actions };
-  logger.info(
-    `[Build] Discovered: ${Object.keys(pages).length} pages, ${Object.keys(actions).length} actions, init: ${init ? "yes" : "no"}`
-  );
-  return { entries, routes };
-}
-async function buildServerCode(entries, jayOptions, outputDir, projectRoot) {
-  const logger = getLogger();
-  logger.info("[Build] Compiling server code...");
-  const input = {};
-  if (entries.init) {
-    input["init"] = entries.init;
-  }
-  for (const [name, filePath] of Object.entries(entries.pages)) {
-    input[name] = filePath;
-  }
-  for (const [name, filePath] of Object.entries(entries.actions)) {
-    input[name] = filePath;
-  }
-  if (Object.keys(input).length === 0) {
-    logger.info("[Build] No server entries to compile");
-    return;
-  }
-  await build({
-    root: projectRoot,
-    publicDir: false,
-    plugins: [...jayStackCompiler(jayOptions)],
-    build: {
-      ssr: true,
-      outDir: outputDir,
-      emptyOutDir: true,
-      minify: false,
-      rollupOptions: {
-        input,
-        external: [
-          /^node:/,
-          /^@jay-framework\//,
-          // Plugin packages are pre-compiled, externalize them
-          /^@wix\//
-        ],
-        output: {
-          entryFileNames: "[name].js",
-          chunkFileNames: "chunks/[name]-[hash].js",
-          format: "es"
-        }
-      }
-    },
-    logLevel: "warn"
-  });
-  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...");
-  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.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.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, "_");
-}
-async function parseViteManifest(outputDir, packages) {
-  const viteManifestPath = path.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.basename(entry.file, ".js");
-    for (const [varName, pkg] of varNameToPackage) {
-      if (outputBase.startsWith(varName)) {
-        manifest[pkg] = entry.file;
-        break;
-      }
-    }
-  }
-  const sharedManifestPath = path.join(outputDir, "shared-manifest.json");
-  await fs.writeFile(sharedManifestPath, JSON.stringify(manifest, null, 2));
-  await fs.rm(viteManifestPath, { force: true });
-  return manifest;
-}
-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) {
-  const logger = getLogger();
-  const routeDir = route.rawRoute.replace(/^\//, "") || "index";
-  const paramHash = hashParams(params, ctx.rebuildSuffix);
-  const instanceId = `page${paramHash}`;
-  const backendInstanceDir = path.join(ctx.backendDir, "pre-rendered", routeDir);
-  const frontendInstanceDir = path.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.dirname(route.jayHtmlPath);
-  const serverBuildDir = path.join(ctx.backendDir, "server");
-  const pageParts = await loadProductionPageParts(
-    route,
-    pageModule,
-    jayHtmlContent,
-    ctx.projectRoot,
-    ctx.tsConfigFilePath,
-    serverBuildDir
-  );
-  const contracts = [
-    .../* @__PURE__ */ new Set([
-      ...pageParts.headlessInstanceComponents.map((c2) => c2.contractName),
-      ...pageParts.parts.filter((p) => p.contractInfo?.contractName).map((p) => p.contractInfo.contractName)
-    ])
-  ];
-  const pagePartsConfigPath = path.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.relative(ctx.projectRoot, route.compPath);
-      pageServerModule = relativePath.replace(/^src\//, "server/").replace(/\.ts$/, ".js").replace(/\[/g, "_").replace(/\]/g, "_");
-    }
-  }
-  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()
-      };
-    }
-    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: "" }
-      }
-    );
-    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
-        }
-      };
-    }
-  }
-  if (pageParts.forEachInstances.length > 0) {
-    const existingInstances = carryForward.__instances || {
-      discovered: [],
-      carryForwards: {}
-    };
-    existingInstances.forEachInstances = pageParts.forEachInstances;
-    carryForward.__instances = existingInstances;
-  }
-  const cachePath = path.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.join(ctx.backendDir, routeServerElementPath) : path.join(backendInstanceDir, `${instanceId}.server-element.js`);
-  const instanceEntry = {
-    params,
-    cachePath: path.relative(ctx.backendDir, cachePath),
-    serverElementPath: path.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 };
-    }
-  });
-}
-function buildRouteEntry(route, serverModulePath) {
-  return {
-    pattern: route.rawRoute,
-    segments: convertSegments(route.segments),
-    serverModule: serverModulePath,
-    componentExport: route.componentExport,
-    instances: [],
-    ...route.devOnly && { devOnly: true }
-  };
-}
-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.relative(
-            buildDir,
-            path.join(serverOutputDir, entryName + ".js")
-          ),
-          isPlugin: false,
-          actionNames: extracted.map((a) => a.actionName)
-        });
-      }
-    } 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) {
-        actions.push({
-          serverModule: "",
-          packageName,
-          isPlugin: true,
-          actionNames: pluginActions.map(
-            (a) => typeof a === "string" ? a : a.name
-          )
-        });
-        getLogger().info(
-          `[Build] Plugin actions from ${packageName}: ${pluginActions.length}`
-        );
-      }
-    }
-  } catch (err) {
-    getLogger().warn(`[Build] Plugin action scan failed: ${err.message}`);
-  }
-  return { actions, plugins };
-}
-async function writeRouteManifest(manifest, buildDir) {
-  const manifestPath = path.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`
-  );
-}
+import crypto from "node:crypto";
 async function generateSitemap(manifest, baseUrl, outputPath) {
   const base = baseUrl.replace(/\/$/, "");
   const urls = [];
@@ -486,929 +49,6 @@ function buildUrlFromManifest(pattern, params) {
 function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-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;
-      }
-      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 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 pluginRoutes;
-}
-function resolvePluginExport(pluginPath, exportSubpath) {
-  const normalized = exportSubpath.replace(/^\.\//, "");
-  const packageJsonPath = path.join(pluginPath, "package.json");
-  try {
-    const packageJson = JSON.parse(fs$1.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.join(pluginPath, resolved);
-      }
-    }
-  } catch {
-  }
-  for (const dir of ["dist", "lib", ""]) {
-    const candidate = path.join(pluginPath, dir, normalized);
-    try {
-      fs$1.accessSync(candidate);
-      return candidate;
-    } catch {
-    }
-  }
-  return void 0;
-}
-function resolvePluginModule(pluginPath) {
-  const pkgJsonPath = path.join(pluginPath, "package.json");
-  try {
-    const pkg = JSON.parse(fs$1.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.join(pluginPath, mainPath);
-      if (fs$1.existsSync(resolved)) return resolved;
-    }
-  } catch {
-  }
-  return path.join(pluginPath, "dist", "index.js");
-}
-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.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.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.basename(outputPath, ".server-element.js");
-    const cssFilename = `${baseName}-${hash}.css`;
-    await fs.writeFile(path.join(outputDir, cssFilename), cssContent, "utf-8");
-    cssFile = cssFilename;
-  }
-  getLogger().info(`[Build] Compiled server element: ${path.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.dirname(jayHtmlPath);
-  const outputDir = path.dirname(outputPath);
-  let jayHtml = injectHeadfullFSTemplates(jayHtmlContent, sourceDir, JAY_IMPORT_RESOLVER);
-  jayHtml = resolveJayHtmlPaths(jayHtml, sourceDir, outputDir);
-  return compileServerElement(
-    jayHtml,
-    path.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.dirname(jayHtmlPath);
-  let jayHtml = injectHeadfullFSTemplates(jayHtmlContent, sourceDir, JAY_IMPORT_RESOLVER);
-  jayHtml = resolveJayHtmlPaths(jayHtml, sourceDir, outputDir);
-  const jayFile = await parseJayFile(
-    jayHtml,
-    path.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.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.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.resolve(sourceDir, val);
-      let rel = path.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");
-  }
-  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);
-    }
-  }
-  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
-    );
-    return pageComp({});
-}
-`;
-  const outputDir = path.dirname(outputPath);
-  await fs.mkdir(outputDir, { recursive: true });
-  await fs.writeFile(outputPath, code, "utf-8");
-  getLogger().info(`[Build] Generated route hydration entry: ${path.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.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;
-}
-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`
-          );
-        }
-      }
-    }
-  }
-  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;
-}
-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;
-}
-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;
-      }
-      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 url = buildUrl(route, mergedParams);
-      entries.push({ route, params: mergedParams, url, specificity });
-    }
-  }
-  return entries;
-}
-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);
-    }
-  }
-  const deduped = [...byUrl.values()];
-  if (deduped.length < entries.length) {
-    logger.info(
-      `[Build] Deduplication: ${entries.length} materialized → ${deduped.length} unique URLs`
-    );
-  }
-  return deduped;
-}
-async function discoverPluginClientPackages(projectRoot) {
-  const projectRequire = createRequire(path.join(projectRoot, "package.json"));
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  async function walk(pkgName) {
-    if (seen.has(pkgName)) return;
-    seen.add(pkgName);
-    try {
-      const mainPath = projectRequire.resolve(pkgName);
-      let pkgDir = path.dirname(mainPath);
-      while (pkgDir !== path.dirname(pkgDir)) {
-        const candidate = path.join(pkgDir, "package.json");
-        try {
-          const pkgJson = JSON.parse(await fs.readFile(candidate, "utf-8"));
-          if (pkgJson.name === pkgName) {
-            if (pkgJson.exports?.["./client"]) {
-              result.push(`${pkgName}/client`);
-            }
-            for (const dep of Object.keys(pkgJson.dependencies || {})) {
-              if (dep.startsWith("@jay-framework/")) {
-                await walk(dep);
-              }
-            }
-            break;
-          }
-        } catch {
-        }
-        pkgDir = path.dirname(pkgDir);
-      }
-    } catch {
-    }
-  }
-  try {
-    const projectPkg = JSON.parse(
-      await fs.readFile(path.join(projectRoot, "package.json"), "utf-8")
-    );
-    for (const dep of Object.keys(projectPkg.dependencies || {})) {
-      if (dep.startsWith("@jay-framework/")) {
-        await walk(dep);
-      }
-    }
-  } catch {
-  }
-  return result;
-}
-async function collectFiles(dir, base = "") {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  const paths = [];
-  for (const entry of entries) {
-    const rel = base ? `${base}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      paths.push(...await collectFiles(path.join(dir, entry.name), rel));
-    } else {
-      paths.push(rel);
-    }
-  }
-  return paths;
-}
-async function computeBuildHash(buildDir) {
-  const files = (await collectFiles(buildDir)).filter((f) => f !== "backend/build-metadata.json");
-  files.sort();
-  const hash = createHash("sha256");
-  for (const file of files) {
-    hash.update(file);
-    hash.update(await fs.readFile(path.join(buildDir, file)));
-  }
-  return hash.digest("hex").slice(0, 12);
-}
-async function buildVersion(options) {
-  const logger = getLogger();
-  const buildDir = path.join(options.buildRoot, `v${options.version}`);
-  const backendDir = path.join(buildDir, "backend");
-  const frontendDir = path.join(buildDir, "frontend");
-  logger.important(`[Build] Starting production build v${options.version}`);
-  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 serverOutputDir = path.join(backendDir, "server");
-  await buildServerCode(
-    entries,
-    { tsConfigFilePath: options.tsConfigFilePath },
-    serverOutputDir,
-    options.projectRoot
-  );
-  const pluginClientPackages = await discoverPluginClientPackages(options.projectRoot);
-  if (pluginClientPackages.length > 0) {
-    logger.important(`[Build] Plugin client packages: ${pluginClientPackages.join(", ")}`);
-  }
-  const sharedOutputDir = path.join(frontendDir, "shared");
-  const { manifest: sharedManifest } = await buildSharedChunks(
-    sharedOutputDir,
-    options.projectRoot,
-    options.minify ?? true,
-    pluginClientPackages
-  );
-  const { actions, plugins } = await discoverActions(
-    entries.actions,
-    serverOutputDir,
-    backendDir,
-    options.projectRoot
-  );
-  const { discoverPluginsWithInit, sortPluginsByDependencies } = await import("@jay-framework/stack-server-runtime");
-  try {
-    const pluginsWithInit = sortPluginsByDependencies(
-      await discoverPluginsWithInit({ projectRoot: options.projectRoot })
-    );
-    for (const pluginInit of pluginsWithInit) {
-      try {
-        let modulePath;
-        if (pluginInit.isLocal) {
-          const pluginDirName = path.basename(pluginInit.pluginPath);
-          modulePath = path.join(
-            serverOutputDir,
-            "plugins",
-            pluginDirName,
-            `${pluginInit.initModule}.js`
-          );
-        } else {
-          modulePath = pluginInit.packageName;
-        }
-        const pluginModule = await import(modulePath);
-        const init = pluginModule.init || pluginModule[pluginInit.initExport || "init"];
-        if (init?._serverInit) {
-          logger.info(`[Build] Running plugin init: ${pluginInit.name}`);
-          await init._serverInit();
-        }
-      } catch (err) {
-        logger.warn(`[Build] Plugin init failed: ${pluginInit.name}: ${err.message}`);
-      }
-    }
-  } catch {
-  }
-  if (entries.init) {
-    const initModulePath = path.join(serverOutputDir, "init.js");
-    try {
-      const initModule = await import(initModulePath);
-      const init = initModule.init || initModule.default;
-      if (init?._serverInit) {
-        logger.info("[Build] Running server init...");
-        await init._serverInit();
-      }
-    } catch (err) {
-      logger.error(`[Build] Failed to run init: ${err}`);
-      throw err;
-    }
-  }
-  const clientInits = [];
-  try {
-    const allPluginsWithInit = sortPluginsByDependencies(
-      await discoverPluginsWithInit({ projectRoot: options.projectRoot })
-    );
-    for (const pluginInit of allPluginsWithInit) {
-      if (pluginInit.isLocal) continue;
-      const clientImportPath = `${pluginInit.packageName}/client`;
-      try {
-        const clientModule = await import(clientImportPath);
-        const init = clientModule[pluginInit.initExport || "init"] || clientModule.init;
-        if (init?._clientInit) {
-          clientInits.push({
-            modulePath: clientImportPath,
-            exportName: pluginInit.initExport || "init",
-            key: pluginInit.name
-          });
-        }
-      } catch {
-      }
-    }
-  } catch (err) {
-    logger.warn(`[Build] Client init discovery failed: ${err.message}`);
-  }
-  if (clientInits.length > 0) {
-    logger.important(`[Build] Client inits: ${clientInits.map((ci) => ci.key).join(", ")}`);
-  }
-  if (entries.init) {
-    clientInits.push({
-      modulePath: entries.init,
-      exportName: "init",
-      key: "project"
-    });
-  }
-  const instanceCtx = {
-    projectRoot: options.projectRoot,
-    pagesRoot: options.pagesRoot,
-    buildDir,
-    backendDir,
-    frontendDir,
-    jayOptions: { tsConfigFilePath: options.tsConfigFilePath },
-    tsConfigFilePath: options.tsConfigFilePath,
-    minify: options.minify ?? true,
-    clientInits
-  };
-  const pluginRoutes = await scanPluginRoutes(options.projectRoot, routes);
-  const allRoutes = [...routes, ...pluginRoutes];
-  const routeEntries = allRoutes.map((route) => {
-    let serverModule = "";
-    if (route.compPath) {
-      if (route.componentExport) {
-        serverModule = route.compPath;
-      } else {
-        const relativePath = path.relative(options.projectRoot, route.compPath);
-        serverModule = relativePath.replace(/^src\//, "server/").replace(/\.ts$/, ".js").replace(/\[/g, "_").replace(/\]/g, "_");
-      }
-    }
-    const entry = buildRouteEntry(route, serverModule);
-    if (route.componentExport) {
-      entry.isPlugin = true;
-    }
-    return { route, entry };
-  });
-  let instanceCount = 0;
-  let totalExpected = 0;
-  function logInstance(routeName, params) {
-    instanceCount++;
-    const paramStr = Object.keys(params).length > 0 ? ` (${Object.entries(params).map(([k, v]) => `${k}=${v}`).join(", ")})` : "";
-    logger.important(`[Build] ${instanceCount}/${totalExpected} ${routeName}${paramStr}`);
-  }
-  async function loadPageModule(entry) {
-    if (!entry.serverModule) return {};
-    if (entry.isPlugin) return import(entry.serverModule);
-    return import(path.join(backendDir, entry.serverModule));
-  }
-  const routeInfos = routeEntries.map((re) => {
-    const optionalNames = re.route.segments.filter((s) => typeof s !== "string" && s.type === JayRouteParamType.optional).map((s) => s.name);
-    return {
-      rawRoute: re.route.rawRoute,
-      inferredParams: re.route.inferredParams,
-      optionalSegments: optionalNames.length > 0 ? new Set(optionalNames) : void 0,
-      hasDynamicParams: re.route.segments.some((s) => typeof s !== "string"),
-      routeEntry: re
-    };
-  });
-  const loadParamsCache = /* @__PURE__ */ new Map();
-  const loadParamsResults = /* @__PURE__ */ new Map();
-  for (const info of routeInfos) {
-    if (!info.hasDynamicParams) continue;
-    const { route, entry } = info.routeEntry;
-    let pageModule;
-    try {
-      pageModule = await loadPageModule(entry);
-    } catch (err) {
-      logger.error(`[Build] Failed to load page module ${entry.serverModule}: ${err}`);
-      continue;
-    }
-    const pageParts = await loadProductionPageParts(
-      route,
-      pageModule,
-      await fs.readFile(route.jayHtmlPath, "utf-8"),
-      options.projectRoot,
-      options.tsConfigFilePath,
-      serverOutputDir
-    );
-    const partsWithLoadParams = pageParts.parts.filter((p) => p.compDefinition?.loadParams);
-    if (partsWithLoadParams.length === 0) continue;
-    const paramParts = [];
-    for (const part of partsWithLoadParams) {
-      const propsKey = JSON.stringify(part.headlessProps ?? {});
-      const cacheKey = `${part.key ?? ""}:${propsKey}`;
-      if (!loadParamsCache.has(cacheKey)) {
-        logger.important(`[Build] Loading params for ${route.rawRoute}...`);
-        const partParams = [];
-        let batchIndex = 0;
-        for await (const batch of runLoadParams([part])) {
-          partParams.push(...batch);
-          batchIndex++;
-          if (batchIndex > 1) {
-            logger.important(`[Build]   ...${partParams.length} params so far`);
-          }
-        }
-        loadParamsCache.set(cacheKey, partParams);
-      }
-      const cached = loadParamsCache.get(cacheKey);
-      const keys = new Set(cached.flatMap((p) => Object.keys(p)));
-      paramParts.push({ keys, values: cached });
-    }
-    loadParamsResults.set(info, crossProductParams(paramParts));
-  }
-  const materialized = materializeRouteParams(routeInfos, loadParamsResults);
-  const deduped = dedupeByUrl(materialized);
-  totalExpected = deduped.length;
-  const byRoute = /* @__PURE__ */ new Map();
-  for (const materialized2 of deduped) {
-    const info = materialized2.route;
-    if (!byRoute.has(info)) byRoute.set(info, []);
-    byRoute.get(info).push(materialized2.params);
-  }
-  for (const [info] of byRoute) {
-    const { route, entry } = info.routeEntry;
-    if (!route.jayHtmlPath) continue;
-    const routeDir = route.rawRoute.replace(/^\//, "") || "index";
-    const frontendSafeRouteDir = routeDir.replace(/\[/g, "%5B").replace(/\]/g, "%5D");
-    const backendRouteDir = path.join(backendDir, "pre-rendered", routeDir);
-    const frontendRouteDir = path.join(frontendDir, "pages", frontendSafeRouteDir);
-    await fs.mkdir(backendRouteDir, { recursive: true });
-    await fs.mkdir(frontendRouteDir, { recursive: true });
-    const serverElementPath = path.join(backendRouteDir, "route.server-element.js");
-    try {
-      const seResult = await compileRouteServerElement(
-        route.jayHtmlPath,
-        serverElementPath,
-        options.projectRoot,
-        options.tsConfigFilePath,
-        options.minify ?? true
-      );
-      entry.serverElementPath = path.relative(backendDir, serverElementPath);
-      if (seResult.cssFile) {
-        const srcCss = path.join(backendRouteDir, seResult.cssFile);
-        const dstCss = path.join(frontendRouteDir, seResult.cssFile);
-        try {
-          await fs.rename(srcCss, dstCss);
-        } catch {
-          await fs.copyFile(srcCss, dstCss);
-          await fs.rm(srcCss, { force: true });
-        }
-        entry.routeCssPath = path.relative(frontendDir, dstCss);
-      }
-      if (seResult.cssImports?.length) {
-        entry.cssImports = seResult.cssImports;
-      }
-      if (seResult.headMeta) {
-        entry.headMeta = seResult.headMeta;
-        const robotsMeta = seResult.headMeta.meta?.find(
-          (m) => m.name === "robots" && m.content?.some((p) => p.kind === "static" && p.value.includes("noindex"))
-        );
-        if (robotsMeta) {
-          entry.noIndex = true;
-        }
-      }
-      logger.important(`[Build] Route server element: ${routeDir}`);
-    } catch (err) {
-      logger.error(`[Build] Route server element FAILED ${route.rawRoute}: ${err.message}`);
-    }
-    try {
-      const hydrateResult = await compileRouteHydrateScript(
-        route.jayHtmlPath,
-        frontendRouteDir,
-        options.projectRoot,
-        options.tsConfigFilePath,
-        options.minify ?? true
-      );
-      entry.routeHydratePath = path.relative(
-        frontendDir,
-        path.join(frontendRouteDir, hydrateResult.jsFile)
-      );
-      logger.important(`[Build] Route hydrate script: ${routeDir}`);
-    } catch (err) {
-      logger.error(`[Build] Route hydrate script FAILED ${route.rawRoute}: ${err.message}`);
-      continue;
-    }
-    try {
-      const ROUTE_HYDRATE_KEY = "jay-route-hydrate";
-      const exportName = route.componentExport || "page";
-      let pageModulePath = "";
-      if (route.compPath) {
-        if (route.componentExport) {
-          const pkgName = route.packageName || route.compPath;
-          pageModulePath = `${pkgName}/client`;
-        } else {
-          pageModulePath = "./" + path.relative(frontendRouteDir, route.compPath);
-        }
-      }
-      const pageParts = await loadProductionPageParts(
-        route,
-        {},
-        await fs.readFile(route.jayHtmlPath, "utf-8"),
-        options.projectRoot,
-        options.tsConfigFilePath,
-        path.join(backendDir, "server")
-      );
-      entry.trackByMap = pageParts.serverTrackByMap || pageParts.clientTrackByMap;
-      const entryPath = path.join(frontendRouteDir, "route.entry.ts");
-      await generateRouteHydrationEntry({
-        hydrateImport: ROUTE_HYDRATE_KEY,
-        pageModulePath,
-        pageExportName: exportName,
-        trackByMap: pageParts.clientTrackByMap || {},
-        outputPath: entryPath,
-        keyedParts: pageParts.keyedPartModules,
-        clientInits
-      });
-      const clientResult = await buildInstanceClient(
-        entryPath,
-        "route.client",
-        frontendRouteDir,
-        options.projectRoot,
-        { tsConfigFilePath: options.tsConfigFilePath },
-        options.minify ?? true,
-        options.pagesRoot,
-        buildDir
-      );
-      await fs.rm(entryPath, { force: true });
-      entry.routeClientBundlePath = path.relative(
-        frontendDir,
-        path.join(frontendRouteDir, clientResult.jsFile)
-      );
-      logger.important(`[Build] Route client bundle: ${routeDir}`);
-    } catch (err) {
-      logger.error(`[Build] Route client bundle FAILED ${route.rawRoute}: ${err.message}`);
-    }
-  }
-  for (const [info, paramsList] of byRoute) {
-    const { route, entry } = info.routeEntry;
-    let pageModule;
-    try {
-      pageModule = await loadPageModule(entry);
-    } catch (err) {
-      logger.error(`[Build] Failed to load page module ${entry.serverModule}: ${err}`);
-      continue;
-    }
-    if (paramsList.length > 1 || info.hasDynamicParams) {
-      logger.important(
-        `[Build] Route ${route.rawRoute}: ${paramsList.length} param combinations`
-      );
-    }
-    for (const params of paramsList) {
-      try {
-        const result = await buildInstance(
-          route,
-          params,
-          pageModule,
-          instanceCtx,
-          entry.serverElementPath,
-          entry.routeCssPath,
-          entry.routeHydratePath,
-          entry.routeClientBundlePath
-        );
-        if (result.status === "success") {
-          entry.instances.push(result.instanceEntry);
-          if (result.contracts.length > 0 && !entry.contracts) {
-            entry.contracts = result.contracts;
-          }
-          logInstance(route.rawRoute || "/", params);
-        } else {
-          logger.warn(
-            `[Build] Skipped ${route.rawRoute} (${JSON.stringify(params)}): ${result.reason}`
-          );
-          totalExpected--;
-        }
-      } catch (err) {
-        instanceCount++;
-        logger.error(
-          `[Build] ${instanceCount}/${totalExpected} FAILED ${route.rawRoute || "/"} (${JSON.stringify(params)}): ${err.message}`
-        );
-      }
-    }
-  }
-  const manifest = {
-    version: options.version,
-    projectRoot: options.projectRoot,
-    sharedManifest,
-    routes: routeEntries.map((r) => r.entry),
-    actions,
-    plugins
-  };
-  await writeRouteManifest(manifest, backendDir);
-  const publicFolder = path.join(options.projectRoot, "public");
-  try {
-    await fs.access(publicFolder);
-    await fs.cp(publicFolder, frontendDir, { recursive: true });
-    logger.info("[Build] Copied public/ contents to frontend/");
-  } catch {
-  }
-  if (options.siteBaseUrl) {
-    const sitemapPath = path.join(frontendDir, "sitemap.xml");
-    const urlCount = await generateSitemap(manifest, options.siteBaseUrl, sitemapPath);
-    logger.important(`[Build] Sitemap generated: ${urlCount} URLs`);
-  }
-  const sourceHash = await computeBuildHash(buildDir);
-  const metadata = {
-    version: options.version,
-    sourceHash,
-    buildTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    nodeVersion: process.version,
-    instanceCount
-  };
-  await fs.writeFile(
-    path.join(backendDir, "build-metadata.json"),
-    JSON.stringify(metadata, null, 2)
-  );
-  logger.important(
-    `[Build] Done! ${instanceCount} instances built in ${buildDir} (hash: ${sourceHash})`
-  );
-  return manifest;
-}
 function toFetchRequest(req) {
   const url = new URL(req.url || "/", `http://${req.headers.host}`);
   const headers = new Headers();
@@ -1627,6 +267,107 @@ async function discoverWebhooks(projectRoot, serverBuildDir) {
   }
   return webhooks;
 }
+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 rebuildInstance(route, params, backendDir, rebuildSuffix) {
+  const logger = getLogger();
+  const routeDir = route.pattern.replace(/^\//, "") || "index";
+  const paramHash = hashParams(params, rebuildSuffix);
+  const instanceId = `page${paramHash}`;
+  const backendInstanceDir = path.join(backendDir, "pre-rendered", routeDir);
+  await fs.mkdir(backendInstanceDir, { recursive: true });
+  const pagePartsConfigPath = path.join(backendInstanceDir, "page-parts.json");
+  const artifacts = new FilesystemArtifactStore(backendDir);
+  let pageParts;
+  try {
+    pageParts = await loadPagePartsFromConfig(
+      path.relative(backendDir, pagePartsConfigPath),
+      artifacts
+    );
+  } catch (err) {
+    return { status: "skipped", reason: `Failed to load page-parts.json: ${err.message}` };
+  }
+  const slowPhase = new DevSlowlyChangingPhase();
+  const slowResult = await slowPhase.runSlowlyForPage(
+    params,
+    { params },
+    pageParts.parts,
+    pageParts.discoveredInstances,
+    pageParts.headlessInstanceComponents
+  );
+  if (slowResult.kind !== "PhaseOutput") {
+    if (slowResult.kind === "ClientError" || slowResult.kind === "Redirect") {
+      return {
+        status: "skipped",
+        reason: `${slowResult.kind} ${slowResult.status ?? ""} ${slowResult.message ?? ""}`.trim()
+      };
+    }
+    return { status: "skipped", reason: `Slow render returned: ${slowResult.kind}` };
+  }
+  const slowViewState = slowResult.rendered;
+  const carryForward = slowResult.carryForward;
+  if (pageParts.discoveredInstances && pageParts.discoveredInstances.length > 0 && pageParts.headlessInstanceComponents.length > 0) {
+    const instanceSlowResult = await slowRenderInstances(
+      pageParts.discoveredInstances,
+      pageParts.headlessInstanceComponents,
+      {
+        pageViewState: slowViewState,
+        pageParams: params,
+        pageProps: { language: "en", url: "" }
+      }
+    );
+    if (instanceSlowResult) {
+      const existingInstances = carryForward.__instances || {
+        discovered: [],
+        carryForwards: {}
+      };
+      carryForward.__instances = {
+        discovered: [
+          ...existingInstances.discovered,
+          ...instanceSlowResult.instancePhaseData.discovered
+        ],
+        carryForwards: {
+          ...existingInstances.carryForwards,
+          ...instanceSlowResult.instancePhaseData.carryForwards
+        },
+        slowViewStates: {
+          ...existingInstances.slowViewStates || {},
+          ...instanceSlowResult.instancePhaseData.slowViewStates
+        }
+      };
+    }
+  }
+  if (pageParts.forEachInstances && pageParts.forEachInstances.length > 0) {
+    const existingInstances = carryForward.__instances || {
+      discovered: [],
+      carryForwards: {}
+    };
+    existingInstances.forEachInstances = pageParts.forEachInstances;
+    carryForward.__instances = existingInstances;
+  }
+  const cachePath = path.join(backendInstanceDir, `${instanceId}.cache.json`);
+  await fs.writeFile(cachePath, JSON.stringify({ slowViewState, carryForward }), "utf-8");
+  logger.info(`[Rebuild] Instance data: ${routeDir}/${instanceId}`);
+  const instanceEntry = {
+    params,
+    cachePath: path.relative(backendDir, cachePath),
+    serverElementPath: route.serverElementPath || "",
+    clientBundlePath: route.routeClientBundlePath || "",
+    clientCssPath: route.routeCssPath
+  };
+  return { status: "success", instanceEntry };
+}
 function resolveContractToRoutes(manifest, contractName) {
   return manifest.routes.filter((r) => r.contracts && r.contracts.includes(contractName));
 }
@@ -1652,17 +393,6 @@ async function rebuild(options) {
   const frontendDir = path.join(buildDir, "frontend");
   await initializeServices(backendDir, options.projectRoot, "Rebuild");
   const rebuildSuffix = Date.now().toString(36);
-  const instanceCtx = {
-    projectRoot: options.projectRoot,
-    pagesRoot: options.pagesRoot,
-    buildDir,
-    backendDir,
-    frontendDir,
-    jayOptions: { tsConfigFilePath: options.tsConfigFilePath },
-    tsConfigFilePath: options.tsConfigFilePath,
-    minify: options.minify ?? true,
-    rebuildSuffix
-  };
   const result = { affected: 0, rebuilt: 0, errors: [] };
   const orphanedFiles = [];
   for (const route of affectedRoutes) {
@@ -1674,25 +404,13 @@ async function rebuild(options) {
       result.affected++;
       const params = instance.params;
       const oldFiles = collectInstanceFiles(instance);
-      let pageModule;
-      try {
-        pageModule = await loadRouteModule(route, buildDir);
-      } catch (err) {
-        result.errors.push({
-          route: route.pattern,
-          params,
-          error: `Failed to load module: ${err.message}`
-        });
-        continue;
-      }
-      const jayRoute = await resolveJayRouteFromManifest(route, options);
       try {
-        const buildResult = await buildInstance(jayRoute, params, pageModule, instanceCtx);
+        const buildResult = await rebuildInstance(route, params, backendDir, rebuildSuffix);
         if (buildResult.status !== "success") {
           result.errors.push({
             route: route.pattern,
             params,
-            error: buildResult.reason
+            error: buildResult.reason || "Unknown error"
           });
           continue;
         }
@@ -1793,41 +511,6 @@ async function rebuildContract(options) {
     target: { mode: "contract", contractName: options.contractName, params: options.params }
   });
 }
-async function loadRouteModule(route, buildDir) {
-  if (!route.serverModule) return {};
-  if (route.isPlugin) return import(route.serverModule);
-  return import(path.join(buildDir, route.serverModule));
-}
-async function resolveJayRouteFromManifest(route, options) {
-  const routeDir = route.pattern.replace(/^\//, "") || "index";
-  const jayHtmlPath = path.join(options.pagesRoot, routeDir, "page.jay-html");
-  let resolvedJayHtmlPath = jayHtmlPath;
-  if (route.isPlugin && route.serverModule) {
-    try {
-      const pluginModule = await import(route.serverModule);
-      const comp = pluginModule[route.componentExport || "page"];
-      if (comp?.jayHtmlPath) {
-        resolvedJayHtmlPath = comp.jayHtmlPath;
-      }
-    } catch {
-    }
-  }
-  return {
-    rawRoute: route.pattern,
-    segments: route.segments.map((s) => {
-      if (s.type === "static") return s.value;
-      return { name: s.value, type: segmentTypeMap[s.type] };
-    }),
-    jayHtmlPath: resolvedJayHtmlPath,
-    compPath: route.isPlugin ? route.serverModule : void 0,
-    componentExport: route.componentExport
-  };
-}
-const segmentTypeMap = {
-  param: 0,
-  catchAll: 1,
-  optional: 2
-};
 function paramsMatch(instanceParams, targetParams) {
   return Object.entries(targetParams).every(([key, value]) => instanceParams[key] === value);
 }
@@ -2006,7 +689,6 @@ function readBody(req) {
 }
 export {
   FilesystemArtifactStore,
-  buildVersion,
   cleanupOrphanedFiles,
   fetchActionRequest,
   fetchPageRequest,
@@ -2015,6 +697,7 @@ export {
   initializeServices,
   c as initializeServicesFromModules,
   isActionRequest,
+  loadPagePartsFromConfig,
   matchRequest,
   rebuild,
   rebuildContract,