@jay-framework/dev-server 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -2,6 +2,8 @@ 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 { ProjectClientInitInfo, PluginWithInit, ActionRegistry } from '@jay-framework/stack-server-runtime';
+import { RequestHandler as RequestHandler$1 } from 'express';
 
 interface DevServerOptions {
     publicBaseUrlPath?: string;
@@ -14,30 +16,40 @@ interface DevServerOptions {
 /**
  * Service lifecycle management for the Jay Stack dev-server.
  *
- * Handles loading jay.init.ts, running init/shutdown callbacks,
- * hot reloading services, and graceful shutdown.
+ * Handles loading lib/init.ts, running init/shutdown callbacks,
+ * hot reloading services, graceful shutdown, and action auto-discovery.
  */
 
 declare class ServiceLifecycleManager {
     private projectRoot;
     private sourceBase;
-    private initFilePath;
+    /** Path to project's lib/init.ts (makeJayInit pattern) */
+    private projectInitFilePath;
     private isInitialized;
     private viteServer;
+    private pluginsWithInit;
     constructor(projectRoot: string, sourceBase?: string);
     /**
      * Set the Vite server instance for SSR module loading
      */
     setViteServer(viteServer: ViteDevServer): void;
     /**
-     * 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}
      */
-    private findInitFile;
+    private findProjectInitFile;
     /**
-     * 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
      */
     initialize(): Promise<void>;
+    /**
+     * Auto-discovers and registers actions from project and plugins.
+     */
+    private discoverActions;
     /**
      * Shuts down services gracefully with timeout
      */
@@ -47,9 +59,18 @@ declare class ServiceLifecycleManager {
      */
     reload(): Promise<void>;
     /**
-     * Returns the path to the init file if found
+     * Returns the path to the init file if found.
      */
     getInitFilePath(): string | null;
+    /**
+     * Returns project init info for client-side embedding.
+     */
+    getProjectInit(): ProjectClientInitInfo | null;
+    /**
+     * Returns the discovered plugins with init configurations.
+     * Sorted by dependencies (plugins with no deps first).
+     */
+    getPluginsWithInit(): PluginWithInit[];
     /**
      * Checks if services are initialized
      */
@@ -69,4 +90,53 @@ interface DevServer {
 }
 declare function mkDevServer(options: DevServerOptions): Promise<DevServer>;
 
-export { type DevServer, type DevServerOptions, type DevServerRoute, mkDevServer };
+/**
+ * Action Router for Jay Stack dev server.
+ *
+ * Handles HTTP requests to /_jay/actions/:actionName
+ * and routes them to registered action handlers.
+ */
+
+/**
+ * The base path for action endpoints.
+ */
+declare const ACTION_ENDPOINT_BASE = "/_jay/actions";
+/**
+ * Options for creating the action router.
+ */
+interface ActionRouterOptions {
+    /**
+     * The action registry to use.
+     * Defaults to the global actionRegistry.
+     */
+    registry?: ActionRegistry;
+}
+/**
+ * Creates the action router middleware.
+ *
+ * Handles requests to /_jay/actions/:actionName
+ *
+ * For GET requests, input is parsed from query string.
+ * For POST/PUT/PATCH/DELETE, input is parsed from request body.
+ *
+ * @param options - Optional configuration including custom registry for testing
+ *
+ * @example
+ * ```typescript
+ * // In dev-server setup (uses default registry)
+ * const actionRouter = createActionRouter();
+ * app.use(ACTION_ENDPOINT_BASE, actionRouter);
+ *
+ * // For testing (uses isolated registry)
+ * const testRegistry = new ActionRegistry();
+ * const actionRouter = createActionRouter({ registry: testRegistry });
+ * ```
+ */
+declare function createActionRouter(options?: ActionRouterOptions): RequestHandler$1;
+/**
+ * Express middleware to parse JSON body for action requests.
+ * Should be applied before the action router.
+ */
+declare function actionBodyParser(): RequestHandler$1;
+
+export { ACTION_ENDPOINT_BASE, type ActionRouterOptions, type DevServer, type DevServerOptions, type DevServerRoute, actionBodyParser, createActionRouter, mkDevServer };

package/dist/index.js

@@ -6,7 +6,7 @@ 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, 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";
@@ -365,7 +365,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 +464,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 +599,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 +638,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 +648,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 +678,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 +747,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 +779,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 +803,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 +815,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 +850,284 @@ 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"
+        );
+      }
+    }
+  };
+}
+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(
     // 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 +1136,93 @@ 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;
+            }
+          }
+          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 +1233,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 +1247,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 +1361,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 +1411,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",
@@ -1046,7 +1650,7 @@ function handleOtherResponseCodes(res, renderedResult) {
   else
     res.status(renderedResult.status).end("redirect to " + renderedResult.location);
 }
-function mkRoute(route, vite, slowlyPhase, options) {
+function mkRoute(route, vite, slowlyPhase, options, projectInit, allPluginsWithInit = [], allPluginClientInits = []) {
   const path2 = routeToExpressRoute(route);
   const handler = async (req, res) => {
     try {
@@ -1057,33 +1661,56 @@ function mkRoute(route, vite, slowlyPhase, options) {
         url
       };
       let viewState, carryForward;
-      const pageParts = await loadPageParts(
+      const pagePartsResult = await loadPageParts(
         vite,
         route,
         options.pagesRootFolder,
+        options.projectRootFolder,
         options.jayRollupConfig
       );
-      if (pageParts.val) {
+      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(
           pageParams,
           pageProps,
-          pageParts.val
+          pageParts
         );
-        if (renderedSlowly.kind === "PartialRender") {
+        if (renderedSlowly.kind === "PhaseOutput") {
           const renderedFast = await renderFastChangingData(
             pageParams,
             pageProps,
             renderedSlowly.carryForward,
-            pageParts.val
+            pageParts
           );
-          if (renderedFast.kind === "PartialRender") {
-            viewState = { ...renderedSlowly.rendered, ...renderedFast.rendered };
+          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.val,
-              route.jayHtmlPath
+              pageParts,
+              route.jayHtmlPath,
+              clientTrackByMap,
+              getClientInitData(),
+              projectInit,
+              pluginsForPage
             );
             const compiledPageHtml = await vite.transformIndexHtml(
               !!url ? url : "/",
@@ -1097,8 +1724,8 @@ function mkRoute(route, vite, slowlyPhase, options) {
           handleOtherResponseCodes(res, renderedSlowly);
         }
       } else {
-        console.log(pageParts.validations.join("\n"));
-        res.status(500).end(pageParts.validations.join("\n"));
+        console.log(pagePartsResult.validations.join("\n"));
+        res.status(500).end(pagePartsResult.validations.join("\n"));
       }
     } catch (e2) {
       vite?.ssrFixStacktrace(e2);
@@ -1126,17 +1753,21 @@ 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 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, projectInit, pluginsWithInit, pluginClientInits)
   );
   return {
     server: vite.middlewares,
@@ -1163,7 +1794,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 +1807,14 @@ 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}`);
+}
 export {
+  ACTION_ENDPOINT_BASE,
+  actionBodyParser,
+  createActionRouter,
   mkDevServer
 };

package/package.json

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