@jay-framework/dev-server 0.9.0 → 0.11.0

package/dist/index.js

@@ -6,14 +6,16 @@ var __publicField = (obj, key, value) => {
 };
 import { createServer } from "vite";
 import { scanRoutes, routeToExpressRoute } from "@jay-framework/stack-route-scanner";
-import { runInitCallbacks, runShutdownCallbacks, clearLifecycleCallbacks, clearServiceRegistry, DevSlowlyChangingPhase, loadPageParts, renderFastChangingData, generateClientScript } from "@jay-framework/stack-server-runtime";
+import { discoverPluginsWithInit, sortPluginsByDependencies, executePluginServerInits, runInitCallbacks, actionRegistry, discoverAndRegisterActions, discoverAllPluginActions, runShutdownCallbacks, clearLifecycleCallbacks, clearServiceRegistry, clearClientInitData, DevSlowlyChangingPhase, SlowRenderCache, preparePluginClientInits, loadPageParts, renderFastChangingData, generateClientScript, getClientInitData } from "@jay-framework/stack-server-runtime";
 import { jayRuntime } from "@jay-framework/vite-plugin";
 import { createRequire } from "module";
 import "@jay-framework/compiler-shared";
 import * as path from "node:path";
 import path__default from "node:path";
-import "@jay-framework/compiler-jay-html";
+import { parseContract, slowRenderTransform } from "@jay-framework/compiler-jay-html";
+import { createRequire as createRequire$1 } from "node:module";
 import * as fs from "node:fs";
