@jay-framework/production-server 0.17.3 → 0.18.0

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,16 +5,20 @@ 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 } 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-BKVwxzYb.js";
+import { e, b } from "./init-services-BKVwxzYb.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 http from "node:http";
-import { deepMergeViewStates } from "@jay-framework/view-state-merge";
-import { asyncSwapScript } from "@jay-framework/ssr-runtime";
-import { isJayAction, isJayStreamAction } from "@jay-framework/fullstack-component";
+import { Readable } from "node:stream";
+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, {
@@ -57,7 +55,7 @@ async function discoverServerEntries(projectRoot, pagesRoot) {
         const dirPath = path.join(scanDir, dir.name);
         const files = await fs.readdir(dirPath);
         for (const file of files) {
-          if (file.endsWith(".ts") && !file.endsWith(".d.ts") && file !== "init.ts" && file !== "page.ts") {
+          if (file.endsWith(".ts") && !file.endsWith(".d.ts") && file !== "page.ts") {
             const entryName = `${subDir}/${dir.name}/${file.replace(/\.ts$/, "")}`;
             pages[entryName] = path.join(dirPath, file);
           }
@@ -208,281 +206,7 @@ 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 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`;
-      parts.push({
-        key: headlessImport.key,
-        compDefinition: headlessCompDef,
-        clientImport: "",
-        clientPart: "",
-        contractInfo: headlessImport.contract ? {
-          contractName: headlessImport.contract.name,
-          metadata: headlessImport.metadata
-        } : void 0
-      });
-      keyedPartModules.push({
-        key: headlessImport.key,
-        modulePath: clientModulePath,
-        exportName: name
-      });
-    }
-    if (!headlessImport.key && headlessImport.contract) {
-      headlessInstanceComponents.push({
-        contractName: headlessImport.contractName,
-        compDefinition: headlessCompDef,
-        contract: headlessImport.contract
-      });
-    }
-  }
-  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,
-    serverTrackByMap: jayHtml.serverTrackByMap,
-    clientTrackByMap: jayHtml.clientTrackByMap
-  };
-}
-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) {
+function hashParams(params, suffix) {
   const sorted = Object.keys(params).sort().reduce(
     (acc, key) => {
       acc[key] = params[key];
@@ -491,20 +215,23 @@ function hashParams(params) {
     {}
   );
   const json = JSON.stringify(sorted);
-  if (json === "{}")
+  if (json === "{}" && !suffix)
     return "";
-  return "_" + crypto.createHash("md5").update(json).digest("hex").substring(0, 8);
+  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);
+  const paramHash = hashParams(params, ctx.rebuildSuffix);
   const instanceId = `page${paramHash}`;
-  const instanceDir = path.join(ctx.buildDir, "pre-rendered", routeDir);
-  await fs.mkdir(instanceDir, { recursive: true });
+  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");
-  const sourceDir = path.dirname(route.jayHtmlPath);
-  const serverBuildDir = path.join(ctx.buildDir, "server");
+  path.dirname(route.jayHtmlPath);
+  const serverBuildDir = path.join(ctx.backendDir, "server");
   const pageParts = await loadProductionPageParts(
     route,
     pageModule,
@@ -513,6 +240,38 @@ async function buildInstance(route, params, pageModule, ctx) {
     ctx.tsConfigFilePath,
     serverBuildDir
   );
+  const contracts = [
+    .../* @__PURE__ */ new Set([
+      ...pageParts.headlessInstanceComponents.map((c) => c.contractName),
+      ...pageParts.parts.filter((p) => p.contractInfo?.contractName).map((p) => p.contractInfo.contractName)
+    ])
+  ];
+  const pagePartsConfigPath = path.join(backendInstanceDir, "page-parts.json");
+  try {
+    await fs.access(pagePartsConfigPath);
+  } catch {
+    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,
@@ -535,163 +294,59 @@ 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
         }
-      }
+      };
     }
   }
-  const preRenderedPath = path.join(instanceDir, `${instanceId}.jay-html`);
-  await fs.writeFile(preRenderedPath, preRenderedJayHtml, "utf-8");
-  const cacheMetadataPath = path.join(instanceDir, `${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,
-      sourcePath: route.jayHtmlPath
+      carryForward
     }),
     "utf-8"
   );
-  logger.info(`[Build] Pre-rendered: ${routeDir}/${instanceId}`);
-  const serverElementPath = path.join(instanceDir, `${instanceId}.server-element.js`);
-  const serverElementResult = await compileServerElement(
-    preRenderedJayHtml,
-    `${instanceId}.jay-html`,
-    instanceDir,
-    serverElementPath,
-    ctx.projectRoot,
-    ctx.tsConfigFilePath,
-    sourceDir
-  );
-  const hydrateEntryPath = path.join(instanceDir, `${instanceId}.hydrate-entry.ts`);
-  const relativeJayHtmlPath = path.relative(instanceDir, preRenderedPath);
-  let pageModulePath;
-  let pageExportName;
-  if (route.componentExport) {
-    const pkgName = resolvePackageNameForRoute(route.compPath);
-    pageModulePath = pkgName ? `${pkgName}/client` : "./" + path.relative(instanceDir, route.compPath);
-    pageExportName = route.componentExport;
-  } else if (route.compPath) {
-    pageModulePath = "./" + path.relative(instanceDir, 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,
-    instanceDir,
-    ctx.projectRoot,
-    ctx.jayOptions,
-    ctx.minify ?? true,
-    ctx.pagesRoot,
-    ctx.buildDir
-  );
-  await fs.rm(hydrateEntryPath, { force: true });
-  const cssFile = clientResult.cssFile || serverElementResult.cssFile;
+  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.buildDir, preRenderedPath),
-    serverElementPath: path.relative(ctx.buildDir, serverElementPath),
-    clientBundlePath: path.relative(ctx.buildDir, path.join(instanceDir, clientResult.jsFile)),
-    clientCssPath: cssFile ? path.relative(ctx.buildDir, path.join(instanceDir, cssFile)) : void 0
+    cachePath: path.relative(ctx.backendDir, cachePath),
+    serverElementPath: path.relative(ctx.backendDir, serverElementPath),
+    clientBundlePath: routeClientBundlePath || "",
+    clientCssPath: routeCssPath
   };
-  return { status: "success", instanceEntry, slowViewState, carryForward };
+  return { status: "success", instanceEntry, slowViewState, carryForward, contracts };
 }
 function convertSegments(segments) {
   return segments.map((s) => {
@@ -713,7 +368,6 @@ function buildRouteEntry(route, serverModulePath) {
     pattern: route.rawRoute,
     segments: convertSegments(route.segments),
     serverModule: serverModulePath,
-    jayHtmlPath: route.jayHtmlPath,
     componentExport: route.componentExport,
     instances: []
   };
@@ -804,7 +458,8 @@ 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}`);
     }
@@ -852,44 +507,289 @@ function resolvePluginModule(pluginPath) {
   }
   return path.join(pluginPath, "dist", "index.js");
 }
-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) {
+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 compileRouteServerElement(jayHtmlPath, outputPath, projectRoot, tsConfigFilePath) {
+  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
+  );
+}
+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();
+}
+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,
+    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 b2 of next) {
+        combined.push({ ...a, ...b2 });
+      }
+    }
+    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);
@@ -1006,11 +906,14 @@ async function discoverPluginClientPackages(projectRoot) {
 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(buildDir, { recursive: true });
+  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(buildDir, "server");
+  const serverOutputDir = path.join(backendDir, "server");
   await buildServerCode(
     entries,
     { tsConfigFilePath: options.tsConfigFilePath },
@@ -1021,7 +924,7 @@ async function buildVersion(options) {
   if (pluginClientPackages.length > 0) {
     logger.important(`[Build] Plugin client packages: ${pluginClientPackages.join(", ")}`);
   }
-  const sharedOutputDir = path.join(buildDir, "shared");
+  const sharedOutputDir = path.join(frontendDir, "shared");
   const { manifest: sharedManifest } = await buildSharedChunks(
     sharedOutputDir,
     options.projectRoot,
@@ -1031,7 +934,7 @@ async function buildVersion(options) {
   const { actions, plugins } = await discoverActions(
     entries.actions,
     serverOutputDir,
-    buildDir,
+    backendDir,
     options.projectRoot
   );
   const { discoverPluginsWithInit, sortPluginsByDependencies } = await import("@jay-framework/stack-server-runtime");
@@ -1106,6 +1009,8 @@ async function buildVersion(options) {
     projectRoot: options.projectRoot,
     pagesRoot: options.pagesRoot,
     buildDir,
+    backendDir,
+    frontendDir,
     jayOptions: { tsConfigFilePath: options.tsConfigFilePath },
     tsConfigFilePath: options.tsConfigFilePath,
     minify: options.minify ?? true,
@@ -1141,7 +1046,7 @@ async function buildVersion(options) {
       return {};
     if (entry.isPlugin)
       return import(entry.serverModule);
-    return import(path.join(serverOutputDir, entry.serverModule.replace("server/", "")));
+    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);
@@ -1172,7 +1077,7 @@ async function buildVersion(options) {
       await fs.readFile(route.jayHtmlPath, "utf-8"),
       options.projectRoot,
       options.tsConfigFilePath,
-      path.join(buildDir, "server")
+      serverOutputDir
     );
     const partsWithLoadParams = pageParts.parts.filter((p) => p.compDefinition?.loadParams);
     if (partsWithLoadParams.length === 0)
@@ -1209,6 +1114,108 @@ 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
+      );
+      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);
+      }
+      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;
@@ -1225,9 +1232,21 @@ 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) {
+            entry.contracts = result.contracts;
+          }
           logInstance(route.rawRoute || "/", params);
         } else {
           logger.warn(
@@ -1248,13 +1267,12 @@ async function buildVersion(options) {
     buildTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash: "",
     projectRoot: options.projectRoot,
-    publicBasePath: options.publicBasePath,
     sharedManifest,
     routes: routeEntries.map((r) => r.entry),
     actions,
     plugins
   };
-  await writeRouteManifest(manifest, buildDir);
+  await writeRouteManifest(manifest, backendDir);
   const metadata = {
     version: options.version,
     sourceHash: "",
@@ -1263,592 +1281,633 @@ async function buildVersion(options) {
     instanceCount
   };
   await fs.writeFile(
-    path.join(buildDir, "build-metadata.json"),
+    path.join(backendDir, "build-metadata.json"),
     JSON.stringify(metadata, null, 2)
   );
+  const publicFolder = path.join(options.projectRoot, "public");
+  try {
+    await fs.access(publicFolder);
+    await fs.cp(publicFolder, path.join(frontendDir, "public"), { recursive: true });
+    logger.info("[Build] Copied public/ to frontend/public/");
+  } catch {
+  }
   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, "moduleCache", /* @__PURE__ */ new Map());
-    this.basePath = basePath;
-  }
-  async readManifest() {
-    const manifestPath = path.join(this.basePath, "route-manifest.json");
-    const stat = await fs.stat(manifestPath);
-    if (this.manifestCache && stat.mtimeMs === this.manifestCache.mtime) {
-      return this.manifestCache.manifest;
-    }
-    const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
-    this.manifestCache = { manifest, mtime: stat.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);
+function toFetchRequest(req) {
+  const url = new URL(req.url || "/", `http://${req.headers.host}`);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value)
+      headers.set(key, Array.isArray(value) ? value.join(", ") : value);
   }
-  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;
+  const init = { method: req.method, headers };
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    init.body = Readable.toWeb(req);
+    init.duplex = "half";
   }
