@jay-framework/production-server 0.17.3 → 0.17.4

package/dist/index.js

@@ -12,15 +12,16 @@ 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 { 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 crypto from "node:crypto";
 import fs$1 from "node:fs";
 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 } from "@jay-framework/fullstack-component";
+import { isJayAction, isJayStreamAction, isJayWebhook } from "@jay-framework/fullstack-component";
 async function discoverServerEntries(projectRoot, pagesRoot) {
   const logger = getLogger();
   const routes = await scanRoutes(pagesRoot, {
@@ -57,7 +58,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);
           }
@@ -226,6 +227,7 @@ async function loadProductionPageParts(route, pageModule, jayHtmlContent, projec
   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(",")}`
@@ -261,21 +263,26 @@ async function loadProductionPageParts(route, pageModule, jayHtmlContent, projec
     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: headlessImport.contract ? {
-          contractName: headlessImport.contract.name,
-          metadata: headlessImport.metadata
-        } : void 0
+        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({
@@ -283,6 +290,13 @@ async function loadProductionPageParts(route, pageModule, jayHtmlContent, projec
         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) => ({
@@ -315,10 +329,101 @@ async function loadProductionPageParts(route, pageModule, jayHtmlContent, projec
     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,
@@ -482,7 +587,7 @@ function resolvePackageNameForRoute(compPath) {
   }
   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 +596,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) {
   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");
+  const serverBuildDir = path.join(ctx.backendDir, "server");
   const pageParts = await loadProductionPageParts(
     route,
     pageModule,
@@ -513,6 +621,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.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,
@@ -619,39 +759,62 @@ async function buildInstance(route, params, pageModule, ctx) {
       }
     }
   }
-  const preRenderedPath = path.join(instanceDir, `${instanceId}.jay-html`);
+  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(instanceDir, `${instanceId}.cache.json`);
+  const cacheMetadataPath = path.join(backendInstanceDir, `${instanceId}.cache.json`);
   await fs.writeFile(
     cacheMetadataPath,
     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 serverElementPath = path.join(backendInstanceDir, `${instanceId}.server-element.js`);
   const serverElementResult = await compileServerElement(
     preRenderedJayHtml,
     `${instanceId}.jay-html`,
-    instanceDir,
+    backendInstanceDir,
     serverElementPath,
     ctx.projectRoot,
     ctx.tsConfigFilePath,
     sourceDir
   );
-  const hydrateEntryPath = path.join(instanceDir, `${instanceId}.hydrate-entry.ts`);
-  const relativeJayHtmlPath = path.relative(instanceDir, preRenderedPath);
+  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(instanceDir, route.compPath);
+    pageModulePath = pkgName ? `${pkgName}/client` : "./" + path.relative(backendInstanceDir, route.compPath);
     pageExportName = route.componentExport;
   } else if (route.compPath) {
-    pageModulePath = "./" + path.relative(instanceDir, route.compPath);
+    pageModulePath = "./" + path.relative(backendInstanceDir, route.compPath);
     pageExportName = "page";
   } else {
     pageModulePath = "";
@@ -675,7 +838,7 @@ async function buildInstance(route, params, pageModule, ctx) {
   const clientResult = await buildInstanceClient(
     hydrateEntryPath,
     instanceId,
-    instanceDir,
+    frontendInstanceDir,
     ctx.projectRoot,
     ctx.jayOptions,
     ctx.minify ?? true,
@@ -684,14 +847,27 @@ async function buildInstance(route, params, pageModule, ctx) {
   );
   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 });
+    }
+  }
   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
+    preRenderedPath: path.relative(ctx.backendDir, preRenderedPath),
+    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
   };
-  return { status: "success", instanceEntry, slowViewState, carryForward };
+  return { status: "success", instanceEntry, slowViewState, carryForward, contracts };
 }
 function convertSegments(segments) {
   return segments.map((s) => {
@@ -713,7 +889,6 @@ function buildRouteEntry(route, serverModulePath) {
     pattern: route.rawRoute,
     segments: convertSegments(route.segments),
     serverModule: serverModulePath,
-    jayHtmlPath: route.jayHtmlPath,
     componentExport: route.componentExport,
     instances: []
   };
@@ -1006,11 +1181,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 +1199,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 +1209,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 +1284,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 +1321,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 +1352,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)
@@ -1228,6 +1408,9 @@ async function buildVersion(options) {
         const result = await buildInstance(route, params, pageModule, instanceCtx);
         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 +1431,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,9 +1445,16 @@ 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;
 }
@@ -1274,17 +1463,24 @@ 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");
-    const stat = await fs.stat(manifestPath);
-    if (this.manifestCache && stat.mtimeMs === this.manifestCache.mtime) {
-      return this.manifestCache.manifest;
+    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"));
-    this.manifestCache = { manifest, mtime: stat.mtimeMs };
+    const manifestStat = await fs.stat(manifestPath);
+    this.manifestCache = { manifest, mtime: manifestStat.mtimeMs };
     return manifest;
   }
   async readPreRenderedHtml(relativePath) {
@@ -1315,6 +1511,9 @@ class FilesystemArtifactStore {
   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);
@@ -1421,56 +1620,23 @@ function buildImportMap(sharedManifest, publicBasePath, sharedDir = "shared") {
   return imports;
 }
 const pagePartsCache = /* @__PURE__ */ new Map();
-async function getPageParts(route, pageModule, artifacts, preRenderedPath, manifest) {
+async function getPageParts(route, artifacts, preRenderedPath) {
   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: ""
-        }
-      ],
-      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
-  );
+  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 handlePageRequest(res, match, manifest, artifacts) {
+async function fetchPageRequest(match, manifest, requestUrl, artifacts, staticBaseUrl, cookies = {}) {
   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 pageParts = await getPageParts(route, artifacts, instance.preRenderedPath);
+  const query = Object.fromEntries(requestUrl.searchParams.entries());
   const fastResult = await renderFastChangingData(
     match.params,
     { params: match.params, query },
@@ -1480,17 +1646,19 @@ async function handlePageRequest(res, match, manifest, artifacts) {
     pageParts.forEachInstances,
     pageParts.headlessInstanceComponents,
     preRendered.slowViewState,
-    query
+    query,
+    cookies
   );
   if (fastResult.kind === "Redirect3xx") {
-    res.writeHead(fastResult.status, { Location: fastResult.location });
-    res.end();
-    return;
+    return new Response(null, {
+      status: fastResult.status,
+      headers: { Location: fastResult.location }
+    });
   }
   if (fastResult.kind === "ServerError5xx" || fastResult.kind === "ClientError4xx") {
-    res.writeHead(fastResult.status);
-    res.end(fastResult.message || "Error");
-    return;
+    return new Response(fastResult.message || "Error", {
+      status: fastResult.status
+    });
   }
   const fastViewState = fastResult.rendered || {};
   const fastCarryForward = fastResult.carryForward || {};
@@ -1503,7 +1671,6 @@ async function handlePageRequest(res, match, manifest, artifacts) {
     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,
@@ -1511,15 +1678,15 @@ async function handlePageRequest(res, match, manifest, artifacts) {
   );
   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>
+  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" />
@@ -1529,82 +1696,47 @@ ${headParts}
   </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))
-        )
-      );
-    }
-  });
-  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(`
+      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>`);
-  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;
-  }
-  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;
-  } catch {
-    return false;
-  }
+      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 handleActionRequest(req, res, registry = actionRegistry) {
-  const url = new URL(req.url || "/", `http://${req.headers.host}`);
+async function fetchActionRequest(request, registry = actionRegistry) {
+  const url = new URL(request.url);
   const actionName = url.pathname.slice(ACTION_PREFIX.length);
   if (!actionName) {
-    jsonResponse(res, 400, {
+    return jsonResponse(400, {
       success: false,
       error: {
         code: "MISSING_ACTION_NAME",
@@ -1612,11 +1744,10 @@ async function handleActionRequest(req, res, registry = actionRegistry) {
         isActionError: false
       }
     });
-    return;
   }
   const action = registry.get(actionName);
   if (!action) {
-    jsonResponse(res, 404, {
+    return jsonResponse(404, {
       success: false,
       error: {
         code: "ACTION_NOT_FOUND",
@@ -1624,11 +1755,10 @@ async function handleActionRequest(req, res, registry = actionRegistry) {
         isActionError: false
       }
     });
-    return;
   }
-  const requestMethod = (req.method || "GET").toUpperCase();
+  const requestMethod = request.method.toUpperCase();
   if (requestMethod !== action.method) {
-    jsonResponse(res, 405, {
+    return jsonResponse(405, {
       success: false,
       error: {
         code: "METHOD_NOT_ALLOWED",
@@ -1636,7 +1766,6 @@ async function handleActionRequest(req, res, registry = actionRegistry) {
         isActionError: false
       }
     });
-    return;
   }
   let input;
   try {
@@ -1649,10 +1778,11 @@ async function handleActionRequest(req, res, registry = actionRegistry) {
         delete input._input;
       }
     } else {
-      input = await parseBody(req);
+      const text = await request.text();
+      input = text ? JSON.parse(text) : {};
     }
   } catch {
-    jsonResponse(res, 400, {
+    return jsonResponse(400, {
       success: false,
       error: {
         code: "INVALID_INPUT",
@@ -1660,39 +1790,50 @@ async function handleActionRequest(req, res, registry = actionRegistry) {
         isActionError: false
       }
     });
-    return;
   }
   if (registry.isStreaming(actionName)) {
-    res.writeHead(200, {
-      "Content-Type": "application/x-ndjson",
-      "Transfer-Encoding": "chunked"
-    });
-    try {
-      const generator = registry.executeStream(actionName, input);
-      for await (const chunk of generator) {
-        res.write(JSON.stringify({ chunk }) + "\n");
+    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();
       }
-      res.write(JSON.stringify({ done: true }) + "\n");
-    } catch (err) {
-      res.write(JSON.stringify({ error: err.message }) + "\n");
-    }
-    res.end();
-    return;
+    });
+    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) {
-        res.setHeader("Cache-Control", cacheHeaders);
+        headers["Cache-Control"] = cacheHeaders;
       }
     }
-    jsonResponse(res, 200, { success: true, data: result.data });
+    return jsonResponse(200, { success: true, data: result.data }, headers);
   } else {
     const statusCode = getStatusCode(result.error.code, result.error.isActionError);
-    jsonResponse(res, statusCode, { success: false, error: result.error });
+    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;
@@ -1717,33 +1858,6 @@ async function registerActionsFromManifest(actions, buildDir, registry = actionR
   }
   logger.info(`[Server] Registered ${count} actions`);
 }
-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);
-}
-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 getStatusCode(code, isActionError) {
   if (isActionError)
     return 422;
@@ -1761,71 +1875,186 @@ function getStatusCode(code, isActionError) {
       return 500;
   }
 }
-async function startMainServer(options) {
+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 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");
   try {
     const pluginsWithInit = sortPluginsByDependencies(
-      await discoverPluginsWithInit({ projectRoot: manifest.projectRoot })
+      await discoverPluginsWithInit({ projectRoot })
     );
     for (const pluginInit of pluginsWithInit) {
       try {
-        const pluginModule = await import(pluginInit.packageName);
+        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(`[Server] Running plugin init: ${pluginInit.name}`);
+          logger.info(`[${label}] 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}`);
+        logger.warn(`[${label}] Plugin init failed: ${pluginInit.name}: ${err.message}`);
       }
     }
   } catch {
   }
-  const initModule = await artifacts.loadPageModule("server/init.js").catch(() => null);
-  if (initModule) {
+  const initModulePath = path.join(buildDir, "server", "init.js");
+  try {
+    const initModule = await import(initModulePath);
     const init = initModule.init || initModule.default;
     if (init?._serverInit) {
-      logger.important("[Server] Running server init...");
+      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();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value)
+      headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+  }
+  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);
+}
+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();
+    }
+  }
+  res.end();
+}
+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, buildDir);
+    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 (isActionRequest(url.pathname)) {
-        await handleActionRequest(req, res);
+      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;
       }
-      const handled = await handleStaticRequest(
-        req,
-        res,
-        path.join(buildDir, "shared"),
-        "/shared/"
-      );
-      if (handled)
+      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;
-      const handledInstances = await handleStaticRequest(
-        req,
-        res,
-        path.join(buildDir, "pre-rendered"),
-        "/pre-rendered/"
-      );
-      if (handledInstances)
+      }
+      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) {
@@ -1833,9 +2062,20 @@ async function startMainServer(options) {
         res.end("Not Found");
         return;
       }
-      await handlePageRequest(res, match, currentManifest, artifacts);
+      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");
@@ -1846,9 +2086,505 @@ async function startMainServer(options) {
     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`
+      );
+    }
+  });
+}
+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}`
+            );
+          }
+        }
+      } catch (err) {
+        logger.warn(
+          `[Renderer] Failed to load webhooks from ${packageName}: ${err.message}`
+        );
+      }
+    }
+  } catch {
+  }
+  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}`
+          );
+        }
+      }
+    }
+  } catch {
+  }
+  const webhooksDir = path.join(serverBuildDir, "webhooks");
+  try {
+    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 webhooks;
+}
+function resolveContractToRoutes(manifest, contractName) {
+  return manifest.routes.filter((r) => r.contracts && r.contracts.includes(contractName));
+}
+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: [] };
+  }
+  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;
+      }
+      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
+        });
+      }
+    }
+  }
+  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 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`);
+    }
+  }
+  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)})`
+      };
+    }
+  }
+}
+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 pluginModule = await import(route.serverModule);
+      const comp = pluginModule[route.componentExport || "page"];
+      if (comp?.jayHtmlPath) {
+        resolvedJayHtmlPath = comp.jayHtmlPath;
+      }
+    } catch {
+    }
+  }
+  return {
+    rawRoute: route.pattern,
+    segments: route.segments.map((s) => {
+      if (s.type === "static")
+        return s.value;
+      return { name: s.value, type: segmentTypeMap[s.type] };
+    }),
+    jayHtmlPath: resolvedJayHtmlPath,
+    compPath: route.isPlugin ? route.serverModule : void 0,
+    componentExport: route.componentExport
+  };
+}
+const segmentTypeMap = {
+  param: 0,
+  catchAll: 1,
+  optional: 2
+};
+function paramsMatch(instanceParams, targetParams) {
+  return Object.entries(targetParams).every(([key, value]) => instanceParams[key] === value);
+}
+function collectInstanceFiles(instance) {
+  if (!instance.preRenderedPath)
+    return [];
+  const files = [
+    instance.preRenderedPath,
+    instance.preRenderedPath.replace(".jay-html", ".cache.json"),
+    instance.serverElementPath,
+    instance.clientBundlePath
+  ];
+  if (instance.clientCssPath)
+    files.push(instance.clientCssPath);
+  return files.filter(Boolean);
+}
+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 cleanupOrphanedFiles(buildRoot, version) {
+  const logger = getLogger();
+  const buildDir = path.join(buildRoot, `v${version}`);
+  const cleanupPath = path.join(buildDir, "cleanup-manifest.json");
+  let files;
+  try {
+    files = JSON.parse(await fs.readFile(cleanupPath, "utf-8"));
+  } catch {
+    logger.info("[Cleanup] No cleanup manifest found");
+    return 0;
+  }
+  let deleted = 0;
+  for (const file of files) {
+    try {
+      await fs.unlink(path.join(buildDir, file));
+      deleted++;
+    } catch {
+    }
+  }
+  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 {
+      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;
+      }
+      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;
+      }
+      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;
+      }
+      res.writeHead(404);
+      res.end("Not Found");
+    } catch (err) {
+      logger.error(`[Renderer] Error: ${err.message}`);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+    }
+  });
+  server.listen(options.port, () => {
+    logger.important(
+      `[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,
+  isActionRequest,
+  matchRequest,
+  rebuild,
+  rebuildContract,
+  registerActionsFromManifest,
+  resolveContractToRoutes,
+  startMainServer,
+  startRendererServer
 };