@jay-framework/dev-server 0.10.0 → 0.12.0

package/dist/index.d.ts

@@ -2,15 +2,34 @@ import { ViteDevServer, Connect } from 'vite';
 import { JayRoute } from '@jay-framework/stack-route-scanner';
 import { RequestHandler } from 'express-serve-static-core';
 import { JayRollupConfig } from '@jay-framework/rollup-plugin';
+import { LogLevel } from '@jay-framework/logger';
 import { ProjectClientInitInfo, PluginWithInit, ActionRegistry } from '@jay-framework/stack-server-runtime';
 import { RequestHandler as RequestHandler$1 } from 'express';
+import { JayRollupConfig as JayRollupConfig$1 } from '@jay-framework/compiler-jay-stack';
 
 interface DevServerOptions {
     publicBaseUrlPath?: string;
     projectRootFolder?: string;
     pagesRootFolder?: string;
+    /**
+     * Folder where build artifacts are stored.
+     * Pre-rendered jay-html files are written to `<buildFolder>/slow-render-cache/`.
+     * Defaults to `<projectRootFolder>/build`.
+     */
+    buildFolder?: string;
     jayRollupConfig: JayRollupConfig;
     dontCacheSlowly: boolean;
+    /**
+     * Disable automation integration.
+     * When false (default), pages are wrapped with automation API for dev tooling.
+     * The automation API is available at `window.__jay.automation` and via `AUTOMATION_CONTEXT`.
+     */
+    disableAutomation?: boolean;
+    /**
+     * Log level for dev server output.
+     * Controls both Jay logging and Vite logging.
+     */
+    logLevel?: LogLevel;
 }
 
 /**
@@ -88,7 +107,7 @@ interface DevServer {
     routes: DevServerRoute[];
     lifecycleManager: ServiceLifecycleManager;
 }
-declare function mkDevServer(options: DevServerOptions): Promise<DevServer>;
+declare function mkDevServer(rawOptions: DevServerOptions): Promise<DevServer>;
 
 /**
  * Action Router for Jay Stack dev server.
@@ -139,4 +158,44 @@ declare function createActionRouter(options?: ActionRouterOptions): RequestHandl
  */
 declare function actionBodyParser(): RequestHandler$1;
 
-export { ACTION_ENDPOINT_BASE, type ActionRouterOptions, type DevServer, type DevServerOptions, type DevServerRoute, actionBodyParser, createActionRouter, mkDevServer };
+/**
+ * Vite Factory
+ *
+ * Single source of truth for creating Vite servers.
+ * Used by both the dev-server and CLI commands.
+ */
+
+interface CreateViteServerOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Root directory for pages (defaults to projectRoot) */
+    pagesRoot?: string;
+    /** Base URL path for public assets */
+    base?: string;
+    /** Jay Stack compiler config (optional, will use defaults if not provided) */
+    jayRollupConfig?: JayRollupConfig$1;
+    /** Log level (defaults to 'info' for dev-server, 'warn' for CLI) */
+    logLevel?: 'info' | 'warn' | 'error' | 'silent';
+    /** Whether to clear screen on rebuild */
+    clearScreen?: boolean;
+}
+/**
+ * Creates a Vite server configured for Jay Stack.
+ *
+ * This is the single source of truth for Vite configuration.
+ * Both dev-server and CLI use this function.
+ */
+declare function createViteServer(options: CreateViteServerOptions): Promise<ViteDevServer>;
+/**
+ * Creates a minimal Vite server for CLI usage.
+ *
+ * This is a convenience wrapper around createViteServer with CLI-appropriate defaults.
+ * Disables dependency optimization and ignores the build/ folder to avoid errors
+ * from stale build artifacts (e.g., build/client-scripts/ referencing build/slow-render-cache/).
+ */
+declare function createViteForCli(options: {
+    projectRoot: string;
+    tsConfigFilePath?: string;
+}): Promise<ViteDevServer>;
+
+export { ACTION_ENDPOINT_BASE, type ActionRouterOptions, type CreateViteServerOptions, type DevServer, type DevServerOptions, type DevServerRoute, actionBodyParser, createActionRouter, createViteForCli, createViteServer, mkDevServer };

package/dist/index.js

@@ -5,15 +5,18 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import { createServer } from "vite";
-import { scanRoutes, routeToExpressRoute } from "@jay-framework/stack-route-scanner";
-import { discoverPluginsWithInit, sortPluginsByDependencies, executePluginServerInits, runInitCallbacks, actionRegistry, discoverAndRegisterActions, discoverAllPluginActions, runShutdownCallbacks, clearLifecycleCallbacks, clearServiceRegistry, clearClientInitData, DevSlowlyChangingPhase, preparePluginClientInits, loadPageParts, renderFastChangingData, getClientInitData, generateClientScript } 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 { discoverHeadlessInstances, parseContract, slowRenderTransform, JAY_IMPORT_RESOLVER, resolveHeadlessInstances } from "@jay-framework/compiler-jay-html";
+import { getLogger, getDevLogger } from "@jay-framework/logger";
+import { createRequire as createRequire$1 } from "node:module";
 import * as fs from "node:fs";
