@jay-framework/production-server 0.17.4 → 0.18.1

package/dist/index.js

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 import { build } from "vite";
 import { jayStackCompiler, extractActionsFromSource } from "@jay-framework/compiler-jay-stack";
 import { scanRoutes, JayRouteParamType, parseRouteSegments } from "@jay-framework/stack-route-scanner";
@@ -11,17 +5,21 @@ import { getLogger } from "@jay-framework/logger";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { createRequire } from "node:module";
-import { parseJayFile, JAY_IMPORT_RESOLVER, injectHeadfullFSTemplates, discoverHeadlessInstances, assignCoordinatesToJayHtml, generateServerElementFile, parseContract, slowRenderTransform, resolveHeadlessInstances } from "@jay-framework/compiler-jay-html";
-import { DevSlowlyChangingPhase, slowRenderInstances, scanPlugins, runLoadParams, renderFastChangingData, mergeHeadTags, serializeHeadTags, getClientInitData, actionRegistry, setClientInitData, parseCookies } from "@jay-framework/stack-server-runtime";
-import { checkValidationErrors } from "@jay-framework/compiler-shared";
-import { jayRuntime } from "@jay-framework/vite-plugin";
+import { DevSlowlyChangingPhase, slowRenderInstances, scanPlugins, runLoadParams, parseCookies } from "@jay-framework/stack-server-runtime";
+import { l as loadProductionPageParts, g as buildPagePartsConfig, d as initializeServices, r as registerActionsFromManifest, i as isActionRequest, a as fetchActionRequest, c as fetchStaticFile, m as matchRequest, f as fetchPageRequest, F as FilesystemArtifactStore } from "./init-services-F6Svgfm9.js";
+import { e, b } from "./init-services-F6Svgfm9.js";
 import crypto 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 { deepMergeViewStates } from "@jay-framework/view-state-merge";