+  return new Request(url, init);
 }
-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 };
+async function pipeFetchResponse(response, res) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  res.writeHead(response.status, headers);
+  if (response.body) {
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        res.write(value);
       }
+    } finally {
+      reader.releaseLock();
     }
   }
-  return void 0;
+  res.end();
 }
-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;
+async function startMainServer(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");
+  const artifacts = new FilesystemArtifactStore(backendDir);
+  const manifest = await artifacts.readManifest();
+  logger.important(
+    `[Server] Loaded manifest: ${manifest.routes.length} routes, v${manifest.version}`
+  );
+  await initializeServices(backendDir, process.cwd(), "Server");
+  if (manifest.actions.length > 0) {
+    await registerActionsFromManifest(manifest.actions, backendDir);
+  }
+  const staticBaseUrl = options.publicBasePath ?? "/";
+  const startTime = Date.now();
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    try {
+      if (options.testMode && url.pathname === "/_jay/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            status: "ready",
+            port: options.port,
+            uptime: (Date.now() - startTime) / 1e3
+          })
+        );
+        return;
       }
-      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++;
+      if (options.testMode && url.pathname === "/_jay/shutdown" && req.method === "POST") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "shutting_down" }));
+        setTimeout(() => {
+          server.close();
+          process.exit(0);
+        }, 100);
+        return;
       }