+import fs$1 from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 const s$1 = createRequire(import.meta.url), e$1 = s$1("typescript"), c$1 = new Proxy(e$1, {
   get(t, r) {
@@ -365,7 +367,7 @@ const {
   SyntaxKind: SyntaxKind$4,
   isStringLiteral: isStringLiteral$7,
   visitNode: visitNode$4,
-  isFunctionDeclaration: isFunctionDeclaration$1$1,
+  isFunctionDeclaration: isFunctionDeclaration$1,
   isVariableStatement: isVariableStatement$2,
   isImportDeclaration: isImportDeclaration$3,
   isBlock: isBlock$2,
@@ -464,7 +466,7 @@ class SourceFileBindingResolver {
       return node;
     };
     const visitor = (node) => {
-      if (isFunctionDeclaration$1$1(node))
+      if (isFunctionDeclaration$1(node))
         nbResolversQueue[0].addFunctionDeclaration(node);
       if (isVariableStatement$2(node))
         nbResolversQueue[0].addVariableStatement(node);
@@ -599,18 +601,25 @@ function areVariableRootsEqual(root1, root2) {
       return false;
   }
 }
-const SERVER_METHODS = /* @__PURE__ */ new Set([
+const COMPONENT_SERVER_METHODS = /* @__PURE__ */ new Set([
   "withServices",
   "withLoadParams",
   "withSlowlyRender",
   "withFastRender"
 ]);
-const CLIENT_METHODS = /* @__PURE__ */ new Set([
-  "withInteractive",
-  "withContexts"
-]);
+const COMPONENT_CLIENT_METHODS = /* @__PURE__ */ new Set(["withInteractive", "withContexts"]);
+const INIT_SERVER_METHODS = /* @__PURE__ */ new Set(["withServer"]);
+const INIT_CLIENT_METHODS = /* @__PURE__ */ new Set(["withClient"]);
 function shouldRemoveMethod(methodName, environment) {
-  return environment === "client" && SERVER_METHODS.has(methodName) || environment === "server" && CLIENT_METHODS.has(methodName);
+  if (environment === "client" && COMPONENT_SERVER_METHODS.has(methodName))
+    return true;
+  if (environment === "server" && COMPONENT_CLIENT_METHODS.has(methodName))
+    return true;
+  if (environment === "client" && INIT_SERVER_METHODS.has(methodName))
+    return true;
+  if (environment === "server" && INIT_CLIENT_METHODS.has(methodName))
+    return true;
+  return false;
 }
 const { isCallExpression: isCallExpression$1, isPropertyAccessExpression: isPropertyAccessExpression$1, isIdentifier: isIdentifier$2, isStringLiteral } = c$1;
 function findBuilderMethodsToRemove(sourceFile, bindingResolver, environment) {
@@ -631,6 +640,7 @@ function findBuilderMethodsToRemove(sourceFile, bindingResolver, environment) {
   sourceFile.forEachChild(visit);
   return { callsToRemove, removedVariables };
 }
+const JAY_BUILDER_FUNCTIONS = /* @__PURE__ */ new Set(["makeJayStackComponent", "makeJayInit"]);
 function isPartOfJayStackChain(callExpr, bindingResolver) {
   let current = callExpr.expression;
   while (true) {
@@ -640,7 +650,7 @@ function isPartOfJayStackChain(callExpr, bindingResolver) {
       if (isIdentifier$2(current.expression)) {
         const variable = bindingResolver.explain(current.expression);
         const flattened = flattenVariable(variable);
-        if (flattened.path.length === 1 && flattened.path[0] === "makeJayStackComponent" && isImportModuleVariableRoot(flattened.root) && isStringLiteral(flattened.root.module) && flattened.root.module.text === "@jay-framework/fullstack-component")
+        if (flattened.path.length === 1 && JAY_BUILDER_FUNCTIONS.has(flattened.path[0]) && isImportModuleVariableRoot(flattened.root) && isStringLiteral(flattened.root.module) && flattened.root.module.text === "@jay-framework/fullstack-component")
           return true;
       }
       if (isPropertyAccessExpression$1(current.expression)) {
@@ -670,15 +680,15 @@ function collectVariablesFromArguments(args, bindingResolver, variables) {
 const {
   isIdentifier: isIdentifier$1,
   isImportDeclaration: isImportDeclaration$1,
-  isFunctionDeclaration: isFunctionDeclaration$1,
-  isVariableStatement: isVariableStatement$1,
-  isInterfaceDeclaration: isInterfaceDeclaration$1,
-  isTypeAliasDeclaration: isTypeAliasDeclaration$1,
+  isFunctionDeclaration,
+  isVariableStatement,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration,
   isClassDeclaration,
   isEnumDeclaration,
   SyntaxKind
 } = c$1;
-function analyzeUnusedStatements(sourceFile, bindingResolver) {
+function analyzeUnusedStatements(sourceFile) {
   const statementsToRemove = /* @__PURE__ */ new Set();
   const collectUsedIdentifiers = () => {
     const used = /* @__PURE__ */ new Set();
@@ -739,19 +749,19 @@ function isExportStatement(statement) {
   return false;
 }
 function getStatementDefinedName(statement) {
-  if (isFunctionDeclaration$1(statement) && statement.name) {
+  if (isFunctionDeclaration(statement) && statement.name) {
     return statement.name.text;
   }
-  if (isVariableStatement$1(statement)) {
+  if (isVariableStatement(statement)) {
     const firstDecl = statement.declarationList.declarations[0];
     if (firstDecl && isIdentifier$1(firstDecl.name)) {
       return firstDecl.name.text;
     }
   }
-  if (isInterfaceDeclaration$1(statement) && statement.name) {
+  if (isInterfaceDeclaration(statement) && statement.name) {
     return statement.name.text;
   }
-  if (isTypeAliasDeclaration$1(statement) && statement.name) {
+  if (isTypeAliasDeclaration(statement) && statement.name) {
     return statement.name.text;
   }
   if (isClassDeclaration(statement) && statement.name) {
@@ -771,19 +781,10 @@ const {
   isPropertyAccessExpression,
   isImportDeclaration,
   isNamedImports,
-  isIdentifier,
-  isFunctionDeclaration,
-  isVariableStatement,
-  isInterfaceDeclaration,
-  isTypeAliasDeclaration
+  isIdentifier
 } = c$1;
 function transformJayStackBuilder(code, filePath, environment) {
-  const sourceFile = createSourceFile(
-    filePath,
-    code,
-    ScriptTarget.Latest,
-    true
-  );
+  const sourceFile = createSourceFile(filePath, code, ScriptTarget.Latest, true);
   const transformers = [mkTransformer(mkJayStackCodeSplitTransformer, { environment })];
   const printer = createPrinter();
   const result = c$1.transform(sourceFile, transformers);
@@ -804,11 +805,7 @@ function mkJayStackCodeSplitTransformer({
   environment
 }) {
   const bindingResolver = new SourceFileBindingResolver(sourceFile);
-  const { callsToRemove, removedVariables } = findBuilderMethodsToRemove(
-    sourceFile,
-    bindingResolver,
-    environment
-  );
+  const { callsToRemove } = findBuilderMethodsToRemove(sourceFile, bindingResolver, environment);
   const transformVisitor = (node) => {
     if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
       const variable = bindingResolver.explain(node.expression);
@@ -820,11 +817,12 @@ function mkJayStackCodeSplitTransformer({
     }
     return visitEachChild(node, transformVisitor, context);
   };
-  let transformedSourceFile = visitEachChild(sourceFile, transformVisitor, context);
-  new SourceFileBindingResolver(transformedSourceFile);
-  const { statementsToRemove, unusedImports } = analyzeUnusedStatements(
-    transformedSourceFile
+  let transformedSourceFile = visitEachChild(
+    sourceFile,
+    transformVisitor,
+    context
   );
+  const { statementsToRemove, unusedImports } = analyzeUnusedStatements(transformedSourceFile);
   const transformedStatements = transformedSourceFile.statements.map((statement) => {
     if (statementsToRemove.has(statement)) {
       return void 0;
@@ -854,32 +852,409 @@ function filterImportDeclaration(statement, unusedImports, factory) {
       importClause,
       importClause.isTypeOnly,
       importClause.name,
-      factory.updateNamedImports(
-        importClause.namedBindings,
-        usedElements
-      )
+      factory.updateNamedImports(importClause.namedBindings, usedElements)
     ),
     statement.moduleSpecifier,
     statement.assertClause
   );
 }
-function jayStackCompiler(jayOptions = {}) {
-  return [
+const actionMetadataCache = /* @__PURE__ */ new Map();
+function clearActionMetadataCache() {
+  actionMetadataCache.clear();
+}
+function isActionImport(importSource) {
+  return importSource.includes(".actions") || importSource.includes("-actions") || importSource.includes("/actions/") || importSource.endsWith("/actions");
+}
+function extractActionsFromSource(sourceCode, filePath) {
+  const cached = actionMetadataCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  const actions = [];
+  const sourceFile = c$1.createSourceFile(
+    filePath,
+    sourceCode,
+    c$1.ScriptTarget.Latest,
+    true
+  );
+  function visit(node) {
+    if (c$1.isVariableStatement(node)) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === c$1.SyntaxKind.ExportKeyword
+      );
+      if (!hasExport) {
+        c$1.forEachChild(node, visit);
+        return;
+      }
+      for (const decl of node.declarationList.declarations) {
+        if (!c$1.isIdentifier(decl.name) || !decl.initializer) {
+          continue;
+        }
+        const exportName = decl.name.text;
+        const actionMeta = extractActionFromExpression(decl.initializer);
+        if (actionMeta) {
+          actions.push({
+            ...actionMeta,
+            exportName
+          });
+        }
+      }
+    }
+    c$1.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  actionMetadataCache.set(filePath, actions);
+  return actions;
+}
+function extractActionFromExpression(node) {
+  let current = node;
+  let method = "POST";
+  let explicitMethod = null;
+  while (c$1.isCallExpression(current)) {
+    const expr = current.expression;
+    if (c$1.isPropertyAccessExpression(expr) && expr.name.text === "withMethod") {
+      const arg = current.arguments[0];
+      if (arg && c$1.isStringLiteral(arg)) {
+        explicitMethod = arg.text;
+      }
+      current = expr.expression;
+      continue;
+    }
+    if (c$1.isPropertyAccessExpression(expr) && ["withServices", "withCaching", "withHandler", "withTimeout"].includes(expr.name.text)) {
+      current = expr.expression;
+      continue;
+    }
+    if (c$1.isIdentifier(expr)) {
+      const funcName = expr.text;
+      if (funcName === "makeJayAction" || funcName === "makeJayQuery") {
+        const nameArg = current.arguments[0];
+        if (nameArg && c$1.isStringLiteral(nameArg)) {
+          method = funcName === "makeJayQuery" ? "GET" : "POST";
+          if (explicitMethod) {
+            method = explicitMethod;
+          }
+          return {
+            actionName: nameArg.text,
+            method
+          };
+        }
+      }
+    }
+    break;
+  }
+  return null;
+}
+const SERVER_ONLY_MODULES = /* @__PURE__ */ new Set([
+  "module",
+  // createRequire
+  "fs",
+  "path",
+  "node:fs",
+  "node:path",
+  "node:module",
+  "child_process",
+  "node:child_process",
+  "crypto",
+  "node:crypto"
+]);
+const SERVER_ONLY_PACKAGE_PATTERNS = [
+  "@jay-framework/compiler-shared",
+  "@jay-framework/stack-server-runtime",
+  "yaml"
+  // Often used in server config
+];
+function createImportChainTracker(options = {}) {
+  const {
+    verbose = false,
+    additionalServerModules = [],
+    additionalServerPatterns = []
+  } = options;
+  const importChain = /* @__PURE__ */ new Map();
+  const detectedServerModules = /* @__PURE__ */ new Set();
+  const serverOnlyModules = /* @__PURE__ */ new Set([...SERVER_ONLY_MODULES, ...additionalServerModules]);
+  const serverOnlyPatterns = [...SERVER_ONLY_PACKAGE_PATTERNS, ...additionalServerPatterns];
+  function isServerOnlyModule(id) {
+    if (serverOnlyModules.has(id)) {
+      return true;
+    }
+    for (const pattern of serverOnlyPatterns) {
+      if (id.includes(pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function buildImportChain(moduleId) {
+    const chain = [moduleId];
+    let current = moduleId;
+    for (let i = 0; i < 100; i++) {
+      const importer = importChain.get(current);
+      if (!importer)
+        break;
+      chain.push(importer);
+      current = importer;
+    }
+    return chain.reverse();
+  }
+  function formatChain(chain) {
+    return chain.map((id, idx) => {
+      const indent = "  ".repeat(idx);
+      const shortId = shortenPath(id);
+      return `${indent}${idx === 0 ? "" : "↳ "}${shortId}`;
+    }).join("\n");
+  }
+  function shortenPath(id) {
+    if (id.includes("node_modules")) {
+      const parts = id.split("node_modules/");
+      return parts[parts.length - 1];
+    }
+    const cwd = process.cwd();
+    if (id.startsWith(cwd)) {
+      return id.slice(cwd.length + 1);
+    }
+    return id;
+  }
+  return {
+    name: "jay-stack:import-chain-tracker",
+    enforce: "pre",
+    buildStart() {
+      importChain.clear();
+      detectedServerModules.clear();
+      if (verbose) {
+        console.log("[import-chain-tracker] Build started, tracking imports...");
+      }
+    },
+    resolveId(source, importer, options2) {
+      if (options2?.ssr) {
+        return null;
+      }
+      if (source.startsWith("\0")) {
+        return null;
+      }
+      if (importer) {
+        if (verbose) {
+          console.log(
+            `[import-chain-tracker] ${shortenPath(importer)} imports ${source}`
+          );
+        }
+      }
+      return null;
+    },
+    load(id) {
+      return null;
+    },
+    transform(code, id, options2) {
+      if (options2?.ssr) {
+        return null;
+      }
+      if (isServerOnlyModule(id)) {
+        detectedServerModules.add(id);
+        const chain = buildImportChain(id);
+        console.error(
+          `
+[import-chain-tracker] ⚠️  Server-only module detected in client build!`
+        );
+        console.error(`Module: ${shortenPath(id)}`);
+        console.error(`Import chain:`);
+        console.error(formatChain(chain));
+        console.error("");
+      }
+      const importRegex = /import\s+(?:(?:\{[^}]*\}|[^{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g;
+      let match;
+      while ((match = importRegex.exec(code)) !== null) {
+        const importedModule = match[1];
+        importChain.set(importedModule, id);
+        if (isServerOnlyModule(importedModule)) {
+          if (!detectedServerModules.has(importedModule)) {
+            detectedServerModules.add(importedModule);
+            console.error(
+              `
+[import-chain-tracker] ⚠️  Server-only import detected in client build!`
+            );
+            console.error(`Module "${importedModule}" imported by: ${shortenPath(id)}`);
+            const chain = buildImportChain(id);
+            chain.push(importedModule);
+            console.error(`Import chain:`);
+            console.error(formatChain(chain));
+            console.error("");
+          }
+        }
+      }
+      return null;
+    },
+    buildEnd() {
+      if (detectedServerModules.size > 0) {
+        console.warn(
+          `
+[import-chain-tracker] ⚠️  ${detectedServerModules.size} server-only module(s) detected during transform:`
+        );
+        for (const mod of detectedServerModules) {
+          console.warn(`  - ${mod}`);
+        }
+        console.warn(
+          "\nNote: These may be stripped by the code-split transform if only used in .withServer()."
+        );
+        console.warn(
+          'If build fails with "not exported" errors, check the import chains above.\n'
+        );
+      } else if (verbose) {
+        console.log(
+          "[import-chain-tracker] ✅ No server-only modules detected in client build"
+        );
+      }
+    }
+  };
+}
+const require2 = createRequire$1(import.meta.url);
+function createDefaultPluginDetector() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    isJayPluginWithClientExport(packageName, projectRoot) {
+      const cacheKey = `${packageName}:${projectRoot}`;
+      if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      let result = false;
+      try {
+        require2.resolve(`${packageName}/plugin.yaml`, { paths: [projectRoot] });
+        try {
+          require2.resolve(`${packageName}/client`, { paths: [projectRoot] });
+          result = true;
+        } catch {
+          result = false;
+        }
+      } catch {
+        result = false;
+      }
+      cache.set(cacheKey, result);
+      return result;
+    }
+  };
+}
+function extractPackageName(source) {
+  if (source.startsWith(".") || source.startsWith("/")) {
+    return null;
+  }
+  if (source.startsWith("@")) {
+    const parts2 = source.split("/");
+    if (parts2.length >= 2) {
+      return `${parts2[0]}/${parts2[1]}`;
+    }
+    return null;
+  }
+  const parts = source.split("/");
+  return parts[0];
+}
+function isSubpathImport(source, packageName) {
+  return source.length > packageName.length && source[packageName.length] === "/";
+}
+const IMPORT_REGEX = /import\s+(.+?)\s+from\s+(['"])([^'"]+)\2/g;
+const EXPORT_FROM_REGEX = /export\s+(.+?)\s+from\s+(['"])([^'"]+)\2/g;
+function transformImports(options) {
+  const { code, projectRoot, filePath, pluginDetector, verbose = false } = options;
+  let hasChanges = false;
+  let result = code;
+  result = result.replace(IMPORT_REGEX, (match, clause, quote, source) => {
+    const packageName = extractPackageName(source);
+    if (!packageName)
+      return match;
+    if (isSubpathImport(source, packageName))
+      return match;
+    if (!pluginDetector.isJayPluginWithClientExport(packageName, projectRoot))
+      return match;
+    hasChanges = true;
+    const newSource = `${packageName}/client`;
+    if (verbose) {
+      console.log(
+        `[plugin-client-import] Rewriting import ${source} -> ${newSource} (in ${path.basename(filePath)})`
+      );
+    }
+    return `import ${clause} from ${quote}${newSource}${quote}`;
+  });
+  result = result.replace(EXPORT_FROM_REGEX, (match, clause, quote, source) => {
+    const packageName = extractPackageName(source);
+    if (!packageName)
+      return match;
+    if (isSubpathImport(source, packageName))
+      return match;
+    if (!pluginDetector.isJayPluginWithClientExport(packageName, projectRoot))
+      return match;
+    hasChanges = true;
+    const newSource = `${packageName}/client`;
+    if (verbose) {
+      console.log(
+        `[plugin-client-import] Rewriting export ${source} -> ${newSource} (in ${path.basename(filePath)})`
+      );
+    }
+    return `export ${clause} from ${quote}${newSource}${quote}`;
+  });
+  return { code: result, hasChanges };
+}
+function createPluginClientImportResolver(options = {}) {
+  const { verbose = false } = options;
+  let projectRoot = options.projectRoot || process.cwd();
+  let isSSRBuild = false;
+  const pluginDetector = options.pluginDetector || createDefaultPluginDetector();
+  return {
+    name: "jay-stack:plugin-client-import",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root || projectRoot;
+      isSSRBuild = !!config.build?.ssr;
+    },
+    transform(code, id, transformOptions) {
+      if (transformOptions?.ssr || isSSRBuild) {
+        return null;
+      }
+      if (!id.endsWith(".ts") && !id.endsWith(".js") && !id.includes(".ts?") && !id.includes(".js?")) {
+        return null;
+      }
+      if (id.includes("node_modules") && !id.includes("@jay-framework")) {
+        return null;
+      }
+      if (!code.includes("@jay-framework/") && !code.includes("from '@") && !code.includes('from "@')) {
+        return null;
+      }
+      const result = transformImports({
+        code,
+        projectRoot,
+        filePath: id,
+        pluginDetector,
+        verbose
+      });
+      if (!result.hasChanges) {
+        return null;
+      }
+      return { code: result.code };
+    }
+  };
+}
+function jayStackCompiler(options = {}) {
+  const { trackImports, ...jayOptions } = options;
+  const moduleCache = /* @__PURE__ */ new Map();
+  const shouldTrackImports = trackImports || process.env.DEBUG_IMPORTS === "1";
+  const trackerOptions = typeof trackImports === "object" ? trackImports : { verbose: process.env.DEBUG_IMPORTS === "1" };
+  const plugins = [];
+  if (shouldTrackImports) {
+    plugins.push(createImportChainTracker(trackerOptions));
+  }
+  plugins.push(createPluginClientImportResolver({ verbose: !!shouldTrackImports }));
+  plugins.push(
     // First: Jay Stack code splitting transformation
     {
       name: "jay-stack:code-split",
       enforce: "pre",
       // Run before jay:runtime
-      transform(code, id) {
-        const isClientBuild = id.includes("?jay-client");
-        const isServerBuild = id.includes("?jay-server");
-        if (!isClientBuild && !isServerBuild) {
+      transform(code, id, options2) {
+        if (!id.endsWith(".ts") && !id.includes(".ts?")) {
           return null;
         }
-        const environment = isClientBuild ? "client" : "server";
-        if (!id.endsWith(".ts") && !id.includes(".ts?")) {
+        const hasComponent = code.includes("makeJayStackComponent");
+        const hasInit = code.includes("makeJayInit");
+        if (!hasComponent && !hasInit) {
           return null;
         }
+        const environment = options2?.ssr ? "server" : "client";
         try {
           return transformJayStackBuilder(code, id, environment);
         } catch (error) {
@@ -888,15 +1263,100 @@ function jayStackCompiler(jayOptions = {}) {
         }
       }
     },
-    // Second: Jay runtime compilation (existing plugin)
+    // Second: Action import transformation (client builds only)
+    // Uses resolveId + load to replace action modules with virtual modules
+    // containing createActionCaller calls BEFORE bundling happens.
+    (() => {
+      let isSSRBuild = false;
+      return {
+        name: "jay-stack:action-transform",
+        enforce: "pre",
+        // Track SSR mode from config
+        configResolved(config) {
+          isSSRBuild = config.build?.ssr ?? false;
+        },
+        buildStart() {
+          clearActionMetadataCache();
+          moduleCache.clear();
+        },
+        async resolveId(source, importer, options2) {
+          if (options2?.ssr || isSSRBuild) {
+            return null;
+          }
+          if (!isActionImport(source)) {
+            return null;
+          }
+          if (!source.startsWith(".") || !importer) {
+            return null;
+          }
+          const importerDir = path.dirname(importer);
+          let resolvedPath = path.resolve(importerDir, source);
+          if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".js")) {
+            if (fs.existsSync(resolvedPath + ".ts")) {
+              resolvedPath += ".ts";
+            } else if (fs.existsSync(resolvedPath + ".js")) {
+              resolvedPath += ".js";
+            } else {
+              return null;
+            }
+          } else if (resolvedPath.endsWith(".js") && !fs.existsSync(resolvedPath)) {
+            const tsPath = resolvedPath.slice(0, -3) + ".ts";
+            if (fs.existsSync(tsPath)) {
+              resolvedPath = tsPath;
+            } else {
+              return null;
+            }
+          }
+          return `\0jay-action:${resolvedPath}`;
+        },
+        async load(id) {
+          if (!id.startsWith("\0jay-action:")) {
+            return null;
+          }
+          const actualPath = id.slice("\0jay-action:".length);
+          let code;
+          try {
+            code = await fs.promises.readFile(actualPath, "utf-8");
+          } catch (err) {
+            console.error(`[action-transform] Could not read ${actualPath}:`, err);
+            return null;
+          }
+          const actions = extractActionsFromSource(code, actualPath);
+          if (actions.length === 0) {
+            console.warn(`[action-transform] No actions found in ${actualPath}`);
+            return null;
+          }
+          const lines = [
+            `import { createActionCaller } from '@jay-framework/stack-client-runtime';`,
+            ""
+          ];
+          for (const action of actions) {
+            lines.push(
+              `export const ${action.exportName} = createActionCaller('${action.actionName}', '${action.method}');`
+            );
+          }
+          if (code.includes("ActionError")) {
+            lines.push(
+              `export { ActionError } from '@jay-framework/stack-client-runtime';`
+            );
+          }
+          const result = lines.join("\n");
+          return result;
+        }
+      };
+    })(),
+    // Third: Jay runtime compilation (existing plugin)
     jayRuntime(jayOptions)
-  ];
+  );
+  return plugins;
 }
 class ServiceLifecycleManager {
   constructor(projectRoot, sourceBase = "src") {
-    __publicField(this, "initFilePath", null);
+    /** Path to project's lib/init.ts (makeJayInit pattern) */
+    __publicField(this, "projectInitFilePath", null);
     __publicField(this, "isInitialized", false);
     __publicField(this, "viteServer", null);
+    __publicField(this, "pluginsWithInit", []);
     this.projectRoot = projectRoot;
     this.sourceBase = sourceBase;
   }
@@ -907,14 +1367,13 @@ class ServiceLifecycleManager {
     this.viteServer = viteServer;
   }
   /**
-   * Finds the jay.init.ts (or .js) file in the source directory.
-   * Looks in: {projectRoot}/{sourceBase}/jay.init.{ts,js,mts,mjs}
+   * Finds the project init file using makeJayInit pattern.
+   * Looks in: {projectRoot}/{sourceBase}/init.{ts,js}
    */
-  findInitFile() {
-    const extensions = [".ts", ".js", ".mts", ".mjs"];
-    const baseFilename = "jay.init";
+  findProjectInitFile() {
+    const extensions = [".ts", ".js"];
     for (const ext of extensions) {
-      const filePath = path.join(this.projectRoot, this.sourceBase, baseFilename + ext);
+      const filePath = path.join(this.projectRoot, this.sourceBase, "init" + ext);
       if (fs.existsSync(filePath)) {
         return filePath;
       }
@@ -922,32 +1381,88 @@ class ServiceLifecycleManager {
     return null;
   }
   /**
-   * Initializes services by loading and executing jay.init.ts
+   * Initializes services by:
+   * 1. Discovering and executing plugin server inits (in dependency order)
+   * 2. Loading and executing project lib/init.ts
+   * 3. Running all registered onInit callbacks
+   * 4. Auto-discovering and registering actions
    */
   async initialize() {
     if (this.isInitialized) {
       console.warn("[Services] Already initialized, skipping...");
       return;
     }
-    this.initFilePath = this.findInitFile();
-    if (!this.initFilePath) {
-      console.log("[Services] No jay.init.ts found in src/, skipping service initialization");
-      return;
+    this.projectInitFilePath = this.findProjectInitFile();
+    const discoveredPlugins = await discoverPluginsWithInit({
+      projectRoot: this.projectRoot,
+      verbose: true
+    });
+    this.pluginsWithInit = sortPluginsByDependencies(discoveredPlugins);
+    if (this.pluginsWithInit.length > 0) {
+      console.log(
+        `[Services] Found ${this.pluginsWithInit.length} plugin(s) with init: ${this.pluginsWithInit.map((p) => p.name).join(", ")}`
+      );
     }
-    console.log(`[Services] Loading initialization file: ${this.initFilePath}`);
-    try {
-      if (this.viteServer) {
-        await this.viteServer.ssrLoadModule(this.initFilePath);
-      } else {
-        const fileUrl = pathToFileURL(this.initFilePath).href;
-        await import(fileUrl);
+    await executePluginServerInits(this.pluginsWithInit, this.viteServer ?? void 0, true);
+    if (this.projectInitFilePath) {
+      console.log("[DevServer] Loading project init: src/init.ts");
+      try {
+        if (this.viteServer) {
+          const module = await this.viteServer.ssrLoadModule(this.projectInitFilePath);
+          if (module.init?._serverInit) {
+            console.log("[DevServer] Running server init: project");
+            const { setClientInitData } = await import("@jay-framework/stack-server-runtime");
+            const clientData = await module.init._serverInit();
+            if (clientData !== void 0 && clientData !== null) {
+              setClientInitData("project", clientData);
+            }
+          }
+        } else {
+          const fileUrl = pathToFileURL(this.projectInitFilePath).href;
+          await import(fileUrl);
+        }
+      } catch (error) {
+        console.error("[Services] Failed to load project init:", error);
+        throw error;
       }
-      await runInitCallbacks();
-      this.isInitialized = true;
-      console.log("[Services] Initialization complete");
+    } else {
+      console.log("[Services] No init.ts found, skipping project initialization");
+    }
+    await runInitCallbacks();
+    console.log("[Services] Initialization complete");
+    await this.discoverActions();
+    this.isInitialized = true;
+  }
+  /**
+   * Auto-discovers and registers actions from project and plugins.
+   */
+  async discoverActions() {
+    let totalActions = 0;
+    try {
+      const result = await discoverAndRegisterActions({
+        projectRoot: this.projectRoot,
+        actionsDir: path.join(this.sourceBase, "actions"),
+        registry: actionRegistry,
+        verbose: true,
+        viteServer: this.viteServer ?? void 0
+      });
+      totalActions += result.actionCount;
     } catch (error) {
-      console.error("[Services] Failed to initialize:", error);
-      throw error;
+      console.error("[Actions] Failed to auto-discover project actions:", error);
+    }
+    try {
+      const pluginActions = await discoverAllPluginActions({
+        projectRoot: this.projectRoot,
+        registry: actionRegistry,
+        verbose: true,
+        viteServer: this.viteServer ?? void 0
+      });
+      totalActions += pluginActions.length;
+    } catch (error) {
+      console.error("[Actions] Failed to auto-discover plugin actions:", error);
+    }
+    if (totalActions > 0) {
+      console.log(`[Actions] Auto-registered ${totalActions} action(s) total`);
     }
   }
   /**
@@ -980,31 +1495,48 @@ class ServiceLifecycleManager {
    * Hot reload: shutdown, clear caches, re-import, and re-initialize
    */
   async reload() {
-    if (!this.initFilePath) {
-      console.log("[Services] No init file to reload");
-      return;
-    }
     console.log("[Services] Reloading services...");
     await this.shutdown();
     clearLifecycleCallbacks();
     clearServiceRegistry();
-    if (this.viteServer) {
-      const moduleNode = this.viteServer.moduleGraph.getModuleById(this.initFilePath);
+    clearClientInitData();
+    actionRegistry.clear();
+    if (this.projectInitFilePath && this.viteServer) {
+      const moduleNode = this.viteServer.moduleGraph.getModuleById(this.projectInitFilePath);
       if (moduleNode) {
         await this.viteServer.moduleGraph.invalidateModule(moduleNode);
       }
-    } else {
-      delete require.cache[require.resolve(this.initFilePath)];
+    } else if (this.projectInitFilePath) {
+      delete require.cache[require.resolve(this.projectInitFilePath)];
     }
     this.isInitialized = false;
     await this.initialize();
     console.log("[Services] Reload complete");
   }
   /**
-   * Returns the path to the init file if found
+   * Returns the path to the init file if found.
    */
   getInitFilePath() {
-    return this.initFilePath;
+    return this.projectInitFilePath;
+  }
+  /**
+   * Returns project init info for client-side embedding.
+   */
+  getProjectInit() {
+    if (!this.projectInitFilePath) {
+      return null;
+    }
+    return {
+      importPath: this.projectInitFilePath,
+      initExport: "init"
+    };
+  }
+  /**
+   * Returns the discovered plugins with init configurations.
+   * Sorted by dependencies (plugins with no deps first).
+   */
+  getPluginsWithInit() {
+    return this.pluginsWithInit;
   }
   /**
    * Checks if services are initialized
@@ -1013,6 +1545,212 @@ class ServiceLifecycleManager {
     return this.isInitialized;
   }
 }
+function deepMergeViewStates(base, overlay, trackByMap, path2 = "") {
+  if (!base && !overlay)
+    return {};
+  if (!base)
+    return overlay || {};
+  if (!overlay)
+    return base || {};
+  const result = {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(overlay)]);
+  for (const key of allKeys) {
+    const baseValue = base[key];
+    const overlayValue = overlay[key];
+    const currentPath = path2 ? `${path2}.${key}` : key;
+    if (overlayValue === void 0) {
+      result[key] = baseValue;
+    } else if (baseValue === void 0) {
+      result[key] = overlayValue;
+    } else if (Array.isArray(baseValue) && Array.isArray(overlayValue)) {
+      const trackByField = trackByMap[currentPath];
+      if (trackByField) {
+        result[key] = mergeArraysByTrackBy(
+          baseValue,
+          overlayValue,
+          trackByField,
+          trackByMap,
+          currentPath
+        );
+      } else {
+        result[key] = overlayValue;
+      }
+    } else if (typeof baseValue === "object" && baseValue !== null && typeof overlayValue === "object" && overlayValue !== null && !Array.isArray(baseValue) && !Array.isArray(overlayValue)) {
+      result[key] = deepMergeViewStates(baseValue, overlayValue, trackByMap, currentPath);
+    } else {
+      result[key] = overlayValue;
+    }
+  }
+  return result;
+}
+function mergeArraysByTrackBy(baseArray, overlayArray, trackByField, trackByMap, arrayPath) {
+  const baseByKey = /* @__PURE__ */ new Map();
+  for (const item of baseArray) {
+    const key = item[trackByField];
+    if (key !== void 0 && key !== null) {
+      if (baseByKey.has(key)) {
+        console.warn(
+          `Duplicate trackBy key [${key}] in base array at path [${arrayPath}]. This may cause incorrect merging.`
+        );
+      }
+      baseByKey.set(key, item);
+    }
+  }
+  const overlayByKey = /* @__PURE__ */ new Map();
+  for (const item of overlayArray) {
+    const key = item[trackByField];
+    if (key !== void 0 && key !== null) {
+      overlayByKey.set(key, item);
+    }
+  }
+  return baseArray.map((baseItem) => {
+    const key = baseItem[trackByField];
+    if (key === void 0 || key === null) {
+      return baseItem;
+    }
+    const overlayItem = overlayByKey.get(key);
+    if (overlayItem) {
+      return deepMergeViewStates(baseItem, overlayItem, trackByMap, arrayPath);
+    } else {
+      return baseItem;
+    }
+  });
+}
+const ACTION_ENDPOINT_BASE = "/_jay/actions";
+function createActionRouter(options) {
+  const registry = options?.registry ?? actionRegistry;
+  return async (req, res) => {
+    const actionName = req.path.slice(1);
+    if (!actionName) {
+      res.status(400).json({
+        success: false,
+        error: {
+          code: "MISSING_ACTION_NAME",
+          message: "Action name is required",
+          isActionError: false
+        }
+      });
+      return;
+    }
+    const action = registry.get(actionName);
+    if (!action) {
+      res.status(404).json({
+        success: false,
+        error: {
+          code: "ACTION_NOT_FOUND",
+          message: `Action '${actionName}' is not registered`,
+          isActionError: false
+        }
+      });
+      return;
+    }
+    const requestMethod = req.method.toUpperCase();
+    if (requestMethod !== action.method) {
+      res.status(405).json({
+        success: false,
+        error: {
+          code: "METHOD_NOT_ALLOWED",
+          message: `Action '${actionName}' expects ${action.method}, got ${requestMethod}`,
+          isActionError: false
+        }
+      });
+      return;
+    }
+    let input;
+    try {
+      if (requestMethod === "GET") {
+        if (req.query._input) {
+          input = JSON.parse(req.query._input);
+        } else {
+          input = { ...req.query };
+          delete input._input;
+        }
+      } else {
+        input = req.body;
+      }
+    } catch (parseError) {
+      res.status(400).json({
+        success: false,
+        error: {
+          code: "INVALID_INPUT",
+          message: "Failed to parse request input",
+          isActionError: false
+        }
+      });
+      return;
+    }
+    const result = await registry.execute(actionName, input);
+    if (requestMethod === "GET" && result.success) {
+      const cacheHeaders = registry.getCacheHeaders(actionName);
+      if (cacheHeaders) {
+        res.set("Cache-Control", cacheHeaders);
+      }
+    }
+    if (result.success) {
+      res.status(200).json({
+        success: true,
+        data: result.data
+      });
+    } else {
+      const statusCode = getStatusCodeForError(result.error.code, result.error.isActionError);
+      res.status(statusCode).json({
+        success: false,
+        error: result.error
+      });
+    }
+  };
+}
+function getStatusCodeForError(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;
+    case "INTERNAL_ERROR":
+    default:
+      return 500;
+  }
+}
+function actionBodyParser() {
+  return (req, res, next) => {
+    if (!req.path.startsWith(ACTION_ENDPOINT_BASE)) {
+      next();
+      return;
+    }
+    if (req.method === "GET") {
+      next();
+      return;
+    }
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      try {
+        req.body = body ? JSON.parse(body) : {};
+        next();
+      } catch (e2) {
+        res.status(400).json({
+          success: false,
+          error: {
+            code: "INVALID_JSON",
+            message: "Invalid JSON in request body",
+            isActionError: false
+          }
+        });
+      }
+    });
+  };
+}
 async function initRoutes(pagesBaseFolder) {
   return await scanRoutes(pagesBaseFolder, {
     jayHtmlFilename: "page.jay-html",
@@ -1026,11 +1764,13 @@ function defaults(options) {
     projectRootFolder,
     options.pagesRootFolder || "./src/pages"
   );
+  const buildFolder = options.buildFolder || path__default.resolve(projectRootFolder, "./build");
   const tsConfigFilePath = options.jayRollupConfig.tsConfigFilePath || path__default.resolve(projectRootFolder, "./tsconfig.json");
   return {
     publicBaseUrlPath,
     pagesRootFolder,
     projectRootFolder,
+    buildFolder,
     dontCacheSlowly: options.dontCacheSlowly,
     jayRollupConfig: {
       ...options.jayRollupConfig || {},
@@ -1046,59 +1786,96 @@ function handleOtherResponseCodes(res, renderedResult) {
   else
     res.status(renderedResult.status).end("redirect to " + renderedResult.location);
 }
-function mkRoute(route, vite, slowlyPhase, options) {
-  const path2 = routeToExpressRoute(route);
+function filterPluginsForPage(allPluginClientInits, allPluginsWithInit, usedPackages) {
+  const pluginsByPackage = /* @__PURE__ */ new Map();
+  for (const plugin of allPluginsWithInit) {
+    pluginsByPackage.set(plugin.packageName, plugin);
+  }
+  const expandedPackages = new Set(usedPackages);
+  const toProcess = [...usedPackages];
+  while (toProcess.length > 0) {
+    const packageName = toProcess.pop();
+    const plugin = pluginsByPackage.get(packageName);
+    if (!plugin)
+      continue;
+    for (const dep of plugin.dependencies) {
+      if (pluginsByPackage.has(dep) && !expandedPackages.has(dep)) {
+        expandedPackages.add(dep);
+        toProcess.push(dep);
+      }
+    }
+  }
+  return allPluginClientInits.filter((plugin) => {
+    const pluginInfo = allPluginsWithInit.find((p) => p.name === plugin.name);
+    return pluginInfo && expandedPackages.has(pluginInfo.packageName);
+  });
+}
+function mkRoute(route, vite, slowlyPhase, options, slowRenderCache, projectInit, allPluginsWithInit = [], allPluginClientInits = []) {
+  const routePath = routeToExpressRoute(route);
   const handler = async (req, res) => {
     try {
       const url = req.originalUrl.replace(options.publicBaseUrlPath, "");
-      const pageParams = req.params;
+      const pageParams = { ...route.inferredParams, ...req.params };
       const pageProps = {
         language: "en",
         url
       };
-      let viewState, carryForward;
-      const pageParts = await loadPageParts(
-        vite,
-        route,
-        options.pagesRootFolder,
-        options.jayRollupConfig
-      );
-      if (pageParts.val) {
-        const renderedSlowly = await slowlyPhase.runSlowlyForPage(
+      const useSlowRenderCache = !options.dontCacheSlowly;
+      let cachedEntry = useSlowRenderCache ? slowRenderCache.get(route.jayHtmlPath, pageParams) : void 0;
+      if (cachedEntry) {
+        try {
+          await fs$1.access(cachedEntry.preRenderedPath);
+        } catch {
+          console.log(
+            `[SlowRender] Cached file missing, rebuilding: ${cachedEntry.preRenderedPath}`
+          );
+          await slowRenderCache.invalidate(route.jayHtmlPath);
+          cachedEntry = void 0;
+        }
+      }
+      if (cachedEntry) {
+        await handleCachedRequest(
+          vite,
+          route,
+          options,
+          cachedEntry,
           pageParams,
           pageProps,
-          pageParts.val
+          allPluginClientInits,
+          allPluginsWithInit,
+          projectInit,
+          res,
+          url
+        );
+      } else if (useSlowRenderCache) {
+        await handlePreRenderRequest(
+          vite,
+          route,
+          options,
+          slowlyPhase,
+          slowRenderCache,
+          pageParams,
+          pageProps,
+          allPluginClientInits,
+          allPluginsWithInit,
+          projectInit,
+          res,
+          url
         );
-        if (renderedSlowly.kind === "PartialRender") {
-          const renderedFast = await renderFastChangingData(
-            pageParams,
-            pageProps,
-            renderedSlowly.carryForward,
-            pageParts.val
-          );
-          if (renderedFast.kind === "PartialRender") {
-            viewState = { ...renderedSlowly.rendered, ...renderedFast.rendered };
-            carryForward = renderedFast.carryForward;
-            const pageHtml = generateClientScript(
-              viewState,
-              carryForward,
-              pageParts.val,
-              route.jayHtmlPath
-            );
-            const compiledPageHtml = await vite.transformIndexHtml(
-              !!url ? url : "/",
-              pageHtml
-            );
-            res.status(200).set({ "Content-Type": "text/html" }).send(compiledPageHtml);
-          } else {
-            handleOtherResponseCodes(res, renderedFast);
-          }
-        } else if (renderedSlowly.kind === "ClientError") {
-          handleOtherResponseCodes(res, renderedSlowly);
-        }
       } else {
-        console.log(pageParts.validations.join("\n"));
-        res.status(500).end(pageParts.validations.join("\n"));
+        await handleDirectRequest(
+          vite,
+          route,
+          options,
+          slowlyPhase,
+          pageParams,
+          pageProps,
+          allPluginClientInits,
+          allPluginsWithInit,
+          projectInit,
+          res,
+          url
+        );
       }
     } catch (e2) {
       vite?.ssrFixStacktrace(e2);
@@ -1106,13 +1883,262 @@ function mkRoute(route, vite, slowlyPhase, options) {
       res.status(500).end(e2.stack);
     }
   };
-  return { path: path2, handler, fsRoute: route };
+  return { path: routePath, handler, fsRoute: route };
+}
+async function handleCachedRequest(vite, route, options, cachedEntry, pageParams, pageProps, allPluginClientInits, allPluginsWithInit, projectInit, res, url) {
+  const pagePartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig,
+    { preRenderedPath: cachedEntry.preRenderedPath }
+  );
+  if (!pagePartsResult.val) {
+    console.log(pagePartsResult.validations.join("\n"));
+    res.status(500).end(pagePartsResult.validations.join("\n"));
+    return;
+  }
+  const { parts: pageParts, clientTrackByMap, usedPackages } = pagePartsResult.val;
+  const pluginsForPage = filterPluginsForPage(
+    allPluginClientInits,
+    allPluginsWithInit,
+    usedPackages
+  );
+  const renderedFast = await renderFastChangingData(
+    pageParams,
+    pageProps,
+    cachedEntry.carryForward,
+    pageParts
+  );
+  if (renderedFast.kind !== "PhaseOutput") {
+    handleOtherResponseCodes(res, renderedFast);
+    return;
+  }
+  await sendResponse(
+    vite,
+    res,
+    url,
+    cachedEntry.preRenderedPath,
+    pageParts,
+    renderedFast.rendered,
+    renderedFast.carryForward,
+    clientTrackByMap,
+    projectInit,
+    pluginsForPage,
+    options,
+    cachedEntry.slowViewState
+  );
+}
+async function handlePreRenderRequest(vite, route, options, slowlyPhase, slowRenderCache, pageParams, pageProps, allPluginClientInits, allPluginsWithInit, projectInit, res, url) {
+  const initialPartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig
+  );
+  if (!initialPartsResult.val) {
+    console.log(initialPartsResult.validations.join("\n"));
+    res.status(500).end(initialPartsResult.validations.join("\n"));
+    return;
+  }
+  const renderedSlowly = await slowlyPhase.runSlowlyForPage(
+    pageParams,
+    pageProps,
+    initialPartsResult.val.parts
+  );
+  if (renderedSlowly.kind !== "PhaseOutput") {
+    if (renderedSlowly.kind === "ClientError") {
+      handleOtherResponseCodes(res, renderedSlowly);
+    }
+    return;
+  }
+  const preRenderedContent = await preRenderJayHtml(route, renderedSlowly.rendered);
+  if (!preRenderedContent) {
+    res.status(500).end("Failed to pre-render jay-html");
+    return;
+  }
+  const preRenderedPath = await slowRenderCache.set(
+    route.jayHtmlPath,
+    pageParams,
+    preRenderedContent,
+    renderedSlowly.rendered,
+    renderedSlowly.carryForward
+  );
+  console.log(`[SlowRender] Cached pre-rendered jay-html at ${preRenderedPath}`);
+  const pagePartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig,
+    { preRenderedPath }
+  );
+  if (!pagePartsResult.val) {
+    console.log(pagePartsResult.validations.join("\n"));
+    res.status(500).end(pagePartsResult.validations.join("\n"));
+    return;
+  }
+  const { parts: pageParts, clientTrackByMap, usedPackages } = pagePartsResult.val;
+  const pluginsForPage = filterPluginsForPage(
+    allPluginClientInits,
+    allPluginsWithInit,
+    usedPackages
+  );
+  const renderedFast = await renderFastChangingData(
+    pageParams,
+    pageProps,
+    renderedSlowly.carryForward,
+    pageParts
+  );
+  if (renderedFast.kind !== "PhaseOutput") {
+    handleOtherResponseCodes(res, renderedFast);
+    return;
+  }
+  await sendResponse(
+    vite,
+    res,
+    url,
+    preRenderedPath,
+    pageParts,
+    renderedFast.rendered,
+    renderedFast.carryForward,
+    clientTrackByMap,
+    projectInit,
+    pluginsForPage,
+    options,
+    renderedSlowly.rendered
+  );
+}
+async function handleDirectRequest(vite, route, options, slowlyPhase, pageParams, pageProps, allPluginClientInits, allPluginsWithInit, projectInit, res, url) {
+  const pagePartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig
+  );
+  if (!pagePartsResult.val) {
+    console.log(pagePartsResult.validations.join("\n"));
+    res.status(500).end(pagePartsResult.validations.join("\n"));
+    return;
+  }
+  const {
+    parts: pageParts,
+    serverTrackByMap,
+    clientTrackByMap,
+    usedPackages
+  } = pagePartsResult.val;
+  const pluginsForPage = filterPluginsForPage(
+    allPluginClientInits,
+    allPluginsWithInit,
+    usedPackages
+  );
+  const renderedSlowly = await slowlyPhase.runSlowlyForPage(pageParams, pageProps, pageParts);
+  if (renderedSlowly.kind !== "PhaseOutput") {
+    if (renderedSlowly.kind === "ClientError") {
+      handleOtherResponseCodes(res, renderedSlowly);
+    }
+    return;
+  }
+  const renderedFast = await renderFastChangingData(
+    pageParams,
+    pageProps,
+    renderedSlowly.carryForward,
+    pageParts
+  );
+  if (renderedFast.kind !== "PhaseOutput") {
+    handleOtherResponseCodes(res, renderedFast);
+    return;
+  }
+  let viewState;
+  if (serverTrackByMap && Object.keys(serverTrackByMap).length > 0) {
+    viewState = deepMergeViewStates(
+      renderedSlowly.rendered,
+      renderedFast.rendered,
+      serverTrackByMap
+    );
+  } else {
+    viewState = { ...renderedSlowly.rendered, ...renderedFast.rendered };
+  }
+  await sendResponse(
+    vite,
+    res,
+    url,
+    route.jayHtmlPath,
+    pageParts,
+    viewState,
+    renderedFast.carryForward,
+    clientTrackByMap,
+    projectInit,
+    pluginsForPage,
+    options
+  );
+}
+async function sendResponse(vite, res, url, jayHtmlPath, pageParts, viewState, carryForward, clientTrackByMap, projectInit, pluginsForPage, options, slowViewState) {
+  const pageHtml = generateClientScript(
+    viewState,
+    carryForward,
+    pageParts,
+    jayHtmlPath,
+    clientTrackByMap,
+    getClientInitData(),
+    projectInit,
+    pluginsForPage,
+    {
+      enableAutomation: !options.disableAutomation,
+      slowViewState
+    }
+  );
+  const compiledPageHtml = await vite.transformIndexHtml(!!url ? url : "/", pageHtml);
+  res.status(200).set({ "Content-Type": "text/html" }).send(compiledPageHtml);
+}
+async function preRenderJayHtml(route, slowViewState) {
+  const jayHtmlContent = await fs$1.readFile(route.jayHtmlPath, "utf-8");
+  const contractPath = route.jayHtmlPath.replace(".jay-html", ".jay-contract");
+  let contract;
+  try {
+    const contractContent = await fs$1.readFile(contractPath, "utf-8");
+    const parseResult = parseContract(contractContent, path__default.basename(contractPath));
+    if (parseResult.val) {
+      contract = parseResult.val;
+    } else if (parseResult.validations.length > 0) {
+      console.error(
+        `[SlowRender] Contract parse error for ${contractPath}:`,
+        parseResult.validations
+      );
+      return void 0;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error(`[SlowRender] Error reading contract ${contractPath}:`, error);
+      return void 0;
+    }
+  }
+  const result = slowRenderTransform({
+    jayHtmlContent,
+    slowViewState,
+    contract,
+    sourceDir: path__default.dirname(route.jayHtmlPath)
+  });
+  if (result.val) {
+    return result.val.preRenderedJayHtml;
+  }
+  if (result.validations.length > 0) {
+    console.error(
+      `[SlowRender] Transform failed for ${route.jayHtmlPath}:`,
+      result.validations
+    );
+  }
+  return void 0;
 }
 async function mkDevServer(options) {
   const {
     publicBaseUrlPath,
     pagesRootFolder,
     projectRootFolder,
+    buildFolder,
     jayRollupConfig,
     dontCacheSlowly
   } = defaults(options);
@@ -1126,17 +2152,33 @@ async function mkDevServer(options) {
     root: pagesRootFolder,
     ssr: {
       // Mark stack-server-runtime as external so Vite uses Node's require
-      // This ensures jay.init.ts and dev-server share the same module instance
+      // This ensures lib/init.ts and dev-server share the same module instance
       external: ["@jay-framework/stack-server-runtime"]
     }
   });
   lifecycleManager.setViteServer(vite);
   await lifecycleManager.initialize();
   setupServiceHotReload(vite, lifecycleManager);
+  setupActionRouter(vite);
   const routes = await initRoutes(pagesRootFolder);
   const slowlyPhase = new DevSlowlyChangingPhase(dontCacheSlowly);
+  const slowRenderCacheDir = path__default.join(buildFolder, "slow-render-cache");
+  const slowRenderCache = new SlowRenderCache(slowRenderCacheDir, pagesRootFolder);
+  setupSlowRenderCacheInvalidation(vite, slowRenderCache, pagesRootFolder);
+  const projectInit = lifecycleManager.getProjectInit() ?? void 0;
+  const pluginsWithInit = lifecycleManager.getPluginsWithInit();
+  const pluginClientInits = preparePluginClientInits(pluginsWithInit);
   const devServerRoutes = routes.map(
-    (route) => mkRoute(route, vite, slowlyPhase, options)
+    (route) => mkRoute(
+      route,
+      vite,
+      slowlyPhase,
+      options,
+      slowRenderCache,
+      projectInit,
+      pluginsWithInit,
+      pluginClientInits
+    )
   );
   return {
     server: vite.middlewares,
@@ -1163,7 +2205,7 @@ function setupServiceHotReload(vite, lifecycleManager) {
   vite.watcher.add(initFilePath);
   vite.watcher.on("change", async (changedPath) => {
     if (changedPath === initFilePath) {
-      console.log("[Services] jay.init.ts changed, reloading services...");
+      console.log("[Services] lib/init.ts changed, reloading services...");
       try {
         await lifecycleManager.reload();
         vite.ws.send({
@@ -1176,6 +2218,42 @@ function setupServiceHotReload(vite, lifecycleManager) {
     }
   });
 }
+function setupActionRouter(vite) {
+  vite.middlewares.use(actionBodyParser());
+  vite.middlewares.use(ACTION_ENDPOINT_BASE, createActionRouter());
+  console.log(`[Actions] Action router mounted at ${ACTION_ENDPOINT_BASE}`);
+}
+function setupSlowRenderCacheInvalidation(vite, cache, pagesRootFolder) {
+  vite.watcher.on("change", (changedPath) => {
+    if (!changedPath.startsWith(pagesRootFolder)) {
+      return;
+    }
+    if (changedPath.endsWith(".jay-html")) {
+      cache.invalidate(changedPath).then(() => {
+        console.log(`[SlowRender] Cache invalidated for ${changedPath}`);
+      });
+      return;
+    }
+    if (changedPath.endsWith("page.ts")) {
+      const dir = path__default.dirname(changedPath);
+      const jayHtmlPath = path__default.join(dir, "page.jay-html");
+      cache.invalidate(jayHtmlPath).then(() => {
+        console.log(`[SlowRender] Cache invalidated for ${jayHtmlPath} (page.ts changed)`);
+      });
+      return;
+    }
+    if (changedPath.endsWith(".jay-contract")) {
+      const jayHtmlPath = changedPath.replace(".jay-contract", ".jay-html");
+      cache.invalidate(jayHtmlPath).then(() => {
+        console.log(`[SlowRender] Cache invalidated for ${jayHtmlPath} (contract changed)`);
+      });
+      return;
+    }
+  });
+}
 export {
+  ACTION_ENDPOINT_BASE,
+  actionBodyParser,
+  createActionRouter,
   mkDevServer
 };