-import { asyncSwapScript } from "@jay-framework/ssr-runtime";
-import { isJayAction, isJayStreamAction, isJayWebhook } from "@jay-framework/fullstack-component";
+import { isJayWebhook } from "@jay-framework/fullstack-component";
+import "@jay-framework/view-state-merge";
+import "@jay-framework/ssr-runtime";
 async function discoverServerEntries(projectRoot, pagesRoot) {
   const logger = getLogger();
   const routes = await scanRoutes(pagesRoot, {
@@ -209,384 +207,6 @@ async function parseViteManifest(outputDir, packages) {
   await fs.rm(viteManifestPath, { force: true });
   return manifest;
 }
-const require2 = 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.dirname(route.jayHtmlPath);
-  const fileName = path.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.resolve(dirName, module);
-      if (serverBuildDir) {
-        const relativeToSrc = path.relative(path.join(projectRoot, "src"), sourcePath);
-        let compiledPath = path.join(serverBuildDir, relativeToSrc);
-        compiledPath = compiledPath.replace(/\.ts$/, ".js");
-        if (!compiledPath.endsWith(".js")) {
-          const indexPath = path.join(compiledPath, "index.js");
-          try {
-            await fs.access(indexPath);
-            compiledPath = indexPath;
-          } catch {
-            compiledPath += ".js";
-          }
-        }
-        modulePath = compiledPath;
-      } else {
-        modulePath = sourcePath;
-      }
-    } else {
-      modulePath = require2.resolve(module, { paths: [dirName] });
-    }
-    const headlessModule = await import(modulePath);
-    const headlessCompDef = headlessModule[name];
-    if (headlessImport.key) {
-      const clientModulePath = isLocalModule ? path.resolve(dirName, module) : `${module}/client`;
-      const ci = headlessImport.contract ? { contractName: headlessImport.contract.name, metadata: headlessImport.metadata } : void 0;
-      parts.push({
-        key: headlessImport.key,
-        compDefinition: headlessCompDef,
-        clientImport: "",
-        clientPart: "",
-        contractInfo: ci
-      });
-      keyedPartModules.push({
-        key: headlessImport.key,
-        modulePath: clientModulePath,
-        exportName: name
-      });
-      headlessModuleInfos.push({
-        modulePath,
-        exportName: name,
-        isLocal: isLocalModule,
-        key: headlessImport.key,
-        contractInfo: ci
-      });
-    }
-    if (!headlessImport.key && headlessImport.contract) {
-      headlessInstanceComponents.push({
-        contractName: headlessImport.contractName,
-        compDefinition: headlessCompDef,
-        contract: headlessImport.contract
-      });
-      headlessModuleInfos.push({
-        modulePath,
-        exportName: name,
-        isLocal: isLocalModule,
-        contractName: headlessImport.contractName,
-        propNames: headlessImport.contract.props?.map((p) => p.name) ?? []
-      });
-    }
-  }
-  const headlessContracts = (jayHtml.headlessImports ?? []).filter((hi) => hi.contract && hi.key).map((hi) => ({
-    key: hi.key,
-    contract: hi.contract,
-    contractPath: hi.contractPath
-  }));
-  const jayHtmlForDiscovery = injectHeadfullFSTemplates(
-    jayHtmlContent,
-    dirName,
-    JAY_IMPORT_RESOLVER
-  );
-  let discoveredInstances = [];
-  let forEachInstances = [];
-  if (headlessInstanceComponents.length > 0) {
-    const firstDiscovery = discoverHeadlessInstances(jayHtmlForDiscovery);
-    const contractNames = new Set(headlessInstanceComponents.map((c) => c.contractName));
-    const withCoords = assignCoordinatesToJayHtml(
-      firstDiscovery.preRenderedJayHtml,
-      contractNames
-    );
-    const finalDiscovery = discoverHeadlessInstances(withCoords);
-    discoveredInstances = finalDiscovery.instances;
-    forEachInstances = finalDiscovery.forEachInstances;
-  }
-  return {
-    parts,
-    headlessContracts,
-    headlessInstanceComponents,
-    discoveredInstances,
-    forEachInstances,
-    keyedPartModules,
-    headlessModuleInfos,
-    serverTrackByMap: jayHtml.serverTrackByMap,
-    clientTrackByMap: jayHtml.clientTrackByMap
-  };
-}
-function buildPagePartsConfig(pageParts, pageServerModule, pageExportName, buildDir, pageIsPlugin = false) {
-  const parts = [];
-  if (pageServerModule) {
-    parts.push({
-      modulePath: pageServerModule,
-      exportName: pageExportName,
-      source: pageIsPlugin ? "npm" : "local"
-    });
-  }
-  for (const info of pageParts.headlessModuleInfos) {
-    if (info.key) {
-      parts.push({
-        modulePath: info.isLocal ? path.relative(buildDir, info.modulePath) : info.modulePath,
-        exportName: info.exportName,
-        source: info.isLocal ? "local" : "npm",
-        key: info.key,
-        contractInfo: info.contractInfo
-      });
-    }
-  }
-  const instanceComponents = [];
-  for (const info of pageParts.headlessModuleInfos) {
-    if (info.contractName) {
-      instanceComponents.push({
-        modulePath: info.isLocal ? path.relative(buildDir, info.modulePath) : info.modulePath,
-        exportName: info.exportName,
-        source: info.isLocal ? "local" : "npm",
-        contractName: info.contractName,
-        propNames: info.propNames ?? []
-      });
-    }
-  }
-  return {
-    parts,
-    instanceComponents,
-    forEachInstances: pageParts.forEachInstances.map((fi) => ({
-      contractName: fi.contractName,
-      forEachPath: fi.forEachPath,
-      trackBy: fi.trackBy,
-      propBindings: fi.propBindings,
-      coordinateSuffix: fi.coordinateSuffix
-    }))
-  };
-}
-async function loadPagePartsFromConfig(configPath, buildDir) {
-  const config = JSON.parse(await fs.readFile(configPath, "utf-8"));
-  async function importModule(entry) {
-    if (!entry.modulePath) {
-      throw new Error(
-        `Empty modulePath in page-parts.json for "${entry.exportName}" (source: ${entry.source}). Rebuild required.`
-      );
-    }
-    if (entry.source === "local") {
-      return import(path.join(buildDir, entry.modulePath));
-    }
-    return import(entry.modulePath);
-  }
-  const parts = [];
-  for (const entry of config.parts) {
-    const mod = await importModule(entry);
-    parts.push({
-      compDefinition: mod[entry.exportName] ?? mod.default,
-      key: entry.key,
-      clientImport: "",
-      clientPart: "",
-      contractInfo: entry.contractInfo
-    });
-  }
-  const headlessInstanceComponents = [];
-  for (const entry of config.instanceComponents) {
-    const mod = await importModule(entry);
-    const serveTimeContract = {
-      props: entry.propNames.map((name) => ({ name }))
-    };
-    headlessInstanceComponents.push({
-      contractName: entry.contractName,
-      compDefinition: mod[entry.exportName] ?? mod.default,
-      contract: serveTimeContract
-    });
-  }
-  return {
-    parts,
-    headlessContracts: [],
-    headlessInstanceComponents,
-    discoveredInstances: [],
-    forEachInstances: config.forEachInstances,
-    keyedPartModules: [],
-    headlessModuleInfos: []
-  };
-}
-async function compileServerElement(jayHtmlContent, jayHtmlFilename, jayHtmlDir, outputPath, projectRoot, tsConfigFilePath, sourceDir) {
-  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,
-    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;
-  const css = parsedJayFile.css;
-  if (css) {
-    const cssFilename = path.basename(outputPath, ".server-element.js") + ".css";
-    const cssPath = path.join(outputDir, cssFilename);
-    await fs.writeFile(cssPath, css, "utf-8");
-    cssFile = cssFilename;
-  }
-  getLogger().info(`[Build] Compiled server element: ${path.basename(outputPath)}`);
-  return { cssFile };
-}
-async function generateHydrationEntry(options) {
-  const {
-    jayHtmlPath,
-    pageModulePath,
-    pageExportName = "page",
-    slowViewState,
-    trackByMap,
-    outputPath,
-    keyedParts = [],
-    clientInits = []
-  } = options;
-  const hydrateImport = `${jayHtmlPath}?jay-hydrate`;
-  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 hasClientInit = clientInits.length > 0;
-  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 slowViewState = ${JSON.stringify(slowViewState)};
-const trackByMap = ${JSON.stringify(trackByMap)};
-
-export async function init(fastViewState, fastCarryForward${hasClientInit ? ", 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 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,
-    plugins: [...jayStackCompiler(fullJayOptions)],
-    build: {
-      outDir: outputDir,
-      emptyOutDir: false,
-      minify,
-      manifest: `${instanceId}-manifest.json`,
-      rollupOptions: {
-        input: { [instanceId]: hydrateEntryPath },
-        external: (id) => id.startsWith("@jay-framework/"),
-        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 resolvePackageNameForRoute(compPath) {
-  const dir = path.dirname(compPath);
-  for (const candidate of [dir, path.join(dir, "..")]) {
-    try {
-      const pkgJson = JSON.parse(
-        fs$1.readFileSync(path.join(candidate, "package.json"), "utf-8")
-      );
-      if (pkgJson.name)
-        return pkgJson.name;
-    } catch {
-    }
-  }
-  return void 0;
-}
 function hashParams(params, suffix) {
   const sorted = Object.keys(params).sort().reduce(
     (acc, key) => {
@@ -601,7 +221,7 @@ function hashParams(params, suffix) {
   const input = suffix ? json + ":" + suffix : json;
   return "_" + crypto.createHash("md5").update(input).digest("hex").substring(0, 8);
 }
-async function buildInstance(route, params, pageModule, ctx) {
+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);
@@ -611,7 +231,7 @@ async function buildInstance(route, params, pageModule, ctx) {
   await fs.mkdir(backendInstanceDir, { recursive: true });
   await fs.mkdir(frontendInstanceDir, { recursive: true });
   const jayHtmlContent = await fs.readFile(route.jayHtmlPath, "utf-8");
-  const sourceDir = path.dirname(route.jayHtmlPath);
+  path.dirname(route.jayHtmlPath);
   const serverBuildDir = path.join(ctx.backendDir, "server");
   const pageParts = await loadProductionPageParts(
     route,
@@ -636,7 +256,7 @@ async function buildInstance(route, params, pageModule, ctx) {
     let pageIsPlugin = false;
     if (route.compPath) {
       if (route.componentExport) {
-        pageServerModule = route.compPath;
+        pageServerModule = route.packageName || route.compPath;
         pageIsPlugin = true;
       } else {
         const relativePath = path.relative(ctx.projectRoot, route.compPath);
@@ -675,197 +295,57 @@ async function buildInstance(route, params, pageModule, ctx) {
   }
   const slowViewState = slowResult.rendered;
   const carryForward = slowResult.carryForward;
-  let contract;
-  const contractPath = route.jayHtmlPath.replace(".jay-html", ".jay-contract");
-  try {
-    const contractContent = await fs.readFile(contractPath, "utf-8");
-    const parseResult = parseContract(contractContent, path.basename(contractPath));
-    if (parseResult.val)
-      contract = parseResult.val;
-  } catch {
-  }
-  const jayHtmlWithTemplates = injectHeadfullFSTemplates(
-    jayHtmlContent,
-    sourceDir,
-    JAY_IMPORT_RESOLVER
-  );
-  const transformResult = slowRenderTransform({
-    jayHtmlContent: jayHtmlWithTemplates,
-    slowViewState,
-    contract,
-    headlessContracts: pageParts.headlessContracts,
-    sourceDir,
-    importResolver: JAY_IMPORT_RESOLVER
-  });
-  if (!transformResult.val) {
-    throw new Error(
-      `Slow render transform failed for ${route.rawRoute}: ${transformResult.validations.join(", ")}`
+  if (pageParts.discoveredInstances.length > 0 && pageParts.headlessInstanceComponents.length > 0) {
+    const slowResult2 = await slowRenderInstances(
+      pageParts.discoveredInstances,
+      pageParts.headlessInstanceComponents
     );
-  }
-  let preRenderedJayHtml = transformResult.val.preRenderedJayHtml;
-  if (pageParts.headlessInstanceComponents.length > 0) {
-    const discoveryResult = discoverHeadlessInstances(preRenderedJayHtml);
-    const htmlWithRefs = discoveryResult.preRenderedJayHtml;
-    const contractNames = new Set(
-      pageParts.headlessInstanceComponents.map((c) => c.contractName)
-    );
-    preRenderedJayHtml = assignCoordinatesToJayHtml(htmlWithRefs, contractNames);
-    const finalDiscovery = discoverHeadlessInstances(preRenderedJayHtml);
-    if (finalDiscovery.instances.length > 0) {
-      const slowResult2 = await slowRenderInstances(
-        finalDiscovery.instances,
-        pageParts.headlessInstanceComponents
-      );
-      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
-          }
-        };
-        carryForward.__instanceSlowViewStates = {
-          ...carryForward.__instanceSlowViewStates || {},
-          ...Object.fromEntries(
-            slowResult2.resolvedData.map((d) => [
-              d.coordinate.join("/"),
-              d.slowViewState
-            ])
-          )
-        };
-        carryForward.__instanceResolvedData = [
-          ...carryForward.__instanceResolvedData || [],
-          ...slowResult2.resolvedData
-        ];
-        const pass2Result = resolveHeadlessInstances(
-          preRenderedJayHtml,
-          slowResult2.resolvedData,
-          JAY_IMPORT_RESOLVER
-        );
-        if (pass2Result.val) {
-          preRenderedJayHtml = pass2Result.val;
+    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
         }
-      }
+      };
     }
   }
-  preRenderedJayHtml = preRenderedJayHtml.replace(
-    /(<script\s+type="application\/jay-headfull"[^>]*\s)(src="([^"]*)")/g,
-    (_match, prefix, _srcAttr, srcVal) => {
-      if (path.isAbsolute(srcVal))
-        return prefix + `src="${srcVal}"`;
-      const abs = path.resolve(sourceDir, srcVal);
-      let rel = path.relative(backendInstanceDir, abs);
-      if (!rel.startsWith("."))
-        rel = "./" + rel;
-      return prefix + `src="${rel}"`;
-    }
-  );
-  preRenderedJayHtml = preRenderedJayHtml.replace(
-    /(<script\s+type="application\/jay-headfull"[^>]*\s)(contract="([^"]*)")/g,
-    (_match, prefix, _contractAttr, contractVal) => {
-      if (path.isAbsolute(contractVal))
-        return prefix + `contract="${contractVal}"`;
-      const abs = path.resolve(sourceDir, contractVal);
-      let rel = path.relative(backendInstanceDir, abs);
-      if (!rel.startsWith("."))
-        rel = "./" + rel;
-      return prefix + `contract="${rel}"`;
-    }
-  );
-  const preRenderedPath = path.join(backendInstanceDir, `${instanceId}.jay-html`);
-  await fs.writeFile(preRenderedPath, preRenderedJayHtml, "utf-8");
-  const cacheMetadataPath = path.join(backendInstanceDir, `${instanceId}.cache.json`);
+  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(
-    cacheMetadataPath,
+    cachePath,
     JSON.stringify({
       slowViewState,
       carryForward
     }),
     "utf-8"
   );
-  logger.info(`[Build] Pre-rendered: ${routeDir}/${instanceId}`);
-  const serverElementPath = path.join(backendInstanceDir, `${instanceId}.server-element.js`);
-  const serverElementResult = await compileServerElement(
-    preRenderedJayHtml,
-    `${instanceId}.jay-html`,
-    backendInstanceDir,
-    serverElementPath,
-    ctx.projectRoot,
-    ctx.tsConfigFilePath,
-    sourceDir
-  );
-  const hydrateEntryPath = path.join(backendInstanceDir, `${instanceId}.hydrate-entry.ts`);
-  const relativeJayHtmlPath = path.relative(backendInstanceDir, preRenderedPath);
-  let pageModulePath;
-  let pageExportName;
-  if (route.componentExport) {
-    const pkgName = resolvePackageNameForRoute(route.compPath);
-    pageModulePath = pkgName ? `${pkgName}/client` : "./" + path.relative(backendInstanceDir, route.compPath);
-    pageExportName = route.componentExport;
-  } else if (route.compPath) {
-    pageModulePath = "./" + path.relative(backendInstanceDir, route.compPath);
-    pageExportName = "page";
-  } else {
-    pageModulePath = "";
-    pageExportName = "";
-  }
-  if (pageParts.keyedPartModules.length > 0) {
-    logger.info(
-      `[Build] Keyed parts for ${routeDir}: ${pageParts.keyedPartModules.map((p) => p.key).join(", ")}`
-    );
-  }
-  await generateHydrationEntry({
-    jayHtmlPath: "./" + relativeJayHtmlPath,
-    pageModulePath,
-    pageExportName,
-    slowViewState,
-    trackByMap: pageParts.clientTrackByMap || {},
-    outputPath: hydrateEntryPath,
-    keyedParts: pageParts.keyedPartModules,
-    clientInits: ctx.clientInits
-  });
-  const clientResult = await buildInstanceClient(
-    hydrateEntryPath,
-    instanceId,
-    frontendInstanceDir,
-    ctx.projectRoot,
-    ctx.jayOptions,
-    ctx.minify ?? true,
-    ctx.pagesRoot,
-    ctx.buildDir
-  );
-  await fs.rm(hydrateEntryPath, { force: true });
-  const cssFile = clientResult.cssFile || serverElementResult.cssFile;
-  if (serverElementResult.cssFile && !clientResult.cssFile) {
-    const srcCss = path.join(backendInstanceDir, serverElementResult.cssFile);
-    const dstCss = path.join(frontendInstanceDir, serverElementResult.cssFile);
-    try {
-      await fs.rename(srcCss, dstCss);
-    } catch {
-      await fs.copyFile(srcCss, dstCss);
-      await fs.rm(srcCss, { force: true });
-    }
-  }
+  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,
-    preRenderedPath: path.relative(ctx.backendDir, preRenderedPath),
+    cachePath: path.relative(ctx.backendDir, cachePath),
     serverElementPath: path.relative(ctx.backendDir, serverElementPath),
-    clientBundlePath: path.relative(
-      ctx.frontendDir,
-      path.join(frontendInstanceDir, clientResult.jsFile)
-    ),
-    clientCssPath: cssFile ? path.relative(ctx.frontendDir, path.join(frontendInstanceDir, cssFile)) : void 0
+    clientBundlePath: routeClientBundlePath || "",
+    clientCssPath: routeCssPath
   };
   return { status: "success", instanceEntry, slowViewState, carryForward, contracts };
 }
@@ -979,53 +459,319 @@ async function scanPluginRoutes(projectRoot, projectRoutes) {
         rawRoute: route.path,
         jayHtmlPath,
         compPath,
-        componentExport
+        componentExport,
+        packageName: plugin.packageName
       });
       logger.info(`[Routes] Plugin "${plugin.manifest.name}" provides route ${route.path}`);
     }
   }
   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 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,
+    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 cssFilename = path.basename(outputPath, ".server-element.js") + ".css";
+    const cssPath = path.join(outputDir, cssFilename);
+    if (minifyCss) {
+      const minified = await transform(css, { loader: "css", minify: true });
+      await fs.writeFile(cssPath, minified.code, "utf-8");
+    } else {
+      await fs.writeFile(cssPath, css, "utf-8");
+    }
+    cssFile = cssFilename;
+  }
+  getLogger().info(`[Build] Compiled server element: ${path.basename(outputPath)}`);
+  return { cssFile, cssImports };
+}
+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,
+    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)}`);
 }
-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 {
+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,
+    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}`);
   }
