@jay-framework/production-server 0.17.0

package/dist/index.js

@@ -0,0 +1,1854 @@
+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";
+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 crypto from "node:crypto";
+import fs$1 from "node:fs";
+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";
+async function discoverServerEntries(projectRoot, pagesRoot) {
+  const logger = getLogger();
+  const routes = await scanRoutes(pagesRoot, {
+    jayHtmlFilename: "page.jay-html",
+    compFilename: "page.ts"
+  });
+  const pages = {};
+  for (const route of routes) {
+    if (route.compPath) {
+      const relativePath = path.relative(projectRoot, route.compPath);
+      const entryName = relativePath.replace(/^src\//, "").replace(/\.ts$/, "");
+      pages[entryName] = route.compPath;
+    }
+  }
+  const actions = {};
+  const actionsDir = path.join(projectRoot, "src", "actions");
+  try {
+    const files = await fs.readdir(actionsDir);
+    for (const file of files) {
+      if (file.endsWith(".actions.ts")) {
+        const entryName = "actions/" + file.replace(/\.ts$/, "");
+        actions[entryName] = path.join(actionsDir, file);
+      }
+    }
+  } catch {
+  }
+  for (const subDir of ["plugins", "components"]) {
+    const scanDir = path.join(projectRoot, "src", subDir);
+    try {
+      const dirs = await fs.readdir(scanDir, { withFileTypes: true });
+      for (const dir of dirs) {
+        if (!dir.isDirectory())
+          continue;
+        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") {
+            const entryName = `${subDir}/${dir.name}/${file.replace(/\.ts$/, "")}`;
+            pages[entryName] = path.join(dirPath, file);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  let init;
+  const initPaths = [
+    path.join(projectRoot, "src", "lib", "init.ts"),
+    path.join(projectRoot, "src", "init.ts")
+  ];
+  for (const initPath of initPaths) {
+    try {
+      await fs.access(initPath);
+      init = initPath;
+      break;
+    } catch {
+    }
+  }
+  const entries = { init, pages, actions };
+  logger.info(
+    `[Build] Discovered: ${Object.keys(pages).length} pages, ${Object.keys(actions).length} actions, init: ${init ? "yes" : "no"}`
+  );
+  return { entries, routes };
+}
+async function buildServerCode(entries, jayOptions, outputDir, projectRoot) {
+  const logger = getLogger();
+  logger.info("[Build] Compiling server code...");
+  const input = {};
+  if (entries.init) {
+    input["init"] = entries.init;
+  }
+  for (const [name, filePath] of Object.entries(entries.pages)) {
+    input[name] = filePath;
+  }
+  for (const [name, filePath] of Object.entries(entries.actions)) {
+    input[name] = filePath;
+  }
+  if (Object.keys(input).length === 0) {
+    logger.info("[Build] No server entries to compile");
+    return;
+  }
+  await build({
+    root: projectRoot,
+    plugins: [...jayStackCompiler(jayOptions)],
+    build: {
+      ssr: true,
+      outDir: outputDir,
+      emptyOutDir: true,
+      minify: false,
+      rollupOptions: {
+        input,
+        external: [
+          /^node:/,
+          /^@jay-framework\//,
+          // Plugin packages are pre-compiled, externalize them
+          /^@wix\//
+        ],
+        output: {
+          entryFileNames: "[name].js",
+          chunkFileNames: "chunks/[name]-[hash].js",
+          format: "es"
+        }
+      }
+    },
+    logLevel: "warn"
+  });
+  logger.info(`[Build] Server code compiled to ${outputDir}`);
+}
+createRequire(import.meta.url);
+const FRAMEWORK_PACKAGES = [
+  "@jay-framework/stack-client-runtime",
+  "@jay-framework/component",
+  "@jay-framework/reactive",
+  "@jay-framework/runtime",
+  "@jay-framework/view-state-merge",
+  "@jay-framework/fullstack-component"
+];
+async function buildSharedChunks(outputDir, _projectRoot, minify = true, pluginClientPackages = []) {
+  const logger = getLogger();
+  logger.info("[Build] Building shared client chunks...");
+  await fs.mkdir(outputDir, { recursive: true });
+  const allPackages = [...FRAMEWORK_PACKAGES, ...pluginClientPackages];
+  const entries = {};
+  for (const pkg of allPackages) {
+    const varName = pkgToVarName(pkg);
+    const entryPath = path.join(outputDir, `_shared_${varName}.js`);
+    await fs.writeFile(entryPath, `export * from '${pkg}';
+`);
+    entries[varName] = entryPath;
+  }
+  const dedupePackages = [...allPackages, "@jay-framework/list-compare"];
+  await build({
+    build: {
+      outDir: outputDir,
+      emptyOutDir: true,
+      minify,
+      manifest: "vite-manifest.json",
+      rollupOptions: {
+        input: entries,
+        output: {
+          entryFileNames: "[name]-[hash].js",
+          chunkFileNames: "[name]-[hash].js",
+          format: "es"
+        },
+        preserveEntrySignatures: "exports-only"
+      }
+    },
+    resolve: {
+      dedupe: dedupePackages
+    },
+    logLevel: "warn"
+  });
+  for (const pkg of allPackages) {
+    const varName = pkgToVarName(pkg);
+    await fs.rm(path.join(outputDir, `_shared_${varName}.js`), { force: true });
+  }
+  const manifest = await parseViteManifest(outputDir, allPackages);
+  logger.info(`[Build] Shared chunks built: ${Object.keys(manifest).length} entries`);
+  return { manifest, outputDir };
+}
+function pkgToVarName(pkg) {
+  return pkg.replace("@jay-framework/", "").replace(/[/-]/g, "_");
+}
+async function parseViteManifest(outputDir, packages) {
+  const viteManifestPath = path.join(outputDir, "vite-manifest.json");
+  const raw = JSON.parse(await fs.readFile(viteManifestPath, "utf-8"));
+  const varNameToPackage = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    varNameToPackage.set(pkgToVarName(pkg), pkg);
+  }
+  const manifest = {};
+  for (const [, entry] of Object.entries(raw)) {
+    if (!entry.isEntry)
+      continue;
+    const outputBase = path.basename(entry.file, ".js");
+    for (const [varName, pkg] of varNameToPackage) {
+      if (outputBase.startsWith(varName)) {
+        manifest[pkg] = entry.file;
+        break;
+      }
+    }
+  }
+  const sharedManifestPath = path.join(outputDir, "shared-manifest.json");
+  await fs.writeFile(sharedManifestPath, JSON.stringify(manifest, null, 2));
+  await fs.rm(viteManifestPath, { force: true });
+  return manifest;
+}
+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) {
+  const sorted = Object.keys(params).sort().reduce(
+    (acc, key) => {
+      acc[key] = params[key];
+      return acc;
+    },
+    {}
+  );
+  const json = JSON.stringify(sorted);
+  if (json === "{}")
+    return "";
+  return "_" + crypto.createHash("md5").update(json).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 instanceId = `page${paramHash}`;
+  const instanceDir = path.join(ctx.buildDir, "pre-rendered", routeDir);
+  await fs.mkdir(instanceDir, { 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 pageParts = await loadProductionPageParts(
+    route,
+    pageModule,
+    jayHtmlContent,
+    ctx.projectRoot,
+    ctx.tsConfigFilePath,
+    serverBuildDir
+  );
+  const slowPhase = new DevSlowlyChangingPhase();
+  const slowResult = await slowPhase.runSlowlyForPage(
+    params,
+    { params },
+    pageParts.parts,
+    pageParts.discoveredInstances,
+    pageParts.headlessInstanceComponents,
+    route.jayHtmlPath
+  );
+  if (slowResult.kind !== "PhaseOutput") {
+    if (slowResult.kind === "ClientError" || slowResult.kind === "Redirect") {
+      return {
+        status: "skipped",
+        reason: `${slowResult.kind} ${slowResult.status ?? ""} ${slowResult.message ?? ""}`.trim()
+      };
+    }
+    throw new Error(
+      `Slow render failed for ${route.rawRoute} with params ${JSON.stringify(params)}: ${slowResult.kind}`
+    );
+  }
+  const slowViewState = slowResult.rendered;
+  const carryForward = slowResult.carryForward;
+  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(", ")}`
+    );
+  }
+  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;
+        }
+      }
+    }
+  }
+  const preRenderedPath = path.join(instanceDir, `${instanceId}.jay-html`);
+  await fs.writeFile(preRenderedPath, preRenderedJayHtml, "utf-8");
+  const cacheMetadataPath = path.join(instanceDir, `${instanceId}.cache.json`);
+  await fs.writeFile(
+    cacheMetadataPath,
+    JSON.stringify({
+      slowViewState,
+      carryForward,
+      sourcePath: route.jayHtmlPath
+    }),
+    "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;
+  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
+  };
+  return { status: "success", instanceEntry, slowViewState, carryForward };
+}
+function convertSegments(segments) {
+  return segments.map((s) => {
+    if (typeof s === "string") {
+      return { type: "static", value: s };
+    }
+    switch (s.type) {
+      case JayRouteParamType.single:
+        return { type: "param", value: s.name };
+      case JayRouteParamType.catchAll:
+        return { type: "catchAll", value: s.name };
+      case JayRouteParamType.optional:
+        return { type: "optional", value: s.name };
+    }
+  });
+}
+function buildRouteEntry(route, serverModulePath) {
+  return {
+    pattern: route.rawRoute,
+    segments: convertSegments(route.segments),
+    serverModule: serverModulePath,
+    jayHtmlPath: route.jayHtmlPath,
+    componentExport: route.componentExport,
+    instances: []
+  };
+}
+async function discoverActions(actionPaths, serverOutputDir, buildDir, projectRoot) {
+  const actions = [];
+  const plugins = [];
+  for (const [entryName, sourcePath] of Object.entries(actionPaths)) {
+    try {
+      const code = await fs.readFile(sourcePath, "utf-8");
+      const extracted = extractActionsFromSource(code, sourcePath);
+      if (extracted.length > 0) {
+        actions.push({
+          serverModule: path.relative(
+            buildDir,
+            path.join(serverOutputDir, entryName + ".js")
+          ),
+          isPlugin: false,
+          actionNames: extracted.map((a) => a.actionName)
+        });
+      }
+    } catch {
+      getLogger().warn(`[Build] Could not extract actions from ${sourcePath}`);
+    }
+  }
+  try {
+    const scannedPlugins = await scanPlugins({ projectRoot });
+    for (const [packageName, plugin] of scannedPlugins) {
+      if (plugin.isLocal)
+        continue;
+      plugins.push({ name: plugin.manifest.name, packageName });
+      const pluginActions = plugin.manifest.actions;
+      if (pluginActions && pluginActions.length > 0) {
+        actions.push({
+          serverModule: "",
+          packageName,
+          isPlugin: true,
+          actionNames: pluginActions.map(
+            (a) => typeof a === "string" ? a : a.name
+          )
+        });
+        getLogger().info(
+          `[Build] Plugin actions from ${packageName}: ${pluginActions.length}`
+        );
+      }
+    }
+  } catch (err) {
+    getLogger().warn(`[Build] Plugin action scan failed: ${err.message}`);
+  }
+  return { actions, plugins };
+}
+async function writeRouteManifest(manifest, buildDir) {
+  const manifestPath = path.join(buildDir, "route-manifest.json");
+  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  getLogger().info(
+    `[Build] Route manifest written: ${manifest.routes.length} routes, ${manifest.routes.reduce((n, r) => n + r.instances.length, 0)} instances`
+  );
+}
+createRequire(import.meta.url);
+async function scanPluginRoutes(projectRoot, projectRoutes) {
+  const logger = getLogger();
+  const plugins = await scanPlugins({ projectRoot });
+  const projectPaths = new Set(projectRoutes.map((r) => r.rawRoute));
+  const pluginRoutes = [];
+  for (const [, plugin] of plugins) {
+    if (plugin.isLocal)
+      continue;
+    if (!plugin.manifest.routes)
+      continue;
+    for (const route of plugin.manifest.routes) {
+      if (projectPaths.has(route.path)) {
+        logger.info(
+          `[Routes] Plugin "${plugin.manifest.name}" route ${route.path} skipped — project route takes precedence`
+        );
+        continue;
+      }
+      const jayHtmlPath = resolvePluginExport(plugin.pluginPath, route.jayHtml);
+      if (!jayHtmlPath) {
+        logger.warn(
+          `[Routes] Plugin "${plugin.manifest.name}" route ${route.path}: jayHtml "${route.jayHtml}" not found`
+        );
+        continue;
+      }
+      const compPath = resolvePluginModule(plugin.pluginPath);
+      const componentExport = route.component;
+      pluginRoutes.push({
+        segments: parseRouteSegments(route.path),
+        rawRoute: route.path,
+        jayHtmlPath,
+        compPath,
+        componentExport
+      });
+      logger.info(`[Routes] Plugin "${plugin.manifest.name}" provides route ${route.path}`);
+    }
+  }
+  return pluginRoutes;
+}
+function resolvePluginExport(pluginPath, exportSubpath) {
+  const normalized = exportSubpath.replace(/^\.\//, "");
+  const packageJsonPath = path.join(pluginPath, "package.json");
+  try {
+    const packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.exports) {
+      const exportKey = "./" + normalized;
+      const exportValue = packageJson.exports[exportKey];
+      if (exportValue) {
+        const resolved = typeof exportValue === "string" ? exportValue : exportValue.default || exportValue.import || exportValue.require;
+        if (resolved)
+          return path.join(pluginPath, resolved);
+      }
+    }
+  } catch {
+  }
+  for (const dir of ["dist", "lib", ""]) {
+    const candidate = path.join(pluginPath, dir, normalized);
+    try {
+      fs$1.accessSync(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePluginModule(pluginPath) {
+  const pkgJsonPath = path.join(pluginPath, "package.json");
+  try {
+    const pkg = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf-8"));
+    const mainExport = pkg.exports?.["."];
+    const mainPath = typeof mainExport === "string" ? mainExport : mainExport?.default || mainExport?.import || pkg.main;
+    if (mainPath) {
+      const resolved = path.join(pluginPath, mainPath);
+      if (fs$1.existsSync(resolved))
+        return resolved;
+    }
+  } catch {
+  }
+  return path.join(pluginPath, "dist", "index.js");
+}
+function crossProductParams(parts) {
+  if (parts.length === 0)
+    return [];
+  if (parts.length === 1)
+    return parts[0].values;
+  const logger = getLogger();
+  for (let i = 0; i < parts.length; i++) {
+    for (let j = i + 1; j < parts.length; j++) {
+      for (const key of parts[i].keys) {
+        if (parts[j].keys.has(key)) {
+          logger.warn(
+            `[Build] Multiple loadParams provide key "${key}" — using first provider`
+          );
+        }
+      }
+    }
+  }
+  let result = parts[0].values;
+  for (let i = 1; i < parts.length; i++) {
+    const next = parts[i].values;
+    const combined = [];
+    for (const a of result) {
+      for (const b of next) {
+        combined.push({ ...a, ...b });
+      }
+    }
+    result = combined;
+  }
+  return result;
+}
+function paramsMatchInferred(params, inferredParams, optionalSegments) {
+  return Object.entries(inferredParams).every(([k, v]) => {
+    if (optionalSegments?.has(k))
+      return true;
+    return params[k] === v;
+  });
+}
+function computeSpecificity(route) {
+  const dynamicCount = (route.rawRoute.match(/\[/g) || []).length;
+  const inferredCount = route.inferredParams ? Object.keys(route.inferredParams).length : 0;
+  const unresolvedCount = Math.max(0, dynamicCount - inferredCount);
+  return 0 - unresolvedCount;
+}
+function buildUrl(route, params) {
+  return route.rawRoute.replace(/\[\[(\w+)\]\]/g, (_, name) => {
+    const value = params[name];
+    if (!value)
+      return "";
+    if (route.inferredParams?.[name] === value)
+      return "";
+    return value;
+  }).replace(/\[(\w+)\]/g, (_, name) => params[name] || "").replace(/\/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function materializeRouteParams(routes, loadParamsResults) {
+  const entries = [];
+  for (const route of routes) {
+    const specificity = computeSpecificity(route);
+    if (!route.hasDynamicParams) {
+      const params = route.inferredParams || {};
+      entries.push({ route, params, url: route.rawRoute, specificity });
+      continue;
+    }
+    const allParams = loadParamsResults.get(route) || [];
+    for (const params of allParams) {
+      if (route.inferredParams && !paramsMatchInferred(params, route.inferredParams, route.optionalSegments)) {
+        continue;
+      }
+      let mergedParams = params;
+      if (route.inferredParams) {
+        mergedParams = { ...params };
+        for (const [k, v] of Object.entries(route.inferredParams)) {
+          if (!(k in mergedParams)) {
+            mergedParams[k] = v;
+          }
+        }
+      }
+      const url = buildUrl(route, mergedParams);
+      entries.push({ route, params: mergedParams, url, specificity });
+    }
+  }
+  return entries;
+}
+function dedupeByUrl(entries) {
+  const logger = getLogger();
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = byUrl.get(entry.url);
+    if (!existing) {
+      byUrl.set(entry.url, entry);
+    } else if (entry.specificity > existing.specificity) {
+      byUrl.set(entry.url, entry);
+    }
+  }
+  const deduped = [...byUrl.values()];
+  if (deduped.length < entries.length) {
+    logger.info(
+      `[Build] Deduplication: ${entries.length} materialized → ${deduped.length} unique URLs`
+    );
+  }
+  return deduped;
+}
+async function discoverPluginClientPackages(projectRoot) {
+  const projectRequire = createRequire(path.join(projectRoot, "package.json"));
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  async function walk(pkgName) {
+    if (seen.has(pkgName))
+      return;
+    seen.add(pkgName);
+    try {
+      const mainPath = projectRequire.resolve(pkgName);
+      let pkgDir = path.dirname(mainPath);
+      while (pkgDir !== path.dirname(pkgDir)) {
+        const candidate = path.join(pkgDir, "package.json");
+        try {
+          const pkgJson = JSON.parse(await fs.readFile(candidate, "utf-8"));
+          if (pkgJson.name === pkgName) {
+            if (pkgJson.exports?.["./client"]) {
+              result.push(`${pkgName}/client`);
+            }
+            for (const dep of Object.keys(pkgJson.dependencies || {})) {
+              if (dep.startsWith("@jay-framework/")) {
+                await walk(dep);
+              }
+            }
+            break;
+          }
+        } catch {
+        }
+        pkgDir = path.dirname(pkgDir);
+      }
+    } catch {
+    }
+  }
+  try {
+    const projectPkg = JSON.parse(
+      await fs.readFile(path.join(projectRoot, "package.json"), "utf-8")
+    );
+    const allDeps = {
+      ...projectPkg.dependencies,
+      ...projectPkg.devDependencies
+    };
+    for (const dep of Object.keys(allDeps)) {
+      if (dep.startsWith("@jay-framework/")) {
+        await walk(dep);
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+async function buildVersion(options) {
+  const logger = getLogger();
+  const buildDir = path.join(options.buildRoot, `v${options.version}`);
+  logger.important(`[Build] Starting production build v${options.version}`);
+  logger.important(`[Build] Project: ${options.projectRoot}`);
+  await fs.mkdir(buildDir, { recursive: true });
+  const { entries, routes } = await discoverServerEntries(options.projectRoot, options.pagesRoot);
+  const serverOutputDir = path.join(buildDir, "server");
+  await buildServerCode(
+    entries,
+    { tsConfigFilePath: options.tsConfigFilePath },
+    serverOutputDir,
+    options.projectRoot
+  );
+  const pluginClientPackages = await discoverPluginClientPackages(options.projectRoot);
+  if (pluginClientPackages.length > 0) {
+    logger.important(`[Build] Plugin client packages: ${pluginClientPackages.join(", ")}`);
+  }
+  const sharedOutputDir = path.join(buildDir, "shared");
+  const { manifest: sharedManifest } = await buildSharedChunks(
+    sharedOutputDir,
+    options.projectRoot,
+    options.minify ?? true,
+    pluginClientPackages
+  );
+  const { actions, plugins } = await discoverActions(
+    entries.actions,
+    serverOutputDir,
+    buildDir,
+    options.projectRoot
+  );
+  const { discoverPluginsWithInit, sortPluginsByDependencies } = await import("@jay-framework/stack-server-runtime");
+  try {
+    const pluginsWithInit = sortPluginsByDependencies(
+      await discoverPluginsWithInit({ projectRoot: options.projectRoot })
+    );
+    for (const pluginInit of pluginsWithInit) {
+      try {
+        const pluginModule = await import(pluginInit.packageName);
+        const init = pluginModule.init || pluginModule[pluginInit.initExport || "init"];
+        if (init?._serverInit) {
+          logger.info(`[Build] Running plugin init: ${pluginInit.name}`);
+          await init._serverInit();
+        }
+      } catch (err) {
+        logger.warn(`[Build] Plugin init failed: ${pluginInit.name}: ${err.message}`);
+      }
+    }
+  } catch {
+  }
+  if (entries.init) {
+    const initModulePath = path.join(serverOutputDir, "init.js");
+    try {
+      const initModule = await import(initModulePath);
+      const init = initModule.init || initModule.default;
+      if (init?._serverInit) {
+        logger.info("[Build] Running server init...");
+        await init._serverInit();
+      }
+    } catch (err) {
+      logger.error(`[Build] Failed to run init: ${err}`);
+      throw err;
+    }
+  }
+  const clientInits = [];
+  try {
+    const allPluginsWithInit = sortPluginsByDependencies(
+      await discoverPluginsWithInit({ projectRoot: options.projectRoot })
+    );
+    for (const pluginInit of allPluginsWithInit) {
+      if (pluginInit.isLocal)
+        continue;
+      const clientImportPath = `${pluginInit.packageName}/client`;
+      try {
+        const clientModule = await import(clientImportPath);
+        const init = clientModule[pluginInit.initExport || "init"] || clientModule.init;
+        if (init?._clientInit) {
+          clientInits.push({
+            modulePath: clientImportPath,
+            exportName: pluginInit.initExport || "init",
+            key: pluginInit.name
+          });
+        }
+      } catch {
+      }
+    }
+  } catch (err) {
+    logger.warn(`[Build] Client init discovery failed: ${err.message}`);
+  }
+  if (clientInits.length > 0) {
+    logger.important(`[Build] Client inits: ${clientInits.map((ci) => ci.key).join(", ")}`);
+  }
+  if (entries.init) {
+    clientInits.push({
+      modulePath: entries.init,
+      exportName: "init",
+      key: "project"
+    });
+  }
+  const instanceCtx = {
+    projectRoot: options.projectRoot,
+    pagesRoot: options.pagesRoot,
+    buildDir,
+    jayOptions: { tsConfigFilePath: options.tsConfigFilePath },
+    tsConfigFilePath: options.tsConfigFilePath,
+    minify: options.minify ?? true,
+    clientInits
+  };
+  const pluginRoutes = await scanPluginRoutes(options.projectRoot, routes);
+  const allRoutes = [...routes, ...pluginRoutes];
+  const routeEntries = allRoutes.map((route) => {
+    let serverModule = "";
+    if (route.compPath) {
+      if (route.componentExport) {
+        serverModule = route.compPath;
+      } else {
+        const relativePath = path.relative(options.projectRoot, route.compPath);
+        serverModule = relativePath.replace(/^src\//, "server/").replace(/\.ts$/, ".js").replace(/\[/g, "_").replace(/\]/g, "_");
+      }
+    }
+    const entry = buildRouteEntry(route, serverModule);
+    if (route.componentExport) {
+      entry.isPlugin = true;
+    }
+    return { route, entry };
+  });
+  let instanceCount = 0;
+  let totalExpected = 0;
+  function logInstance(routeName, params) {
+    instanceCount++;
+    const paramStr = Object.keys(params).length > 0 ? ` (${Object.entries(params).map(([k, v]) => `${k}=${v}`).join(", ")})` : "";
+    logger.important(`[Build] ${instanceCount}/${totalExpected} ${routeName}${paramStr}`);
+  }
+  async function loadPageModule(entry) {
+    if (!entry.serverModule)
+      return {};
+    if (entry.isPlugin)
+      return import(entry.serverModule);
+    return import(path.join(serverOutputDir, entry.serverModule.replace("server/", "")));
+  }
+  const routeInfos = routeEntries.map((re) => {
+    const optionalNames = re.route.segments.filter((s) => typeof s !== "string" && s.type === JayRouteParamType.optional).map((s) => s.name);
+    return {
+      rawRoute: re.route.rawRoute,
+      inferredParams: re.route.inferredParams,
+      optionalSegments: optionalNames.length > 0 ? new Set(optionalNames) : void 0,
+      hasDynamicParams: re.route.segments.some((s) => typeof s !== "string"),
+      routeEntry: re
+    };
+  });
+  const loadParamsCache = /* @__PURE__ */ new Map();
+  const loadParamsResults = /* @__PURE__ */ new Map();
+  for (const info of routeInfos) {
+    if (!info.hasDynamicParams)
+      continue;
+    const { route, entry } = info.routeEntry;
+    let pageModule;
+    try {
+      pageModule = await loadPageModule(entry);
+    } catch (err) {
+      logger.error(`[Build] Failed to load page module ${entry.serverModule}: ${err}`);
+      continue;
+    }
+    const pageParts = await loadProductionPageParts(
+      route,
+      pageModule,
+      await fs.readFile(route.jayHtmlPath, "utf-8"),
+      options.projectRoot,
+      options.tsConfigFilePath,
+      path.join(buildDir, "server")
+    );
+    const partsWithLoadParams = pageParts.parts.filter((p) => p.compDefinition?.loadParams);
+    if (partsWithLoadParams.length === 0)
+      continue;
+    const paramParts = [];
+    for (const part of partsWithLoadParams) {
+      const fn = part.compDefinition.loadParams;
+      if (!loadParamsCache.has(fn)) {
+        logger.important(`[Build] Loading params for ${route.rawRoute}...`);
+        const partParams = [];
+        let batchIndex = 0;
+        for await (const batch of runLoadParams([part])) {
+          partParams.push(...batch);
+          batchIndex++;
+          if (batchIndex > 1) {
+            logger.important(`[Build]   ...${partParams.length} params so far`);
+          }
+        }
+        loadParamsCache.set(fn, partParams);
+      }
+      const cached = loadParamsCache.get(fn);
+      const keys = new Set(cached.flatMap((p) => Object.keys(p)));
+      paramParts.push({ keys, values: cached });
+    }
+    loadParamsResults.set(info, crossProductParams(paramParts));
+  }
+  const materialized = materializeRouteParams(routeInfos, loadParamsResults);
+  const deduped = dedupeByUrl(materialized);
+  totalExpected = deduped.length;
+  const byRoute = /* @__PURE__ */ new Map();
+  for (const materialized2 of deduped) {
+    const info = materialized2.route;
+    if (!byRoute.has(info))
+      byRoute.set(info, []);
+    byRoute.get(info).push(materialized2.params);
+  }
+  for (const [info, paramsList] of byRoute) {
+    const { route, entry } = info.routeEntry;
+    let pageModule;
+    try {
+      pageModule = await loadPageModule(entry);
+    } catch (err) {
+      logger.error(`[Build] Failed to load page module ${entry.serverModule}: ${err}`);
+      continue;
+    }
+    if (paramsList.length > 1 || info.hasDynamicParams) {
+      logger.important(
+        `[Build] Route ${route.rawRoute}: ${paramsList.length} param combinations`
+      );
+    }
+    for (const params of paramsList) {
+      try {
+        const result = await buildInstance(route, params, pageModule, instanceCtx);
+        if (result.status === "success") {
+          entry.instances.push(result.instanceEntry);
+          logInstance(route.rawRoute || "/", params);
+        } else {
+          logger.warn(
+            `[Build] Skipped ${route.rawRoute} (${JSON.stringify(params)}): ${result.reason}`
+          );
+          totalExpected--;
+        }
+      } catch (err) {
+        instanceCount++;
+        logger.error(
+          `[Build] ${instanceCount}/${totalExpected} FAILED ${route.rawRoute || "/"} (${JSON.stringify(params)}): ${err.message}`
+        );
+      }
+    }
+  }
+  const manifest = {
+    version: options.version,
+    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);
+  const metadata = {
+    version: options.version,
+    sourceHash: "",
+    buildTimestamp: manifest.buildTimestamp,
+    nodeVersion: process.version,
+    instanceCount
+  };
+  await fs.writeFile(
+    path.join(buildDir, "build-metadata.json"),
+    JSON.stringify(metadata, null, 2)
+  );
+  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);
+  }
+  async loadModule(relativePath) {
+    const fullPath = path.join(this.basePath, relativePath);
+    const stat = await fs.stat(fullPath);
+    const cached = this.moduleCache.get(relativePath);
+    if (cached && stat.mtimeMs === cached.mtime) {
+      return cached.module;
+    }
+    const mod = await import(fullPath + "?t=" + stat.mtimeMs);
+    this.moduleCache.set(relativePath, { module: mod, mtime: stat.mtimeMs });
+    return mod;
+  }
+}
+function extractCacheMetadata(fileContent) {
+  const startIdx = fileContent.indexOf(CACHE_TAG_START);
+  if (startIdx === -1) {
+    return { content: fileContent, slowViewState: {}, carryForward: {} };
+  }
+  const jsonStart = startIdx + CACHE_TAG_START.length;
+  const endIdx = fileContent.indexOf(CACHE_TAG_END, jsonStart);
+  if (endIdx === -1) {
+    return { content: fileContent, slowViewState: {}, carryForward: {} };
+  }
+  const jsonStr = fileContent.substring(jsonStart, endIdx);
+  const metadata = JSON.parse(jsonStr);
+  const tagEnd = endIdx + CACHE_TAG_END.length;
+  const afterTag = fileContent[tagEnd] === "\n" ? tagEnd + 1 : tagEnd;
+  const content = fileContent.substring(0, startIdx) + fileContent.substring(afterTag);
+  return {
+    content,
+    slowViewState: metadata.slowViewState || {},
+    carryForward: metadata.carryForward || {}
+  };
+}
+function matchRequest(manifest, pathname) {
+  const urlSegments = pathname.split("/").filter((s) => s.length > 0);
+  for (const route of manifest.routes) {
+    const params = matchSegments(route.segments, urlSegments);
+    if (params) {
+      const instance = findInstance(route, params);
+      if (instance) {
+        return { route, instance, params, pathname };
+      }
+    }
+  }
+  return void 0;
+}
+function matchSegments(routeSegments, urlSegments) {
+  const params = {};
+  let urlIdx = 0;
+  for (let i = 0; i < routeSegments.length; i++) {
+    const seg = routeSegments[i];
+    if (seg.type === "static") {
+      if (urlIdx >= urlSegments.length || urlSegments[urlIdx] !== seg.value) {
+        return void 0;
+      }
+      urlIdx++;
+    } else if (seg.type === "param") {
+      if (urlIdx >= urlSegments.length)
+        return void 0;
+      params[seg.value] = urlSegments[urlIdx];
+      urlIdx++;
+    } else if (seg.type === "optional") {
+      if (urlIdx < urlSegments.length) {
+        params[seg.value] = urlSegments[urlIdx];
+        urlIdx++;
+      }
+    } else if (seg.type === "catchAll") {
+      if (urlIdx >= urlSegments.length)
+        return void 0;
+      params[seg.value] = urlSegments.slice(urlIdx).join("/");
+      urlIdx = urlSegments.length;
+    } else if (seg.type === "optionalCatchAll") {
+      if (urlIdx < urlSegments.length) {
+        params[seg.value] = urlSegments.slice(urlIdx).join("/");
+        urlIdx = urlSegments.length;
+      }
+    }
+  }
+  if (urlIdx !== urlSegments.length)
+    return void 0;
+  return params;
+}
+function findInstance(route, params) {
+  const paramNames = new Set(
+    route.segments.filter((s) => s.type !== "static").map((s) => s.value)
+  );
+  return route.instances.find((instance) => {
+    for (const name of paramNames) {
+      const urlVal = params[name];
+      const instVal = instance.params[name];
+      if (urlVal === void 0 && instVal === void 0)
+        continue;
+      if (urlVal !== instVal)
+        return false;
+    }
+    return true;
+  });
+}
+function buildImportMap(sharedManifest, publicBasePath, sharedDir = "shared") {
+  const imports = {};
+  for (const [pkgName, hashedFile] of Object.entries(sharedManifest)) {
+    imports[pkgName] = `${publicBasePath}${sharedDir}/${hashedFile}`;
+  }
+  return imports;
+}
+const pagePartsCache = /* @__PURE__ */ new Map();
+async function getPageParts(route, 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: ""
+        }
+      ],
+      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;
+  }
+  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))
+        )
+      );
+    }
+  });
+  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;
+  }
+  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;
+  }
+}
+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}`);
+  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;
+  }
+  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
+      }
+    });
+    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;
+      }
+    } 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"
+    });
+    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");
+    }
+    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);
+      }
+    }
+    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) {
+    try {
+      const modulePath = entry.isPlugin ? entry.packageName : `${buildDir}/${entry.serverModule}`;
+      const mod = await import(modulePath);
+      for (const [, exported] of Object.entries(mod)) {
+        if (isJayAction(exported)) {
+          registry.register(exported);
+          count++;
+        } else if (isJayStreamAction(exported)) {
+          registry.registerStream(exported);
+          count++;
+        }
+      }
+    } catch (err) {
+      logger.error(
+        `[Server] Failed to load action module ${entry.serverModule}: ${err.message}`
+      );
+    }
+  }
+  logger.info(`[Server] Registered ${count} actions`);
+}
+function 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;
+  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 startMainServer(options) {
+  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 })
+    );
+    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}`);
+      }
+    }
+  } catch {
+  }
+  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);
+    }
+  }
+  if (manifest.actions.length > 0) {
+    await registerActionsFromManifest(manifest.actions, buildDir);
+  }
+  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);
+        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)
+        return;
+      const currentManifest = await artifacts.readManifest();
+      const match = matchRequest(currentManifest, url.pathname);
+      if (!match) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      await handlePageRequest(res, match, currentManifest, artifacts);
+    } catch (err) {
+      logger.error(`[Server] Error handling ${url.pathname}: ${err.message}`);
+      if (!res.headersSent) {
+        res.writeHead(500);
+        res.end("Internal Server Error");
+      }
+    }
+  });
+  server.listen(options.port, () => {
+    logger.important(
+      `[Server] Production server listening on http://localhost:${options.port}`
+    );
+  });
+}
+export {
+  buildVersion,
+  startMainServer
+};