+import { scanRoutes, routeToExpressRoute } from "@jay-framework/stack-route-scanner";
+import { discoverPluginsWithInit, sortPluginsByDependencies, executePluginServerInits, runInitCallbacks, actionRegistry, discoverAndRegisterActions, discoverAllPluginActions, runShutdownCallbacks, clearLifecycleCallbacks, clearServiceRegistry, clearClientInitData, DevSlowlyChangingPhase, SlowRenderCache, preparePluginClientInits, getServiceRegistry, materializeContracts, loadPageParts, renderFastChangingData, slowRenderInstances, generateClientScript, getClientInitData, resolveServices } from "@jay-framework/stack-server-runtime";
+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) {
@@ -1019,7 +1022,7 @@ function createImportChainTracker(options = {}) {
       importChain.clear();
       detectedServerModules.clear();
       if (verbose) {
-        console.log("[import-chain-tracker] Build started, tracking imports...");
+        getLogger().info("[import-chain-tracker] Build started, tracking imports...");
       }
     },
     resolveId(source, importer, options2) {
@@ -1031,7 +1034,7 @@ function createImportChainTracker(options = {}) {
       }
       if (importer) {
         if (verbose) {
-          console.log(
+          getLogger().info(
             `[import-chain-tracker] ${shortenPath(importer)} imports ${source}`
           );
         }
@@ -1048,14 +1051,14 @@ function createImportChainTracker(options = {}) {
       if (isServerOnlyModule(id)) {
         detectedServerModules.add(id);
         const chain = buildImportChain(id);
-        console.error(
+        getLogger().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("");
+        getLogger().error(`Module: ${shortenPath(id)}`);
+        getLogger().error(`Import chain:`);
+        getLogger().error(formatChain(chain));
+        getLogger().error("");
       }
       const importRegex = /import\s+(?:(?:\{[^}]*\}|[^{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g;
       let match;
@@ -1065,16 +1068,18 @@ function createImportChainTracker(options = {}) {
         if (isServerOnlyModule(importedModule)) {
           if (!detectedServerModules.has(importedModule)) {
             detectedServerModules.add(importedModule);
-            console.error(
+            getLogger().error(
               `
 [import-chain-tracker] ⚠️  Server-only import detected in client build!`
             );
-            console.error(`Module "${importedModule}" imported by: ${shortenPath(id)}`);
+            getLogger().error(
+              `Module "${importedModule}" imported by: ${shortenPath(id)}`
+            );
             const chain = buildImportChain(id);
             chain.push(importedModule);
-            console.error(`Import chain:`);
-            console.error(formatChain(chain));
-            console.error("");
+            getLogger().error(`Import chain:`);
+            getLogger().error(formatChain(chain));
+            getLogger().error("");
           }
         }
       }
@@ -1082,27 +1087,151 @@ function createImportChainTracker(options = {}) {
     },
     buildEnd() {
       if (detectedServerModules.size > 0) {
-        console.warn(
+        getLogger().warn(
           `
 [import-chain-tracker] ⚠️  ${detectedServerModules.size} server-only module(s) detected during transform:`
         );
         for (const mod of detectedServerModules) {
-          console.warn(`  - ${mod}`);
+          getLogger().warn(`  - ${mod}`);
         }
-        console.warn(
+        getLogger().warn(
           "\nNote: These may be stripped by the code-split transform if only used in .withServer()."
         );
-        console.warn(
+        getLogger().warn(
           'If build fails with "not exported" errors, check the import chains above.\n'
         );
       } else if (verbose) {
-        console.log(
+        getLogger().info(
           "[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) {
+      getLogger().info(
+        `[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) {
+      getLogger().info(
+        `[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();
@@ -1112,6 +1241,7 @@ function jayStackCompiler(options = {}) {
   if (shouldTrackImports) {
     plugins.push(createImportChainTracker(trackerOptions));
   }
+  plugins.push(createPluginClientImportResolver({ verbose: !!shouldTrackImports }));
   plugins.push(
     // First: Jay Stack code splitting transformation
     {
@@ -1131,7 +1261,7 @@ function jayStackCompiler(options = {}) {
         try {
           return transformJayStackBuilder(code, id, environment);
         } catch (error) {
-          console.error(`[jay-stack:code-split] Error transforming ${id}:`, error);
+          getLogger().error(`[jay-stack:code-split] Error transforming ${id}: ${error}`);
           return null;
         }
       }
@@ -1172,6 +1302,13 @@ function jayStackCompiler(options = {}) {
             } 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}`;
         },
@@ -1184,12 +1321,14 @@ function jayStackCompiler(options = {}) {
           try {
             code = await fs.promises.readFile(actualPath, "utf-8");
           } catch (err) {
-            console.error(`[action-transform] Could not read ${actualPath}:`, err);
+            getLogger().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}`);
+            getLogger().warn(`[action-transform] No actions found in ${actualPath}`);
             return null;
           }
           const lines = [
@@ -1216,6 +1355,69 @@ function jayStackCompiler(options = {}) {
   );
   return plugins;
 }
+async function createViteServer(options) {
+  const {
+    projectRoot,
+    pagesRoot = projectRoot,
+    base,
+    jayRollupConfig = { tsConfigFilePath: path__default.join(projectRoot, "tsconfig.json") },
+    logLevel = "info",
+    clearScreen = true
+  } = options;
+  const vite = await createServer({
+    // Don't start HTTP server - we use middleware mode
+    server: { middlewareMode: true },
+    // Use Jay Stack compiler for .jay-html and other custom transforms
+    plugins: [...jayStackCompiler(jayRollupConfig)],
+    // Custom app type (no default middleware)
+    appType: "custom",
+    // Base URL path
+    base,
+    // Root directory for module resolution
+    root: pagesRoot,
+    // SSR configuration
+    ssr: {
+      // Mark jay-framework packages as external so Vite uses Node's require
+      // This ensures all packages share the same module instances (Symbol identity)
+      external: ["@jay-framework/stack-server-runtime", "@jay-framework/fullstack-component"]
+    },
+    // Disable automatic entry point discovery for pre-bundling —
+    // we run in middleware mode with no HTML files, so Vite can't auto-detect entries
+    optimizeDeps: {
+      entries: []
+    },
+    // Logging
+    logLevel,
+    clearScreen
+  });
+  return vite;
+}
+async function createViteForCli(options) {
+  const { projectRoot, tsConfigFilePath = path__default.join(projectRoot, "tsconfig.json") } = options;
+  const vite = await createServer({
+    server: {
+      middlewareMode: true,
+      watch: {
+        ignored: ["**/build/**"]
+      }
+    },
+    plugins: [
+      ...jayStackCompiler({ tsConfigFilePath })
+    ],
+    appType: "custom",
+    root: projectRoot,
+    ssr: {
+      external: ["@jay-framework/stack-server-runtime", "@jay-framework/fullstack-component"]
+    },
+    // Disable dependency optimization — CLI only uses SSR, no browser bundles
+    optimizeDeps: {
+      entries: []
+    },
+    logLevel: "warn",
+    clearScreen: false
+  });
+  return vite;
+}
 class ServiceLifecycleManager {
   constructor(projectRoot, sourceBase = "src") {
     /** Path to project's lib/init.ts (makeJayInit pattern) */
@@ -1254,8 +1456,9 @@ class ServiceLifecycleManager {
    * 4. Auto-discovering and registering actions
    */
   async initialize() {
+    const log = getLogger();
     if (this.isInitialized) {
-      console.warn("[Services] Already initialized, skipping...");
+      log.warn("[Services] Already initialized, skipping...");
       return;
     }
     this.projectInitFilePath = this.findProjectInitFile();
@@ -1265,18 +1468,18 @@ class ServiceLifecycleManager {
     });
     this.pluginsWithInit = sortPluginsByDependencies(discoveredPlugins);
     if (this.pluginsWithInit.length > 0) {
-      console.log(
+      log.info(
         `[Services] Found ${this.pluginsWithInit.length} plugin(s) with init: ${this.pluginsWithInit.map((p) => p.name).join(", ")}`
       );
     }
     await executePluginServerInits(this.pluginsWithInit, this.viteServer ?? void 0, true);
     if (this.projectInitFilePath) {
-      console.log("[DevServer] Loading project init: src/init.ts");
+      log.info("[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");
+            log.info("[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) {
@@ -1288,14 +1491,14 @@ class ServiceLifecycleManager {
           await import(fileUrl);
         }
       } catch (error) {
-        console.error("[Services] Failed to load project init:", error);
+        log.error(`[Services] Failed to load project init: ${error}`);
         throw error;
       }
     } else {
-      console.log("[Services] No init.ts found, skipping project initialization");
+      log.info("[Services] No init.ts found, skipping project initialization");
     }
     await runInitCallbacks();
-    console.log("[Services] Initialization complete");
+    log.info("[Services] Initialization complete");
     await this.discoverActions();
     this.isInitialized = true;
   }
@@ -1303,6 +1506,7 @@ class ServiceLifecycleManager {
    * Auto-discovers and registers actions from project and plugins.
    */
   async discoverActions() {
+    const log = getLogger();
     let totalActions = 0;
     try {
       const result = await discoverAndRegisterActions({
@@ -1314,7 +1518,7 @@ class ServiceLifecycleManager {
       });
       totalActions += result.actionCount;
     } catch (error) {
-      console.error("[Actions] Failed to auto-discover project actions:", error);
+      log.error(`[Actions] Failed to auto-discover project actions: ${error}`);
     }
     try {
       const pluginActions = await discoverAllPluginActions({
@@ -1325,20 +1529,21 @@ class ServiceLifecycleManager {
       });
       totalActions += pluginActions.length;
     } catch (error) {
-      console.error("[Actions] Failed to auto-discover plugin actions:", error);
+      log.error(`[Actions] Failed to auto-discover plugin actions: ${error}`);
     }
     if (totalActions > 0) {
-      console.log(`[Actions] Auto-registered ${totalActions} action(s) total`);
+      log.info(`[Actions] Auto-registered ${totalActions} action(s) total`);
     }
   }
   /**
    * Shuts down services gracefully with timeout
    */
   async shutdown(timeoutMs = 5e3) {
+    const log = getLogger();
     if (!this.isInitialized) {
       return;
     }
-    console.log("[Services] Shutting down...");
+    log.info("[Services] Shutting down...");
     try {
       await Promise.race([
         runShutdownCallbacks(),
@@ -1346,12 +1551,12 @@ class ServiceLifecycleManager {
           (_, reject) => setTimeout(() => reject(new Error("Shutdown timeout")), timeoutMs)
         )
       ]);
-      console.log("[Services] Shutdown complete");
+      log.info("[Services] Shutdown complete");
     } catch (error) {
       if (error.message === "Shutdown timeout") {
-        console.warn("[Services] Shutdown timed out after", timeoutMs, "ms");
+        log.warn(`[Services] Shutdown timed out after ${timeoutMs}ms`);
       } else {
-        console.error("[Services] Shutdown error:", error);
+        log.error(`[Services] Shutdown error: ${error}`);
       }
     } finally {
       this.isInitialized = false;
@@ -1361,7 +1566,8 @@ class ServiceLifecycleManager {
    * Hot reload: shutdown, clear caches, re-import, and re-initialize
    */
   async reload() {
-    console.log("[Services] Reloading services...");
+    const log = getLogger();
+    log.info("[Services] Reloading services...");
     await this.shutdown();
     clearLifecycleCallbacks();
     clearServiceRegistry();
@@ -1377,7 +1583,7 @@ class ServiceLifecycleManager {
     }
     this.isInitialized = false;
     await this.initialize();
-    console.log("[Services] Reload complete");
+    log.info("[Services] Reload complete");
   }
   /**
    * Returns the path to the init file if found.
@@ -1630,11 +1836,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 || {},
@@ -1650,124 +1858,601 @@ function handleOtherResponseCodes(res, renderedResult) {
   else
     res.status(renderedResult.status).end("redirect to " + renderedResult.location);
 }
-function mkRoute(route, vite, slowlyPhase, options, projectInit, allPluginsWithInit = [], allPluginClientInits = []) {
-  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) => {
+    const timing = getDevLogger()?.startRequest(req.method, req.path);
     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 pagePartsResult = await loadPageParts(
-        vite,
-        route,
-        options.pagesRootFolder,
-        options.projectRootFolder,
-        options.jayRollupConfig
-      );
-      if (pagePartsResult.val) {
-        const {
-          parts: pageParts,
-          serverTrackByMap,
-          clientTrackByMap,
-          usedPackages
-        } = pagePartsResult.val;
-        const pluginsForPage = allPluginClientInits.filter((plugin) => {
-          const pluginInfo = allPluginsWithInit.find((p) => p.name === plugin.name);
-          return pluginInfo && usedPackages.has(pluginInfo.packageName);
-        });
-        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 {
+          getLogger().info(
+            `[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
+          allPluginClientInits,
+          allPluginsWithInit,
+          projectInit,
+          res,
+          url,
+          timing
+        );
+      } else if (useSlowRenderCache) {
+        await handlePreRenderRequest(
+          vite,
+          route,
+          options,
+          slowlyPhase,
+          slowRenderCache,
+          pageParams,
+          pageProps,
+          allPluginClientInits,
+          allPluginsWithInit,
+          projectInit,
+          res,
+          url,
+          timing
         );
-        if (renderedSlowly.kind === "PhaseOutput") {
-          const renderedFast = await renderFastChangingData(
-            pageParams,
-            pageProps,
-            renderedSlowly.carryForward,
-            pageParts
-          );
-          if (renderedFast.kind === "PhaseOutput") {
-            if (serverTrackByMap && Object.keys(serverTrackByMap).length > 0) {
-              viewState = deepMergeViewStates(
-                renderedSlowly.rendered,
-                renderedFast.rendered,
-                serverTrackByMap
-              );
-            } else {
-              viewState = { ...renderedSlowly.rendered, ...renderedFast.rendered };
-            }
-            carryForward = renderedFast.carryForward;
-            const pageHtml = generateClientScript(
-              viewState,
-              carryForward,
-              pageParts,
-              route.jayHtmlPath,
-              clientTrackByMap,
-              getClientInitData(),
-              projectInit,
-              pluginsForPage
-            );
-            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(pagePartsResult.validations.join("\n"));
-        res.status(500).end(pagePartsResult.validations.join("\n"));
+        await handleDirectRequest(
+          vite,
+          route,
+          options,
+          slowlyPhase,
+          pageParams,
+          pageProps,
+          allPluginClientInits,
+          allPluginsWithInit,
+          projectInit,
+          res,
+          url,
+          timing
+        );
       }
     } catch (e2) {
       vite?.ssrFixStacktrace(e2);
-      console.log(e2.stack);
+      getLogger().error(e2.stack);
       res.status(500).end(e2.stack);
+      timing?.end();
     }
   };
-  return { path: path2, handler, fsRoute: route };
+  return { path: routePath, handler, fsRoute: route };
 }
-async function mkDevServer(options) {
+async function handleCachedRequest(vite, route, options, cachedEntry, pageParams, pageProps, allPluginClientInits, allPluginsWithInit, projectInit, res, url, timing) {
+  const loadStart = Date.now();
+  const pagePartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig,
+    { preRenderedPath: cachedEntry.preRenderedPath }
+  );
+  timing?.recordViteSsr(Date.now() - loadStart);
+  if (!pagePartsResult.val) {
+    getLogger().info(pagePartsResult.validations.join("\n"));
+    res.status(500).end(pagePartsResult.validations.join("\n"));
+    timing?.end();
+    return;
+  }
+  const { parts: pageParts, clientTrackByMap, usedPackages } = pagePartsResult.val;
+  const pluginsForPage = filterPluginsForPage(
+    allPluginClientInits,
+    allPluginsWithInit,
+    usedPackages
+  );
+  const fastStart = Date.now();
+  const renderedFast = await renderFastChangingData(
+    pageParams,
+    pageProps,
+    cachedEntry.carryForward,
+    pageParts
+  );
+  timing?.recordFastRender(Date.now() - fastStart);
+  if (renderedFast.kind !== "PhaseOutput") {
+    handleOtherResponseCodes(res, renderedFast);
+    timing?.end();
+    return;
+  }
+  let fastViewState = renderedFast.rendered;
+  let fastCarryForward = renderedFast.carryForward;
+  const instancePhaseData = cachedEntry.carryForward?.__instances;
+  if (instancePhaseData && pagePartsResult.val.headlessInstanceComponents.length > 0) {
+    const instanceFastResult = await renderFastChangingDataForInstances(
+      instancePhaseData,
+      pagePartsResult.val.headlessInstanceComponents
+    );
+    if (instanceFastResult) {
+      fastViewState = {
+        ...fastViewState,
+        __headlessInstances: instanceFastResult.viewStates
+      };
+      fastCarryForward = {
+        ...fastCarryForward,
+        __headlessInstances: instanceFastResult.carryForwards
+      };
+    }
+  }
+  await sendResponse(
+    vite,
+    res,
+    url,
+    cachedEntry.preRenderedPath,
+    pageParts,
+    fastViewState,
+    fastCarryForward,
+    clientTrackByMap,
+    projectInit,
+    pluginsForPage,
+    options,
+    cachedEntry.slowViewState,
+    timing
+  );
+}
+async function handlePreRenderRequest(vite, route, options, slowlyPhase, slowRenderCache, pageParams, pageProps, allPluginClientInits, allPluginsWithInit, projectInit, res, url, timing) {
+  const loadStart = Date.now();
+  const initialPartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig
+  );
+  timing?.recordViteSsr(Date.now() - loadStart);
+  if (!initialPartsResult.val) {
+    getLogger().info(initialPartsResult.validations.join("\n"));
+    res.status(500).end(initialPartsResult.validations.join("\n"));
+    timing?.end();
+    return;
+  }
+  const slowStart = Date.now();
+  const renderedSlowly = await slowlyPhase.runSlowlyForPage(
+    pageParams,
+    pageProps,
+    initialPartsResult.val.parts
+  );
+  if (renderedSlowly.kind !== "PhaseOutput") {
+    timing?.recordSlowRender(Date.now() - slowStart);
+    if (renderedSlowly.kind === "ClientError") {
+      handleOtherResponseCodes(res, renderedSlowly);
+    }
+    timing?.end();
+    return;
+  }
+  const preRenderResult = await preRenderJayHtml(
+    route,
+    renderedSlowly.rendered,
+    initialPartsResult.val.headlessContracts,
+    initialPartsResult.val.headlessInstanceComponents
+  );
+  timing?.recordSlowRender(Date.now() - slowStart);
+  if (!preRenderResult) {
+    res.status(500).end("Failed to pre-render jay-html");
+    timing?.end();
+    return;
+  }
+  const carryForward = preRenderResult.instancePhaseData ? { ...renderedSlowly.carryForward, __instances: preRenderResult.instancePhaseData } : renderedSlowly.carryForward;
+  const preRenderedPath = await slowRenderCache.set(
+    route.jayHtmlPath,
+    pageParams,
+    preRenderResult.preRenderedJayHtml,
+    renderedSlowly.rendered,
+    carryForward
+  );
+  getLogger().info(`[SlowRender] Cached pre-rendered jay-html at ${preRenderedPath}`);
+  const pagePartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig,
+    { preRenderedPath }
+  );
+  if (!pagePartsResult.val) {
+    getLogger().info(pagePartsResult.validations.join("\n"));
+    res.status(500).end(pagePartsResult.validations.join("\n"));
+    timing?.end();
+    return;
+  }
+  const { parts: pageParts, clientTrackByMap, usedPackages } = pagePartsResult.val;
+  const pluginsForPage = filterPluginsForPage(
+    allPluginClientInits,
+    allPluginsWithInit,
+    usedPackages
+  );
+  const fastStart = Date.now();
+  const renderedFast = await renderFastChangingData(
+    pageParams,
+    pageProps,
+    carryForward,
+    pageParts
+  );
+  timing?.recordFastRender(Date.now() - fastStart);
+  if (renderedFast.kind !== "PhaseOutput") {
+    handleOtherResponseCodes(res, renderedFast);
+    timing?.end();
+    return;
+  }
+  let fastViewState = renderedFast.rendered;
+  let fastCarryForward = renderedFast.carryForward;
+  const instancePhaseData = carryForward?.__instances;
+  if (instancePhaseData && pagePartsResult.val.headlessInstanceComponents.length > 0) {
+    const instanceFastResult = await renderFastChangingDataForInstances(
+      instancePhaseData,
+      pagePartsResult.val.headlessInstanceComponents
+    );
+    if (instanceFastResult) {
+      fastViewState = {
+        ...fastViewState,
+        __headlessInstances: instanceFastResult.viewStates
+      };
+      fastCarryForward = {
+        ...fastCarryForward,
+        __headlessInstances: instanceFastResult.carryForwards
+      };
+    }
+  }
+  await sendResponse(
+    vite,
+    res,
+    url,
+    preRenderedPath,
+    pageParts,
+    fastViewState,
+    fastCarryForward,
+    clientTrackByMap,
+    projectInit,
+    pluginsForPage,
+    options,
+    renderedSlowly.rendered,
+    timing
+  );
+}
+async function handleDirectRequest(vite, route, options, slowlyPhase, pageParams, pageProps, allPluginClientInits, allPluginsWithInit, projectInit, res, url, timing) {
+  const loadStart = Date.now();
+  const pagePartsResult = await loadPageParts(
+    vite,
+    route,
+    options.pagesRootFolder,
+    options.projectRootFolder,
+    options.jayRollupConfig
+  );
+  timing?.recordViteSsr(Date.now() - loadStart);
+  if (!pagePartsResult.val) {
+    getLogger().info(pagePartsResult.validations.join("\n"));
+    res.status(500).end(pagePartsResult.validations.join("\n"));
+    timing?.end();
+    return;
+  }
+  const {
+    parts: pageParts,
+    serverTrackByMap,
+    clientTrackByMap,
+    usedPackages
+  } = pagePartsResult.val;
+  const pluginsForPage = filterPluginsForPage(
+    allPluginClientInits,
+    allPluginsWithInit,
+    usedPackages
+  );
+  const slowStart = Date.now();
+  const renderedSlowly = await slowlyPhase.runSlowlyForPage(pageParams, pageProps, pageParts);
+  if (renderedSlowly.kind !== "PhaseOutput") {
+    timing?.recordSlowRender(Date.now() - slowStart);
+    if (renderedSlowly.kind === "ClientError") {
+      handleOtherResponseCodes(res, renderedSlowly);
+    }
+    timing?.end();
+    return;
+  }
+  let instanceViewStates;
+  let instancePhaseDataForFast;
+  const headlessInstanceComponents = pagePartsResult.val.headlessInstanceComponents ?? [];
+  if (headlessInstanceComponents.length > 0) {
+    const jayHtmlContent = await fs$1.readFile(route.jayHtmlPath, "utf-8");
+    const discoveryResult = discoverHeadlessInstances(jayHtmlContent);
+    if (discoveryResult.instances.length > 0) {
+      const slowResult = await slowRenderInstances(
+        discoveryResult.instances,
+        headlessInstanceComponents
+      );
+      if (slowResult) {
+        instanceViewStates = { ...slowResult.slowViewStates };
+        instancePhaseDataForFast = slowResult.instancePhaseData;
+      }
+    }
+  }
+  timing?.recordSlowRender(Date.now() - slowStart);
+  const fastStart = Date.now();
+  const renderedFast = await renderFastChangingData(
+    pageParams,
+    pageProps,
+    renderedSlowly.carryForward,
+    pageParts
+  );
+  if (instancePhaseDataForFast && instanceViewStates) {
+    const instanceFastResult = await renderFastChangingDataForInstances(
+      instancePhaseDataForFast,
+      headlessInstanceComponents
+    );
+    if (instanceFastResult) {
+      for (const [coordKey, fastVS] of Object.entries(instanceFastResult.viewStates)) {
+        instanceViewStates[coordKey] = {
+          ...instanceViewStates[coordKey] || {},
+          ...fastVS
+        };
+      }
+    }
+  }
+  timing?.recordFastRender(Date.now() - fastStart);
+  if (renderedFast.kind !== "PhaseOutput") {
+    handleOtherResponseCodes(res, renderedFast);
+    timing?.end();
+    return;
+  }
+  let viewState;
+  if (serverTrackByMap && Object.keys(serverTrackByMap).length > 0) {
+    viewState = deepMergeViewStates(
+      renderedSlowly.rendered,
+      renderedFast.rendered,
+      serverTrackByMap
+    );
+  } else {
+    viewState = { ...renderedSlowly.rendered, ...renderedFast.rendered };
+  }
+  if (instanceViewStates && Object.keys(instanceViewStates).length > 0) {
+    viewState = {
+      ...viewState,
+      __headlessInstances: instanceViewStates
+    };
+  }
+  await sendResponse(
+    vite,
+    res,
+    url,
+    route.jayHtmlPath,
+    pageParts,
+    viewState,
+    renderedFast.carryForward,
+    clientTrackByMap,
+    projectInit,
+    pluginsForPage,
+    options,
+    void 0,
+    timing
+  );
+}
+async function sendResponse(vite, res, url, jayHtmlPath, pageParts, viewState, carryForward, clientTrackByMap, projectInit, pluginsForPage, options, slowViewState, timing) {
+  const pageHtml = generateClientScript(
+    viewState,
+    carryForward,
+    pageParts,
+    jayHtmlPath,
+    clientTrackByMap,
+    getClientInitData(),
+    projectInit,
+    pluginsForPage,
+    {
+      enableAutomation: !options.disableAutomation,
+      slowViewState
+    }
+  );
+  if (options.buildFolder) {
+    const pageName = !url || url === "/" ? "index" : url.replace(/^\//, "").replace(/\//g, "-");
+    const clientScriptDir = path__default.join(options.buildFolder, "client-scripts");
+    await fs$1.mkdir(clientScriptDir, { recursive: true });
+    await fs$1.writeFile(path__default.join(clientScriptDir, `${pageName}.html`), pageHtml, "utf-8");
+  }
+  const viteStart = Date.now();
+  const compiledPageHtml = await vite.transformIndexHtml(!!url ? url : "/", pageHtml);
+  timing?.recordViteClient(Date.now() - viteStart);
+  res.status(200).set({ "Content-Type": "text/html" }).send(compiledPageHtml);
+  timing?.end();
+}
+async function preRenderJayHtml(route, slowViewState, headlessContracts, headlessInstanceComponents) {
+  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) {
+      getLogger().error(
+        `[SlowRender] Contract parse error for ${contractPath}: ${parseResult.validations.join(", ")}`
+      );
+      return void 0;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      getLogger().error(`[SlowRender] Error reading contract ${contractPath}: ${error}`);
+      return void 0;
+    }
+  }
+  const result = slowRenderTransform({
+    jayHtmlContent,
+    slowViewState,
+    contract,
+    headlessContracts,
+    sourceDir: path__default.dirname(route.jayHtmlPath),
+    importResolver: JAY_IMPORT_RESOLVER
+  });
+  if (!result.val) {
+    if (result.validations.length > 0) {
+      getLogger().error(
+        `[SlowRender] Transform failed for ${route.jayHtmlPath}: ${result.validations.join(", ")}`
+      );
+    }
+    return void 0;
+  }
+  let preRenderedJayHtml = result.val.preRenderedJayHtml;
+  let instancePhaseData;
+  if (headlessInstanceComponents.length > 0) {
+    const discoveryResult = discoverHeadlessInstances(preRenderedJayHtml);
+    preRenderedJayHtml = discoveryResult.preRenderedJayHtml;
+    if (discoveryResult.instances.length > 0) {
+      const slowResult = await slowRenderInstances(
+        discoveryResult.instances,
+        headlessInstanceComponents
+      );
+      if (slowResult) {
+        instancePhaseData = slowResult.instancePhaseData;
+        const pass2Result = resolveHeadlessInstances(
+          preRenderedJayHtml,
+          slowResult.resolvedData,
+          JAY_IMPORT_RESOLVER
+        );
+        if (pass2Result.val) {
+          preRenderedJayHtml = pass2Result.val;
+        }
+        if (pass2Result.validations.length > 0) {
+          getLogger().error(
+            `[SlowRender] Instance resolution warnings for ${route.jayHtmlPath}: ${pass2Result.validations.join(", ")}`
+          );
+        }
+      }
+    }
+  }
+  return { preRenderedJayHtml, instancePhaseData };
+}
+async function renderFastChangingDataForInstances(instancePhaseData, headlessInstanceComponents) {
+  const componentByContractName = /* @__PURE__ */ new Map();
+  for (const comp of headlessInstanceComponents) {
+    componentByContractName.set(comp.contractName, comp);
+  }
+  const viewStates = {};
+  const carryForwards = {};
+  let hasResults = false;
+  for (const instance of instancePhaseData.discovered) {
+    const coordKey = instance.coordinate.join("/");
+    const comp = componentByContractName.get(instance.contractName);
+    if (!comp || !comp.compDefinition.fastRender) {
+      continue;
+    }
+    const instanceCarryForward = instancePhaseData.carryForwards[coordKey] || {};
+    const services = resolveServices(comp.compDefinition.services);
+    const fastResult = await comp.compDefinition.fastRender(
+      instance.props,
+      instanceCarryForward,
+      ...services
+    );
+    if (fastResult.kind === "PhaseOutput") {
+      viewStates[coordKey] = fastResult.rendered;
+      carryForwards[coordKey] = fastResult.carryForward;
+      hasResults = true;
+    }
+  }
+  return hasResults ? { viewStates, carryForwards } : void 0;
+}
+async function materializeDynamicContracts(projectRootFolder, buildFolder, viteServer) {
+  try {
+    const services = getServiceRegistry();
+    const result = await materializeContracts(
+      {
+        projectRoot: projectRootFolder,
+        outputDir: path__default.join(buildFolder, "materialized-contracts"),
+        verbose: false,
+        viteServer
+      },
+      services
+    );
+    const dynamicCount = result.dynamicCount;
+    if (dynamicCount > 0) {
+      getLogger().info(`[Contracts] Materialized ${dynamicCount} dynamic contract(s)`);
+    }
+  } catch (error) {
+    getLogger().warn(`[Contracts] Failed to materialize dynamic contracts: ${error.message}`);
+  }
+}
+async function mkDevServer(rawOptions) {
+  const options = defaults(rawOptions);
   const {
     publicBaseUrlPath,
     pagesRootFolder,
     projectRootFolder,
+    buildFolder,
     jayRollupConfig,
     dontCacheSlowly
-  } = defaults(options);
+  } = options;
+  const viteLogLevel = options.logLevel === "silent" ? "silent" : options.logLevel === "verbose" ? "info" : "warn";
   const lifecycleManager = new ServiceLifecycleManager(projectRootFolder);
   setupGracefulShutdown(lifecycleManager);
-  const vite = await createServer({
-    server: { middlewareMode: true },
-    plugins: [...jayStackCompiler(jayRollupConfig)],
-    appType: "custom",
+  const vite = await createViteServer({
+    projectRoot: projectRootFolder,
+    pagesRoot: pagesRootFolder,
     base: publicBaseUrlPath,
-    root: pagesRootFolder,
-    ssr: {
-      // Mark stack-server-runtime as external so Vite uses Node's require
-      // This ensures lib/init.ts and dev-server share the same module instance
-      external: ["@jay-framework/stack-server-runtime"]
-    }
+    jayRollupConfig,
+    logLevel: viteLogLevel
   });
   lifecycleManager.setViteServer(vite);
   await lifecycleManager.initialize();
+  await materializeDynamicContracts(projectRootFolder, buildFolder, vite);
   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, projectInit, pluginsWithInit, pluginClientInits)
+    (route) => mkRoute(
+      route,
+      vite,
+      slowlyPhase,
+      options,
+      slowRenderCache,
+      projectInit,
+      pluginsWithInit,
+      pluginClientInits
+    )
   );
   return {
     server: vite.middlewares,
@@ -1778,7 +2463,7 @@ async function mkDevServer(options) {
 }
 function setupGracefulShutdown(lifecycleManager) {
   const shutdown = async (signal) => {
-    console.log(`
+    getLogger().important(`
 ${signal} received, shutting down gracefully...`);
     await lifecycleManager.shutdown();
     process.exit(0);
@@ -1794,7 +2479,7 @@ function setupServiceHotReload(vite, lifecycleManager) {
   vite.watcher.add(initFilePath);
   vite.watcher.on("change", async (changedPath) => {
     if (changedPath === initFilePath) {
-      console.log("[Services] lib/init.ts changed, reloading services...");
+      getLogger().info("[Services] lib/init.ts changed, reloading services...");
       try {
         await lifecycleManager.reload();
         vite.ws.send({
@@ -1802,7 +2487,7 @@ function setupServiceHotReload(vite, lifecycleManager) {
           path: "*"
         });
       } catch (error) {
-        console.error("[Services] Failed to reload services:", error);
+        getLogger().error(`[Services] Failed to reload services: ${error}`);
       }
     }
   });
@@ -1810,11 +2495,45 @@ 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}`);
+  getLogger().info(`[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(() => {
+        getLogger().info(`[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(() => {
+        getLogger().info(
+          `[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(() => {
+        getLogger().info(
+          `[SlowRender] Cache invalidated for ${jayHtmlPath} (contract changed)`
+        );
+      });
+      return;
+    }
+  });
 }
 export {
   ACTION_ENDPOINT_BASE,
   actionBodyParser,
   createActionRouter,
+  createViteForCli,
+  createViteServer,
   mkDevServer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/dev-server",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -22,21 +22,22 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/compiler-jay-stack": "^0.10.0",
-    "@jay-framework/compiler-shared": "^0.10.0",
-    "@jay-framework/component": "^0.10.0",
-    "@jay-framework/fullstack-component": "^0.10.0",
-    "@jay-framework/runtime": "^0.10.0",
-    "@jay-framework/stack-client-runtime": "^0.10.0",
-    "@jay-framework/stack-route-scanner": "^0.10.0",
-    "@jay-framework/stack-server-runtime": "^0.10.0",
-    "@jay-framework/view-state-merge": "^0.10.0",
+    "@jay-framework/compiler-jay-stack": "^0.12.0",
+    "@jay-framework/compiler-shared": "^0.12.0",
+    "@jay-framework/component": "^0.12.0",
+    "@jay-framework/fullstack-component": "^0.12.0",
+    "@jay-framework/logger": "^0.12.0",
+    "@jay-framework/runtime": "^0.12.0",
+    "@jay-framework/stack-client-runtime": "^0.12.0",
+    "@jay-framework/stack-route-scanner": "^0.12.0",
+    "@jay-framework/stack-server-runtime": "^0.12.0",
+    "@jay-framework/view-state-merge": "^0.12.0",
     "vite": "^5.0.11"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.10.0",
-    "@jay-framework/jay-cli": "^0.10.0",
-    "@jay-framework/stack-client-runtime": "^0.10.0",
+    "@jay-framework/dev-environment": "^0.12.0",
+    "@jay-framework/jay-cli": "^0.12.0",
+    "@jay-framework/stack-client-runtime": "^0.12.0",
     "@types/express": "^5.0.2",
     "@types/node": "^22.15.21",
     "nodemon": "^3.0.3",