-  return path.join(pluginPath, "dist", "index.js");
+  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)
@@ -1049,8 +795,8 @@ function crossProductParams(parts) {
     const next = parts[i].values;
     const combined = [];
     for (const a of result) {
-      for (const b of next) {
-        combined.push({ ...a, ...b });
+      for (const b2 of next) {
+        combined.push({ ...a, ...b2 });
       }
     }
     result = combined;
@@ -1389,6 +1135,112 @@ async function buildVersion(options) {
       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;
+      }
+      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;
@@ -1405,7 +1257,16 @@ async function buildVersion(options) {
     }
     for (const params of paramsList) {
       try {
-        const result = await buildInstance(route, params, pageModule, instanceCtx);
+        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) {
@@ -1458,516 +1319,6 @@ async function buildVersion(options) {
   logger.important(`[Build] Done! ${instanceCount} instances built in ${buildDir}`);
   return manifest;
 }
-const CACHE_TAG_START = '<script type="application/jay-cache">';
-const CACHE_TAG_END = "<\/script>";
-class FilesystemArtifactStore {
-  constructor(basePath) {
-    __publicField(this, "manifestCache");
-    __publicField(this, "metadataMtime");
-    __publicField(this, "moduleCache", /* @__PURE__ */ new Map());
-    this.basePath = basePath;
-  }
-  async readManifest() {
-    const metadataPath = path.join(this.basePath, "build-metadata.json");
-    const manifestPath = path.join(this.basePath, "route-manifest.json");
-    try {
-      const metaStat = await fs.stat(metadataPath);
-      if (this.manifestCache && this.metadataMtime === metaStat.mtimeMs) {
-        return this.manifestCache.manifest;
-      }
-      this.metadataMtime = metaStat.mtimeMs;
-    } catch {
-    }
-    const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
-    const manifestStat = await fs.stat(manifestPath);
-    this.manifestCache = { manifest, mtime: manifestStat.mtimeMs };
-    return manifest;
-  }
-  async readPreRenderedHtml(relativePath) {
-    const fullPath = path.join(this.basePath, relativePath);
-    const content = await fs.readFile(fullPath, "utf-8");
-    const cachePath = fullPath.replace(/\.jay-html$/, ".cache.json");
-    try {
-      const cacheData = JSON.parse(await fs.readFile(cachePath, "utf-8"));
-      return {
-        content,
-        slowViewState: cacheData.slowViewState || {},
-        carryForward: cacheData.carryForward || {}
-      };
-    } catch {
-      return extractCacheMetadata(content);
-    }
-  }
-  async loadServerElement(relativePath) {
-    return this.loadModule(relativePath);
-  }
-  async loadPageModule(relativePath) {
-    return this.loadModule(relativePath);
-  }
-  async readRawFile(relativePath) {
-    const fullPath = path.join(this.basePath, relativePath);
-    return await fs.readFile(fullPath, "utf-8");
-  }
-  getAssetPath(relativePath) {
-    return path.join(this.basePath, relativePath);
-  }
-  getBuildDir() {
-    return this.basePath;
-  }
-  async loadModule(relativePath) {
-    const fullPath = path.join(this.basePath, relativePath);
-    const stat = await fs.stat(fullPath);
-    const cached = this.moduleCache.get(relativePath);
-    if (cached && stat.mtimeMs === cached.mtime) {
-      return cached.module;
-    }
-    const mod = await import(fullPath + "?t=" + stat.mtimeMs);
-    this.moduleCache.set(relativePath, { module: mod, mtime: stat.mtimeMs });
-    return mod;
-  }
-}
-function extractCacheMetadata(fileContent) {
-  const startIdx = fileContent.indexOf(CACHE_TAG_START);
-  if (startIdx === -1) {
-    return { content: fileContent, slowViewState: {}, carryForward: {} };
-  }
-  const jsonStart = startIdx + CACHE_TAG_START.length;
-  const endIdx = fileContent.indexOf(CACHE_TAG_END, jsonStart);
-  if (endIdx === -1) {
-    return { content: fileContent, slowViewState: {}, carryForward: {} };
-  }
-  const jsonStr = fileContent.substring(jsonStart, endIdx);
-  const metadata = JSON.parse(jsonStr);
-  const tagEnd = endIdx + CACHE_TAG_END.length;
-  const afterTag = fileContent[tagEnd] === "\n" ? tagEnd + 1 : tagEnd;
-  const content = fileContent.substring(0, startIdx) + fileContent.substring(afterTag);
-  return {
-    content,
-    slowViewState: metadata.slowViewState || {},
-    carryForward: metadata.carryForward || {}
-  };
-}
-function matchRequest(manifest, pathname) {
-  const urlSegments = pathname.split("/").filter((s) => s.length > 0);
-  for (const route of manifest.routes) {
-    const params = matchSegments(route.segments, urlSegments);
-    if (params) {
-      const instance = findInstance(route, params);
-      if (instance) {
-        return { route, instance, params, pathname };
-      }
-    }
-  }
-  return void 0;
-}
-function matchSegments(routeSegments, urlSegments) {
-  const params = {};
-  let urlIdx = 0;
-  for (let i = 0; i < routeSegments.length; i++) {
-    const seg = routeSegments[i];
-    if (seg.type === "static") {
-      if (urlIdx >= urlSegments.length || urlSegments[urlIdx] !== seg.value) {
-        return void 0;
-      }
-      urlIdx++;
-    } else if (seg.type === "param") {
-      if (urlIdx >= urlSegments.length)
-        return void 0;
-      params[seg.value] = urlSegments[urlIdx];
-      urlIdx++;
-    } else if (seg.type === "optional") {
-      if (urlIdx < urlSegments.length) {
-        params[seg.value] = urlSegments[urlIdx];
-        urlIdx++;
-      }
-    } else if (seg.type === "catchAll") {
-      if (urlIdx >= urlSegments.length)
-        return void 0;
-      params[seg.value] = urlSegments.slice(urlIdx).join("/");
-      urlIdx = urlSegments.length;
-    } else if (seg.type === "optionalCatchAll") {
-      if (urlIdx < urlSegments.length) {
-        params[seg.value] = urlSegments.slice(urlIdx).join("/");
-        urlIdx = urlSegments.length;
-      }
-    }
-  }
-  if (urlIdx !== urlSegments.length)
-    return void 0;
-  return params;
-}
-function findInstance(route, params) {
-  const paramNames = new Set(
-    route.segments.filter((s) => s.type !== "static").map((s) => s.value)
-  );
-  return route.instances.find((instance) => {
-    for (const name of paramNames) {
-      const urlVal = params[name];
-      const instVal = instance.params[name];
-      if (urlVal === void 0 && instVal === void 0)
-        continue;
-      if (urlVal !== instVal)
-        return false;
-    }
-    return true;
-  });
-}
-function buildImportMap(sharedManifest, publicBasePath, sharedDir = "shared") {
-  const imports = {};
-  for (const [pkgName, hashedFile] of Object.entries(sharedManifest)) {
-    imports[pkgName] = `${publicBasePath}${sharedDir}/${hashedFile}`;
-  }
-  return imports;
-}
-const pagePartsCache = /* @__PURE__ */ new Map();
-async function getPageParts(route, artifacts, preRenderedPath) {
-  const cacheKey = route.pattern;
-  const cached = pagePartsCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const routeDir = path.dirname(preRenderedPath);
-  const configPath = artifacts.getAssetPath(path.join(routeDir, "page-parts.json"));
-  const buildDir = artifacts.getBuildDir();
-  const parts = await loadPagePartsFromConfig(configPath, buildDir);
-  pagePartsCache.set(cacheKey, parts);
-  return parts;
-}
-async function fetchPageRequest(match, manifest, requestUrl, artifacts, staticBaseUrl, cookies = {}) {
-  const { route, instance } = match;
-  const preRendered = await artifacts.readPreRenderedHtml(instance.preRenderedPath);
-  const pageParts = await getPageParts(route, artifacts, instance.preRenderedPath);
-  const query = Object.fromEntries(requestUrl.searchParams.entries());
-  const fastResult = await renderFastChangingData(
-    match.params,
-    { params: match.params, query },
-    preRendered.carryForward,
-    pageParts.parts,
-    preRendered.carryForward.__instances,
-    pageParts.forEachInstances,
-    pageParts.headlessInstanceComponents,
-    preRendered.slowViewState,
-    query,
-    cookies
-  );
-  if (fastResult.kind === "Redirect3xx") {
-    return new Response(null, {
-      status: fastResult.status,
-      headers: { Location: fastResult.location }
-    });
-  }
-  if (fastResult.kind === "ServerError5xx" || fastResult.kind === "ClientError4xx") {
-    return new Response(fastResult.message || "Error", {
-      status: fastResult.status
-    });
-  }
-  const fastViewState = fastResult.rendered || {};
-  const fastCarryForward = fastResult.carryForward || {};
-  const headTagSources = [];
-  const slowHeadTags = preRendered.carryForward.__slowHeadTags;
-  if (slowHeadTags)
-    headTagSources.push(...slowHeadTags);
-  const fastHeadTags = fastResult.headTags;
-  if (fastHeadTags)
-    headTagSources.push(fastHeadTags);
-  const headTags = headTagSources.length > 0 ? mergeHeadTags(headTagSources) : [];
-  const headTagsHtml = headTags.length > 0 ? serializeHeadTags(headTags) + "\n" : "";
-  const fullViewState = deepMergeViewStates(
-    preRendered.slowViewState,
-    fastViewState,
-    route.trackByMap || {}
-  );
-  const serverElement = await artifacts.loadServerElement(instance.serverElementPath);
-  const asyncPromises = [];
-  const importMap = buildImportMap(manifest.sharedManifest, staticBaseUrl);
-  const modulePreloads = Object.values(importMap).map((url) => `    <link rel="modulepreload" href="${url}" />`).join("\n");
-  const cssLink = instance.clientCssPath ? `    <link rel="stylesheet" href="${staticBaseUrl}${instance.clientCssPath}" />` : "";
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    async start(controller) {
-      const write = (s) => controller.enqueue(encoder.encode(s));
-      const headParts = [headTagsHtml, modulePreloads, cssLink].filter(Boolean).join("\n");
-      write(`<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-${headParts}
-    <script type="importmap">${JSON.stringify({ imports: importMap })}<\/script>
-  </head>
-  <body>
-    <div id="target">`);
-      serverElement.renderToStream(fullViewState, {
-        write: (chunk) => write(chunk),
-        onAsync: (promise, id, templates) => {
-          asyncPromises.push(
-            promise.then(
-              (val) => asyncSwapScript(id, templates.resolved(val)),
-              (err) => asyncSwapScript(id, templates.rejected(err))
-            )
-          );
-        }
-      });
-      write("</div>");
-      const asyncScripts = (await Promise.all(asyncPromises)).filter((s) => s).join("");
-      if (asyncScripts)
-        write(asyncScripts);
-      const clientInitData = getClientInitData();
-      const clientBundleUrl = `${staticBaseUrl}${instance.clientBundlePath}`;
-      write(`
-    <script type="module">
-      import { init } from '${clientBundleUrl}';
-      await init(${JSON.stringify(fastViewState)}, ${JSON.stringify(fastCarryForward)}, ${JSON.stringify(clientInitData)});
-    <\/script>
-  </body>
-</html>`);
-      controller.close();
-    }
-  });
-  const responseHeaders = fastResult.responseHeaders || {};
-  return new Response(stream, {
-    headers: { "Content-Type": "text/html; charset=utf-8", ...responseHeaders }
-  });
-}
-const ACTION_PREFIX = "/_jay/actions/";
-function isActionRequest(pathname) {
-  return pathname.startsWith(ACTION_PREFIX);
-}
-async function fetchActionRequest(request, registry = actionRegistry) {
-  const url = new URL(request.url);
-  const actionName = url.pathname.slice(ACTION_PREFIX.length);
-  if (!actionName) {
-    return jsonResponse(400, {
-      success: false,
-      error: {
-        code: "MISSING_ACTION_NAME",
-        message: "Action name is required",
-        isActionError: false
-      }
-    });
-  }
-  const action = registry.get(actionName);
-  if (!action) {
-    return jsonResponse(404, {
-      success: false,
-      error: {
-        code: "ACTION_NOT_FOUND",
-        message: `Action '${actionName}' is not registered`,
-        isActionError: false
-      }
-    });
-  }
-  const requestMethod = request.method.toUpperCase();
-  if (requestMethod !== action.method) {
-    return jsonResponse(405, {
-      success: false,
-      error: {
-        code: "METHOD_NOT_ALLOWED",
-        message: `Action '${actionName}' expects ${action.method}, got ${requestMethod}`,
-        isActionError: false
-      }
-    });
-  }
-  let input;
-  try {
-    if (requestMethod === "GET") {
-      const inputParam = url.searchParams.get("_input");
-      if (inputParam) {
-        input = JSON.parse(inputParam);
-      } else {
-        input = Object.fromEntries(url.searchParams.entries());
-        delete input._input;
-      }
-    } else {
-      const text = await request.text();
-      input = text ? JSON.parse(text) : {};
-    }
-  } catch {
-    return jsonResponse(400, {
-      success: false,
-      error: {
-        code: "INVALID_INPUT",
-        message: "Failed to parse request input",
-        isActionError: false
-      }
-    });
-  }
-  if (registry.isStreaming(actionName)) {
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        try {
-          const generator = registry.executeStream(actionName, input);
-          for await (const chunk of generator) {
-            controller.enqueue(encoder.encode(JSON.stringify({ chunk }) + "\n"));
-          }
-          controller.enqueue(encoder.encode(JSON.stringify({ done: true }) + "\n"));
-        } catch (err) {
-          controller.enqueue(
-            encoder.encode(JSON.stringify({ error: err.message }) + "\n")
-          );
-        }
-        controller.close();
-      }
-    });
-    return new Response(stream, {
-      headers: { "Content-Type": "application/x-ndjson" }
-    });
-  }
-  const result = await registry.execute(actionName, input);
-  if (result.success) {
-    const headers = {};
-    if (requestMethod === "GET") {
-      const cacheHeaders = registry.getCacheHeaders(actionName);
-      if (cacheHeaders) {
-        headers["Cache-Control"] = cacheHeaders;
-      }
-    }
-    return jsonResponse(200, { success: true, data: result.data }, headers);
-  } else {
-    const statusCode = getStatusCode(result.error.code, result.error.isActionError);
-    return jsonResponse(statusCode, { success: false, error: result.error });
-  }
-}
-function jsonResponse(status, body, extraHeaders = {}) {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json", ...extraHeaders }
-  });
-}
-async function registerActionsFromManifest(actions, buildDir, registry = actionRegistry) {
-  const logger = getLogger();
-  let count = 0;
-  for (const entry of actions) {
-    try {
-      const modulePath = entry.isPlugin ? entry.packageName : `${buildDir}/${entry.serverModule}`;
-      const mod = await import(modulePath);
-      for (const [, exported] of Object.entries(mod)) {
-        if (isJayAction(exported)) {
-          registry.register(exported);
-          count++;
-        } else if (isJayStreamAction(exported)) {
-          registry.registerStream(exported);
-          count++;
-        }
-      }
-    } catch (err) {
-      logger.error(
-        `[Server] Failed to load action module ${entry.serverModule}: ${err.message}`
-      );
-    }
-  }
-  logger.info(`[Server] Registered ${count} actions`);
-}
-function getStatusCode(code, isActionError) {
-  if (isActionError)
-    return 422;
-  switch (code) {
-    case "ACTION_NOT_FOUND":
-      return 404;
-    case "INVALID_INPUT":
-    case "VALIDATION_ERROR":
-      return 400;
-    case "UNAUTHORIZED":
-      return 401;
-    case "FORBIDDEN":
-      return 403;
-    default:
-      return 500;
-  }
-}
-const MIME_TYPES = {
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".html": "text/html",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".woff": "font/woff",
-  ".ttf": "font/ttf",
-  ".webp": "image/webp"
-};
-async function fetchStaticFile(pathname, frontendDir) {
-  const normalizedBase = path.resolve(frontendDir);
-  for (const candidate of [
-    path.join(frontendDir, pathname),
-    path.join(frontendDir, "public", pathname)
-  ]) {
-    const normalizedFile = path.resolve(candidate);
-    if (!normalizedFile.startsWith(normalizedBase))
-      continue;
-    try {
-      const content = await fs.readFile(candidate);
-      const ext = path.extname(candidate);
-      const contentType = MIME_TYPES[ext] || "application/octet-stream";
-      const isHashed = /[-][a-zA-Z0-9_-]{6,}\./.test(path.basename(candidate));
-      const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
-      return new Response(content, {
-        headers: {
-          "Content-Type": contentType,
-          "Content-Length": String(content.length),
-          "Cache-Control": cacheControl
-        }
-      });
-    } catch {
-    }
-  }
-  return null;
-}
-async function initializeServices(buildDir, projectRoot, label) {
-  const logger = getLogger();
-  const { discoverPluginsWithInit, sortPluginsByDependencies } = await import("@jay-framework/stack-server-runtime");
-  try {
-    const pluginsWithInit = sortPluginsByDependencies(
-      await discoverPluginsWithInit({ projectRoot })
-    );
-    for (const pluginInit of pluginsWithInit) {
-      try {
-        let modulePath;
-        if (pluginInit.isLocal) {
-          const pluginDirName = path.basename(pluginInit.pluginPath);
-          const initModule = pluginInit.initModule || "index";
-          modulePath = path.join(
-            buildDir,
-            "server",
-            "plugins",
-            pluginDirName,
-            initModule + ".js"
-          );
-        } else {
-          modulePath = pluginInit.packageName;
-        }
-        const pluginModule = await import(modulePath);
-        const init = pluginModule.init || pluginModule[pluginInit.initExport || "init"];
-        if (init?._serverInit) {
-          logger.info(`[${label}] Running plugin init: ${pluginInit.name}`);
-          const data = await init._serverInit();
-          if (data)
-            setClientInitData(pluginInit.name, data);
-        }
-      } catch (err) {
-        logger.warn(`[${label}] Plugin init failed: ${pluginInit.name}: ${err.message}`);
-      }
-    }
-  } catch {
-  }
-  const initModulePath = path.join(buildDir, "server", "init.js");
-  try {
-    const initModule = await import(initModulePath);
-    const init = initModule.init || initModule.default;
-    if (init?._serverInit) {
-      logger.info(`[${label}] Running server init...`);
-      const data = await init._serverInit();
-      if (data)
-        setClientInitData("project", data);
-    }
-  } catch {
-  }
-}
 function toFetchRequest(req) {
   const url = new URL(req.url || "/", `http://${req.headers.host}`);
   const headers = new Headers();
@@ -2397,14 +1748,9 @@ function paramsMatch(instanceParams, targetParams) {
   return Object.entries(targetParams).every(([key, value]) => instanceParams[key] === value);
 }
 function collectInstanceFiles(instance) {
-  if (!instance.preRenderedPath)
+  if (!instance.cachePath)
     return [];
-  const files = [
-    instance.preRenderedPath,
-    instance.preRenderedPath.replace(".jay-html", ".cache.json"),
-    instance.serverElementPath,
-    instance.clientBundlePath
-  ];
+  const files = [instance.cachePath, instance.serverElementPath, instance.clientBundlePath];
   if (instance.clientCssPath)
     files.push(instance.clientCssPath);
   return files.filter(Boolean);
@@ -2579,11 +1925,13 @@ export {
   fetchPageRequest,
   fetchStaticFile,
   initializeServices,
+  e as initializeServicesFromModules,
   isActionRequest,
   matchRequest,
   rebuild,
   rebuildContract,
   registerActionsFromManifest,
+  b as registerActionsFromModules,
   resolveContractToRoutes,
   startMainServer,
   startRendererServer