-    } 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 (isActionRequest(url.pathname)) {
+        const fetchReq = toFetchRequest(req);
+        const response2 = await fetchActionRequest(fetchReq);
+        await pipeFetchResponse(response2, res);
+        return;
+      }
+      if (options.serveStatic !== false) {
+        const staticResponse = await fetchStaticFile(url.pathname, frontendDir);
+        if (staticResponse) {
+          await pipeFetchResponse(staticResponse, res);
+          return;
+        }
+      }
+      const currentManifest = await artifacts.readManifest();
+      const match = matchRequest(currentManifest, url.pathname);
+      if (!match) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      const cookies = parseCookies(req.headers.cookie);
+      const response = await fetchPageRequest(
+        match,
+        currentManifest,
+        url,
+        artifacts,
+        staticBaseUrl,
+        cookies
+      );
+      await pipeFetchResponse(response, res);
+    } catch (err) {
+      logger.error(`[Server] Error handling ${url.pathname}: ${err.message}`);
+      if (err.stack)
+        logger.error(err.stack);
+      if (!res.headersSent) {
+        res.writeHead(500);
+        res.end("Internal Server Error");
       }
     }
-  }
-  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;
+  });
+  server.listen(options.port, () => {
+    logger.important(
+      `[Server] Production server listening on http://localhost:${options.port}`
+    );
+    if (options.testMode) {
+      logger.important(`[Server] Test mode enabled`);
+      logger.important(`   Health: http://localhost:${options.port}/_jay/health`);
+      logger.important(
+        `   Shutdown: curl -X POST http://localhost:${options.port}/_jay/shutdown`
+      );
     }
-    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, pageModule, artifacts, preRenderedPath, manifest) {
-  const cacheKey = route.pattern;
-  const cached = pagePartsCache.get(cacheKey);
-  if (cached)
-    return cached;
-  if (!route.jayHtmlPath) {
-    return {
-      parts: [
-        {
-          compDefinition: pageModule.page ?? pageModule.default,
-          clientImport: "",
-          clientPart: ""
+async function discoverWebhooks(projectRoot, serverBuildDir) {
+  const logger = getLogger();
+  const webhooks = [];
+  try {
+    const plugins = await scanPlugins({ projectRoot });
+    for (const [packageName, plugin] of plugins) {
+      if (plugin.isLocal)
+        continue;
+      const declaredWebhooks = plugin.manifest.webhooks;
+      if (!declaredWebhooks || declaredWebhooks.length === 0)
+        continue;
+      try {
+        const pluginModule = await import(packageName);
+        for (const entry of declaredWebhooks) {
+          const exportName = typeof entry === "string" ? entry : entry.name;
+          const value = pluginModule[exportName];
+          if (isJayWebhook(value)) {
+            webhooks.push({
+              name: value.webhookName,
+              webhook: value,
+              source: packageName
+            });
+            logger.info(
+              `[Renderer] Webhook "${value.webhookName}" from ${plugin.manifest.name}`
+            );
+          } else {
+            logger.warn(
+              `[Renderer] plugin.yaml declares webhook "${exportName}" but export is not a JayWebhook in ${packageName}`
+            );
+          }
         }
-      ],
-      headlessContracts: [],
-      headlessInstanceComponents: [],
-      discoveredInstances: [],
-      forEachInstances: [],
-      keyedPartModules: []
-    };
-  }
-  const jayHtmlContent = await artifacts.readRawFile(preRenderedPath);
-  const serverBuildDir = artifacts.getAssetPath("server");
-  const parts = await loadProductionPageParts(
-    { jayHtmlPath: route.jayHtmlPath, componentExport: route.componentExport },
-    pageModule,
-    jayHtmlContent,
-    manifest.projectRoot,
-    void 0,
-    serverBuildDir
-  );
-  pagePartsCache.set(cacheKey, parts);
-  return parts;
-}
-async function handlePageRequest(res, match, manifest, artifacts) {
-  const { route, instance } = match;
-  const preRendered = await artifacts.readPreRenderedHtml(instance.preRenderedPath);
-  let pageModule = {};
-  if (route.serverModule) {
-    pageModule = route.isPlugin ? await import(route.serverModule) : await artifacts.loadPageModule(route.serverModule);
-  }
-  const pageParts = await getPageParts(
-    route,
-    pageModule,
-    artifacts,
-    instance.preRenderedPath,
-    manifest
-  );
-  const url = new URL(`http://localhost${match.pathname}`);
-  const query = Object.fromEntries(url.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
-  );
-  if (fastResult.kind === "Redirect3xx") {
-    res.writeHead(fastResult.status, { Location: fastResult.location });
-    res.end();
-    return;
-  }
-  if (fastResult.kind === "ServerError5xx" || fastResult.kind === "ClientError4xx") {
-    res.writeHead(fastResult.status);
-    res.end(fastResult.message || "Error");
-    return;
+      } catch (err) {
+        logger.warn(
+          `[Renderer] Failed to load webhooks from ${packageName}: ${err.message}`
+        );
+      }
+    }
+  } catch {
   }
-  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" : "";
-  headTags.some((t) => t.tag.toLowerCase() === "title");
-  const fullViewState = deepMergeViewStates(
-    preRendered.slowViewState,
-    fastViewState,
-    route.trackByMap || {}
-  );
-  const serverElement = await artifacts.loadServerElement(instance.serverElementPath);
-  const asyncPromises = [];
-  const importMap = buildImportMap(manifest.sharedManifest, manifest.publicBasePath);
-  const modulePreloads = Object.values(importMap).map((url2) => `    <link rel="modulepreload" href="${url2}" />`).join("\n");
-  const cssLink = instance.clientCssPath ? `    <link rel="stylesheet" href="${manifest.publicBasePath}${instance.clientCssPath}" />` : "";
-  res.writeHead(200, {
-    "Content-Type": "text/html; charset=utf-8",
-    "Transfer-Encoding": "chunked"
-  });
-  const headParts = [headTagsHtml, modulePreloads, cssLink].filter(Boolean).join("\n");
-  res.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) => res.write(chunk),
-    onAsync: (promise, id, templates) => {
-      asyncPromises.push(
-        promise.then(
-          (val) => asyncSwapScript(id, templates.resolved(val)),
-          (err) => asyncSwapScript(id, templates.rejected(err))
-        )
-      );
+  try {
+    const plugins = await scanPlugins({ projectRoot });
+    for (const [, plugin] of plugins) {
+      if (!plugin.isLocal)
+        continue;
+      const declaredWebhooks = plugin.manifest.webhooks;
+      if (!declaredWebhooks || declaredWebhooks.length === 0)
+        continue;
+      const pluginDirName = path.basename(plugin.pluginPath);
+      for (const entry of declaredWebhooks) {
+        const exportName = typeof entry === "string" ? entry : entry.name;
+        const modulePath = path.join(serverBuildDir, "plugins", pluginDirName, "index.js");
+        try {
+          const mod = await import(modulePath);
+          const value = mod[exportName];
+          if (isJayWebhook(value)) {
+            webhooks.push({
+              name: value.webhookName,
+              webhook: value,
+              source: `local:${plugin.manifest.name}`
+            });
+            logger.info(
+              `[Renderer] Webhook "${value.webhookName}" from local plugin ${plugin.manifest.name}`
+            );
+          }
+        } catch (err) {
+          logger.warn(
+            `[Renderer] Failed to load webhook "${exportName}" from local plugin ${plugin.manifest.name}: ${err.message}`
+          );
+        }
+      }
     }
-  });
-  res.write("</div>");
-  const asyncScripts = (await Promise.all(asyncPromises)).filter((s) => s).join("");
-  if (asyncScripts)
-    res.write(asyncScripts);
-  const clientInitData = getClientInitData();
-  const clientBundleUrl = `${manifest.publicBasePath}${instance.clientBundlePath}`;
-  res.write(`
-    <script type="module">
-      import { init } from '${clientBundleUrl}';
-      await init(${JSON.stringify(fastViewState)}, ${JSON.stringify(fastCarryForward)}, ${JSON.stringify(clientInitData)});
-    <\/script>
-  </body>
-</html>`);
-  res.end();
-}
-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",
-  ".woff2": "font/woff2",
-  ".woff": "font/woff"
-};
-async function handleStaticRequest(req, res, basePath, urlPrefix) {
-  const url = new URL(req.url || "/", `http://${req.headers.host}`);
-  if (!url.pathname.startsWith(urlPrefix))
-    return false;
-  const relativePath = url.pathname.slice(urlPrefix.length);
-  const filePath = path.join(basePath, relativePath);
-  const normalizedBase = path.resolve(basePath);
-  const normalizedFile = path.resolve(filePath);
-  if (!normalizedFile.startsWith(normalizedBase)) {
-    res.writeHead(403);
-    res.end("Forbidden");
-    return true;
+  } catch {
   }
+  const webhooksDir = path.join(serverBuildDir, "webhooks");
   try {
-    const content = await fs.readFile(filePath);
-    const ext = path.extname(filePath);
-    const contentType = MIME_TYPES[ext] || "application/octet-stream";
-    const isHashed = /[-][a-zA-Z0-9_-]{6,}\./.test(path.basename(filePath));
-    const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
-    res.writeHead(200, {
-      "Content-Type": contentType,
-      "Content-Length": content.length,
-      "Cache-Control": cacheControl
-    });
-    res.end(content);
-    return true;
+    const files = await fs.readdir(webhooksDir);
+    for (const file of files) {
+      if (!file.endsWith(".js"))
+        continue;
+      try {
+        const mod = await import(path.join(webhooksDir, file));
+        for (const [, value] of Object.entries(mod)) {
+          if (isJayWebhook(value)) {
+            webhooks.push({
+              name: value.webhookName,
+              webhook: value,
+              source: `project:${file}`
+            });
+            logger.info(`[Renderer] Webhook "${value.webhookName}" from project`);
+          }
+        }
+      } catch (err) {
+        logger.warn(`[Renderer] Failed to load webhook ${file}: ${err.message}`);
+      }
+    }
   } catch {
-    return false;
   }
+  return webhooks;
 }
-const ACTION_PREFIX = "/_jay/actions/";
-function isActionRequest(pathname) {
-  return pathname.startsWith(ACTION_PREFIX);
+function resolveContractToRoutes(manifest, contractName) {
+  return manifest.routes.filter((r) => r.contracts && r.contracts.includes(contractName));
 }
-async function handleActionRequest(req, res, registry = actionRegistry) {
-  const url = new URL(req.url || "/", `http://${req.headers.host}`);
-  const actionName = url.pathname.slice(ACTION_PREFIX.length);
-  if (!actionName) {
-    jsonResponse(res, 400, {
-      success: false,
-      error: {
-        code: "MISSING_ACTION_NAME",
-        message: "Action name is required",
-        isActionError: false
-      }
-    });
-    return;
-  }
-  const action = registry.get(actionName);
-  if (!action) {
-    jsonResponse(res, 404, {
-      success: false,
-      error: {
-        code: "ACTION_NOT_FOUND",
-        message: `Action '${actionName}' is not registered`,
-        isActionError: false
-      }
-    });
-    return;
+async function rebuild(options) {
+  const logger = getLogger();
+  const buildDir = path.join(options.buildRoot, `v${options.version}`);
+  const manifestPath = path.join(buildDir, "backend", "route-manifest.json");
+  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
+  const {
+    routes: affectedRoutes,
+    params: targetParams,
+    label
+  } = resolveTarget(manifest, options.target);
+  logger.important(`[Rebuild] ${label} in v${options.version}`);
+  if (affectedRoutes.length === 0) {
+    logger.warn(`[Rebuild] No routes found for ${label}`);
+    return { affected: 0, rebuilt: 0, errors: [] };
   }
-  const requestMethod = (req.method || "GET").toUpperCase();
-  if (requestMethod !== action.method) {
-    jsonResponse(res, 405, {
-      success: false,
-      error: {
-        code: "METHOD_NOT_ALLOWED",
-        message: `Action '${actionName}' expects ${action.method}, got ${requestMethod}`,
-        isActionError: false
+  logger.important(
+    `[Rebuild] Found ${affectedRoutes.length} route(s): ${affectedRoutes.map((r) => r.pattern).join(", ")}`
+  );
+  const backendDir = path.join(buildDir, "backend");
+  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) {
+    const instancesToRebuild = targetParams ? route.instances.filter((i) => paramsMatch(i.params, targetParams)) : [...route.instances];
+    if (instancesToRebuild.length === 0 && targetParams) {
+      instancesToRebuild.push({ params: targetParams });
+    }
+    for (const instance of instancesToRebuild) {
+      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;
       }
-    });
-    return;
-  }
-  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;
+      const jayRoute = await resolveJayRouteFromManifest(route, options);
+      try {
+        const buildResult = await buildInstance(jayRoute, params, pageModule, instanceCtx);
+        if (buildResult.status !== "success") {
+          result.errors.push({
+            route: route.pattern,
+            params,
+            error: buildResult.reason
+          });
+          continue;
+        }
+        const existingIdx = route.instances.findIndex((i) => paramsMatch(i.params, params));
+        if (existingIdx >= 0) {
+          route.instances[existingIdx] = buildResult.instanceEntry;
+          orphanedFiles.push(...oldFiles);
+        } else {
+          route.instances.push(buildResult.instanceEntry);
+        }
+        result.rebuilt++;
+        logger.important(`[Rebuild] ${route.pattern} (${JSON.stringify(params)}): rebuilt`);
+      } catch (err) {
+        result.errors.push({
+          route: route.pattern,
+          params,
+          error: err.message
+        });
       }
-    } else {
-      input = await parseBody(req);
     }
-  } catch {
-    jsonResponse(res, 400, {
-      success: false,
-      error: {
-        code: "INVALID_INPUT",
-        message: "Failed to parse request input",
-        isActionError: false
-      }
-    });
-    return;
   }
-  if (registry.isStreaming(actionName)) {
-    res.writeHead(200, {
-      "Content-Type": "application/x-ndjson",
-      "Transfer-Encoding": "chunked"
-    });
+  if (result.rebuilt > 0) {
+    const tempPath = manifestPath + ".tmp";
+    await fs.writeFile(tempPath, JSON.stringify(manifest, null, 2));
+    await fs.rename(tempPath, manifestPath);
+    const metadataPath = path.join(buildDir, "backend", "build-metadata.json");
     try {
-      const generator = registry.executeStream(actionName, input);
-      for await (const chunk of generator) {
-        res.write(JSON.stringify({ chunk }) + "\n");
-      }
-      res.write(JSON.stringify({ done: true }) + "\n");
-    } catch (err) {
-      res.write(JSON.stringify({ error: err.message }) + "\n");
+      const metadata = JSON.parse(await fs.readFile(metadataPath, "utf-8"));
+      metadata.buildTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+      metadata.instanceCount = manifest.routes.reduce((n, r) => n + r.instances.length, 0);
+      await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    } catch {
+      await fs.writeFile(
+        metadataPath,
+        JSON.stringify(
+          {
+            version: options.version,
+            sourceHash: "",
+            buildTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            nodeVersion: process.version,
+            instanceCount: manifest.routes.reduce((n, r) => n + r.instances.length, 0)
+          },
+          null,
+          2
+        )
+      );
+    }
+    logger.important(`[Rebuild] Manifest and metadata updated`);
+    if (orphanedFiles.length > 0) {
+      await appendCleanupManifest(buildDir, orphanedFiles);
+      logger.info(`[Rebuild] ${orphanedFiles.length} orphaned file(s) queued for cleanup`);
     }
-    res.end();
-    return;
   }
-  const result = await registry.execute(actionName, input);
-  if (result.success) {
-    if (requestMethod === "GET") {
-      const cacheHeaders = registry.getCacheHeaders(actionName);
-      if (cacheHeaders) {
-        res.setHeader("Cache-Control", cacheHeaders);
+  logger.important(
+    `[Rebuild] Done: ${result.affected} affected, ${result.rebuilt} rebuilt, ${result.errors.length} errors`
+  );
+  return result;
+}
+function resolveTarget(manifest, target) {
+  switch (target.mode) {
+    case "contract": {
+      const routes = resolveContractToRoutes(manifest, target.contractName);
+      return {
+        routes,
+        params: target.params,
+        label: `contract "${target.contractName}"${target.params ? ` (${JSON.stringify(target.params)})` : ""}`
+      };
+    }
+    case "route": {
+      const route = manifest.routes.find((r) => r.pattern === target.routePattern);
+      return {
+        routes: route ? [route] : [],
+        params: target.params,
+        label: `route "${target.routePattern}"${target.params ? ` (${JSON.stringify(target.params)})` : ""}`
+      };
+    }
+    case "url": {
+      const match = matchRequest(manifest, target.url);
+      if (!match) {
+        return { routes: [], label: `url "${target.url}"` };
       }
+      return {
+        routes: [match.route],
+        params: match.params,
+        label: `url "${target.url}" → ${match.route.pattern} (${JSON.stringify(match.params)})`
+      };
     }
-    jsonResponse(res, 200, { success: true, data: result.data });
-  } else {
-    const statusCode = getStatusCode(result.error.code, result.error.isActionError);
-    jsonResponse(res, statusCode, { success: false, error: result.error });
   }
 }
-async function registerActionsFromManifest(actions, buildDir, registry = actionRegistry) {
-  const logger = getLogger();
-  let count = 0;
-  for (const entry of actions) {
+async function rebuildContract(options) {
+  return rebuild({
+    ...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 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++;
-        }
+      const pluginModule = await import(route.serverModule);
+      const comp = pluginModule[route.componentExport || "page"];
+      if (comp?.jayHtmlPath) {
+        resolvedJayHtmlPath = comp.jayHtmlPath;
       }
-    } catch (err) {
-      logger.error(
-        `[Server] Failed to load action module ${entry.serverModule}: ${err.message}`
-      );
+    } catch {
     }
   }
-  logger.info(`[Server] Registered ${count} actions`);
+  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
+  };
 }
-function jsonResponse(res, status, body) {
-  const json = JSON.stringify(body);
-  res.writeHead(status, {
-    "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(json)
-  });
-  res.end(json);
+const segmentTypeMap = {
+  param: 0,
+  catchAll: 1,
+  optional: 2
+};
+function paramsMatch(instanceParams, targetParams) {
+  return Object.entries(targetParams).every(([key, value]) => instanceParams[key] === value);
 }
-function parseBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => {
-      const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw) {
-        resolve({});
-        return;
-      }
-      try {
-        resolve(JSON.parse(raw));
-      } catch {
-        reject(new Error("Invalid JSON body"));
-      }
-    });
-    req.on("error", reject);
-  });
+function collectInstanceFiles(instance) {
+  if (!instance.cachePath)
+    return [];
+  const files = [instance.cachePath, instance.serverElementPath, instance.clientBundlePath];
+  if (instance.clientCssPath)
+    files.push(instance.clientCssPath);
+  return files.filter(Boolean);
 }
-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;
+async function appendCleanupManifest(buildDir, files) {
+  const cleanupPath = path.join(buildDir, "cleanup-manifest.json");
+  let existing = [];
+  try {
+    existing = JSON.parse(await fs.readFile(cleanupPath, "utf-8"));
+  } catch {
   }
+  existing.push(...files);
+  await fs.writeFile(cleanupPath, JSON.stringify(existing, null, 2));
 }
-async function startMainServer(options) {
+async function cleanupOrphanedFiles(buildRoot, version) {
   const logger = getLogger();
-  const buildDir = path.join(options.buildRoot, `v${options.version}`);
-  const artifacts = new FilesystemArtifactStore(buildDir);
-  const manifest = await artifacts.readManifest();
-  logger.important(
-    `[Server] Loaded manifest: ${manifest.routes.length} routes, v${manifest.version}`
-  );
-  const { discoverPluginsWithInit, sortPluginsByDependencies } = await import("@jay-framework/stack-server-runtime");
+  const buildDir = path.join(buildRoot, `v${version}`);
+  const cleanupPath = path.join(buildDir, "cleanup-manifest.json");
+  let files;
   try {
-    const pluginsWithInit = sortPluginsByDependencies(
-      await discoverPluginsWithInit({ projectRoot: manifest.projectRoot })
-    );
-    for (const pluginInit of pluginsWithInit) {
-      try {
-        const pluginModule = await import(pluginInit.packageName);
-        const init = pluginModule.init || pluginModule[pluginInit.initExport || "init"];
-        if (init?._serverInit) {
-          logger.info(`[Server] Running plugin init: ${pluginInit.name}`);
-          const data = await init._serverInit();
-          if (data)
-            setClientInitData(pluginInit.name, data);
-        }
-      } catch (err) {
-        logger.warn(`[Server] Plugin init failed: ${pluginInit.name}: ${err.message}`);
-      }
-    }
+    files = JSON.parse(await fs.readFile(cleanupPath, "utf-8"));
   } catch {
+    logger.info("[Cleanup] No cleanup manifest found");
+    return 0;
   }
-  const initModule = await artifacts.loadPageModule("server/init.js").catch(() => null);
-  if (initModule) {
-    const init = initModule.init || initModule.default;
-    if (init?._serverInit) {
-      logger.important("[Server] Running server init...");
-      const data = await init._serverInit();
-      if (data)
-        setClientInitData("project", data);
+  let deleted = 0;
+  for (const file of files) {
+    try {
+      await fs.unlink(path.join(buildDir, file));
+      deleted++;
+    } catch {
     }
   }
-  if (manifest.actions.length > 0) {
-    await registerActionsFromManifest(manifest.actions, buildDir);
+  await fs.unlink(cleanupPath);
+  logger.important(`[Cleanup] Deleted ${deleted}/${files.length} orphaned files`);
+  return deleted;
+}
+async function startRendererServer(options) {
+  const logger = getLogger();
+  const buildDir = path.join(options.buildRoot, `v${options.version}`);
+  const serverBuildDir = path.join(buildDir, "server");
+  logger.important(`[Renderer] Starting renderer server v${options.version}`);
+  await initializeServices(buildDir, options.projectRoot, "Renderer");
+  const webhooks = await discoverWebhooks(options.projectRoot, serverBuildDir);
+  const webhookMap = /* @__PURE__ */ new Map();
+  for (const wh of webhooks) {
+    webhookMap.set(wh.name, wh);
   }
+  logger.important(
+    `[Renderer] ${webhookMap.size} webhook(s) registered: ${[...webhookMap.keys()].join(", ") || "none"}`
+  );
+  const createInvalidateForWebhook = () => {
+    return async (contractName, params) => {
+      await rebuildContract({
+        projectRoot: options.projectRoot,
+        pagesRoot: options.pagesRoot,
+        buildRoot: options.buildRoot,
+        version: options.version,
+        contractName,
+        params,
+        tsConfigFilePath: options.tsConfigFilePath,
+        minify: options.minify
+      });
+    };
+  };
+  const startTime = Date.now();
+  let lastWebhook;
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url || "/", `http://${req.headers.host}`);
     try {
-      if (isActionRequest(url.pathname)) {
-        await handleActionRequest(req, res);
+      const webhookMatch = url.pathname.match(/^\/_jay\/webhooks\/(.+)$/);
+      if (webhookMatch && req.method === "POST") {
+        const webhookName = webhookMatch[1];
+        const discovered = webhookMap.get(webhookName);
+        if (!discovered) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: `Unknown webhook: ${webhookName}` }));
+          return;
+        }
+        const body = await readBody(req);
+        const event = {
+          type: webhookName,
+          payload: JSON.parse(body || "{}"),
+          headers: req.headers
+        };
+        const invalidate = createInvalidateForWebhook();
+        const resolver = globalThis.__JAY_SERVICE_RESOLVER__;
+        const services = resolver ? resolver(discovered.webhook.services) : [];
+        await discovered.webhook.handler(event, invalidate, ...services);
+        lastWebhook = { name: webhookName, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
         return;
       }
-      const handled = await handleStaticRequest(
-        req,
-        res,
-        path.join(buildDir, "shared"),
-        "/shared/"
-      );
-      if (handled)
-        return;
-      const handledInstances = await handleStaticRequest(
-        req,
-        res,
-        path.join(buildDir, "pre-rendered"),
-        "/pre-rendered/"
-      );
-      if (handledInstances)
+      if (url.pathname === "/_jay/rebuild" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req) || "{}");
+        const { contract, route, url: rebuildUrl, params } = body;
+        let target;
+        if (contract) {
+          target = { mode: "contract", contractName: contract, params };
+        } else if (route) {
+          target = { mode: "route", routePattern: route, params };
+        } else if (rebuildUrl) {
+          target = { mode: "url", url: rebuildUrl };
+        } else {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              error: 'One of "contract", "route", or "url" is required'
+            })
+          );
+          return;
+        }
+        const result = await rebuild({
+          projectRoot: options.projectRoot,
+          pagesRoot: options.pagesRoot,
+          buildRoot: options.buildRoot,
+          version: options.version,
+          target,
+          tsConfigFilePath: options.tsConfigFilePath,
+          minify: options.minify
+        });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
         return;
-      const currentManifest = await artifacts.readManifest();
-      const match = matchRequest(currentManifest, url.pathname);
-      if (!match) {
-        res.writeHead(404);
-        res.end("Not Found");
+      }
+      if (url.pathname === "/_jay/status" && req.method === "GET") {
+        const manifest = JSON.parse(
+          await fs.readFile(path.join(buildDir, "route-manifest.json"), "utf-8")
+        );
+        const status = {
+          version: options.version,
+          buildTimestamp: manifest.buildTimestamp,
+          instanceCount: manifest.routes.reduce((n, r) => n + r.instances.length, 0),
+          uptime: Math.floor((Date.now() - startTime) / 1e3),
+          webhooks: [...webhookMap.keys()],
+          lastWebhook
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(status, null, 2));
         return;
       }
-      await handlePageRequest(res, match, currentManifest, artifacts);
+      res.writeHead(404);
+      res.end("Not Found");
     } catch (err) {
-      logger.error(`[Server] Error handling ${url.pathname}: ${err.message}`);
+      logger.error(`[Renderer] Error: ${err.message}`);
       if (!res.headersSent) {
-        res.writeHead(500);
-        res.end("Internal Server Error");
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: err.message }));
       }
     }
   });
   server.listen(options.port, () => {
     logger.important(
-      `[Server] Production server listening on http://localhost:${options.port}`
+      `[Renderer] Renderer server listening on http://localhost:${options.port}`
     );
   });
 }
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
 export {
+  FilesystemArtifactStore,
   buildVersion,
-  startMainServer
+  cleanupOrphanedFiles,
+  fetchActionRequest,
+  fetchPageRequest,
+  fetchStaticFile,
+  initializeServices,
+  e as initializeServicesFromModules,
+  isActionRequest,
+  matchRequest,
+  rebuild,
+  rebuildContract,
+  registerActionsFromManifest,
+  b as registerActionsFromModules,
+  resolveContractToRoutes,
+  startMainServer,
+  startRendererServer
 };