@jay-framework/dev-server 0.8.0 → 0.10.0

package/dist/index.js

@@ -6,17 +6,1223 @@ 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";
 import * as path from "node:path";
 import path__default from "node:path";
+import "@jay-framework/compiler-jay-html";
 import * as fs from "node:fs";
 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) {
+    return t[r];
+  }
+});
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => {
+  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const s = createRequire(import.meta.url), e = s("typescript"), c = new Proxy(e, {
+  get(t, r) {
+    return t[r];
+  }
+});
+const {
+  visitEachChild: visitEachChild$5,
+  isArrowFunction: isArrowFunction$4,
+  isFunctionExpression: isFunctionExpression$1,
+  createSourceFile: createSourceFile$1,
+  ScriptTarget: ScriptTarget$1,
+  isFunctionDeclaration: isFunctionDeclaration$3,
+  isMethodDeclaration,
+  isConstructorDeclaration,
+  isGetAccessorDeclaration,
+  isSetAccessorDeclaration,
+  createPrinter: createPrinter$1,
+  NewLineKind,
+  EmitHint,
+  setTextRange
+} = c;
+createPrinter$1({
+  newLine: NewLineKind.LineFeed
+});
+function isFunctionLikeDeclarationBase(node) {
+  return isFunctionExpression$1(node) || isArrowFunction$4(node) || isFunctionDeclaration$3(node) || isMethodDeclaration(node) || isConstructorDeclaration(node) || isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node);
+}
+function mkTransformer(fileTransformer, config) {
+  return (context) => {
+    const { factory } = context;
+    return (sourceFile) => {
+      return fileTransformer({ factory, context, sourceFile, ...config || {} });
+    };
+  };
+}
+const {
+  isIdentifier: isIdentifier$9,
+  isStatement: isStatement$3,
+  isObjectBindingPattern,
+  isArrayBindingPattern,
+  isBindingElement,
+  isPropertyAccessExpression: isPropertyAccessExpression$5,
+  isElementAccessExpression: isElementAccessExpression$1,
+  isStringLiteral: isStringLiteral$8,
+  isParenthesizedExpression,
+  isAsExpression,
+  isObjectLiteralExpression,
+  isPropertyAssignment: isPropertyAssignment$1,
+  isShorthandPropertyAssignment,
+  isNumericLiteral,
+  isToken,
+  isNamespaceImport,
+  isNamedImports: isNamedImports$1,
+  isArrowFunction: isArrowFunction$2,
+  isFunctionExpression,
+  isCallExpression: isCallExpression$6,
+  NodeFlags,
+  SyntaxKind: SyntaxKind$5
+} = c;
+var VariableRootType = /* @__PURE__ */ ((VariableRootType2) => {
+  VariableRootType2[VariableRootType2["FunctionParameter"] = 0] = "FunctionParameter";
+  VariableRootType2[VariableRootType2["FunctionDefinition"] = 1] = "FunctionDefinition";
+  VariableRootType2[VariableRootType2["Literal"] = 2] = "Literal";
+  VariableRootType2[VariableRootType2["ImportModule"] = 3] = "ImportModule";
+  VariableRootType2[VariableRootType2["FunctionCall"] = 4] = "FunctionCall";
+  VariableRootType2[VariableRootType2["Global"] = 5] = "Global";
+  VariableRootType2[VariableRootType2["Other"] = 6] = "Other";
+  return VariableRootType2;
+})(VariableRootType || {});
+function mkParameterVariableRoot(param, paramIndex) {
+  return { kind: 0, param, paramIndex };
+}
+function mkFunctionVariableRoot(func) {
+  return { kind: 1, func };
+}
+function mkLiteralVariableRoot(literal) {
+  return { kind: 2, literal };
+}
+function mkImportModuleVariableRoot(module, importType) {
+  return { kind: 3, module, importType };
+}
+function mkFunctionCallVariableRoot(node) {
+  return { kind: 4, node };
+}
+function mkGlobalVariableRoot(name) {
+  return { kind: 5, name };
+}
+function mkOtherVariableRoot(node) {
+  return { kind: 6, node };
+}
+function isImportModuleVariableRoot(vr) {
+  return vr.kind === 3;
+}
+function mkVariable(members) {
+  return Object.fromEntries(Object.entries(members).filter(([, value]) => value !== void 0));
+}
+const UNKNOWN_VARIABLE = {};
+const getAccessedByProperty = (binding, accessedFrom, propertyName) => {
+  return accessedFrom ? propertyName ? isIdentifier$9(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
+};
+function findDeclaringStatement(node) {
+  if (!node)
+    return void 0;
+  else if (isStatement$3(node))
+    return node;
+  else
+    return findDeclaringStatement(node.parent);
+}
+function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyName, root) {
+  if (isIdentifier$9(binding)) {
+    return [
+      mkVariable({
+        name: binding.text,
+        accessedFrom,
+        accessedByProperty: getAccessedByProperty(binding, accessedFrom, propertyName),
+        assignedFrom,
+        root,
+        definingStatement: findDeclaringStatement(binding)
+      })
+    ];
+  } else if (isObjectBindingPattern(binding)) {
+    let variable = mkVariable({
+      accessedFrom,
+      accessedByProperty: propertyName ? isIdentifier$9(propertyName) ? propertyName.text : void 0 : void 0,
+      assignedFrom,
+      root,
+      definingStatement: findDeclaringStatement(binding)
+    });
+    return binding.elements.flatMap((element) => {
+      return tsBindingNameToVariable(element.name, variable, void 0, element.propertyName);
+    });
+  } else if (isArrayBindingPattern(binding)) {
+    let variable = mkVariable({
+      accessedFrom,
+      accessedByProperty: propertyName ? isIdentifier$9(propertyName) ? propertyName.text : void 0 : void 0,
+      assignedFrom,
+      root,
+      definingStatement: findDeclaringStatement(binding)
+    });
+    return binding.elements.flatMap((element, index) => {
+      return isBindingElement(element) && tsBindingNameToVariable(element.name, variable, void 0, {
+        kind: 80,
+        text: "" + index
+      });
+    }).filter((variable2) => !!variable2);
+  }
+}
+class NameBindingResolver {
+  constructor(parentNameResolver) {
+    __publicField2(this, "variables", /* @__PURE__ */ new Map());
+    this.parentNameResolver = parentNameResolver;
+  }
+  addVariable(name, variable) {
+    this.variables.set(name, variable);
+  }
+  addFunctionParams(functionDeclaration) {
+    functionDeclaration.parameters.map((param, paramIndex) => {
+      let paramVariables = tsBindingNameToVariable(
+        param.name,
+        void 0,
+        void 0,
+        void 0,
+        mkParameterVariableRoot(param, paramIndex)
+      );
+      paramVariables.forEach((variable) => {
+        if (variable.name)
+          this.variables.set(variable.name, variable);
+      });
+    });
+  }
+  addFunctionDeclaration(statement) {
+    if (statement.name) {
+      let functionVariable = mkVariable({
+        name: statement.name.text,
+        root: mkFunctionVariableRoot(statement),
+        definingStatement: statement
+      });
+      this.variables.set(statement.name.text, functionVariable);
+    }
+  }
+  addVariableDeclarationList(declarationList) {
+    const letOrConst = declarationList.flags === NodeFlags.Const ? 1 : 0;
+    declarationList.declarations.forEach((declaration) => {
+      let rightSide = declaration.initializer ? this.resolvePropertyAccessChain(declaration.initializer) : void 0;
+      let declaredVariable = tsBindingNameToVariable(
+        declaration.name,
+        void 0,
+        rightSide,
+        void 0
+      );
+      declaredVariable.forEach(
+        (variable) => this.variables.set(variable.name, { ...variable, letOrConst })
+      );
+    });
+  }
+  addVariableStatement(variableStatement) {
+    this.addVariableDeclarationList(variableStatement.declarationList);
+  }
+  getVariable(name) {
+    return this.variables.get(name) || UNKNOWN_VARIABLE;
+  }
+  resolvePropertyAccessChain(expression) {
+    if (isPropertyAccessExpression$5(expression)) {
+      const name = expression.name.text;
+      const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
+      return { accessedFrom: identifiersFromObject, accessedByProperty: name };
+    } else if (isElementAccessExpression$1(expression) && isStringLiteral$8(expression.argumentExpression)) {
+      const name = expression.argumentExpression.text;
+      const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
+      return { accessedFrom: identifiersFromObject, accessedByProperty: name };
+    } else if (isIdentifier$9(expression)) {
+      return this.resolveIdentifier(expression);
+    } else if (isParenthesizedExpression(expression)) {
+      return this.resolvePropertyAccessChain(expression.expression);
+    } else if (isAsExpression(expression)) {
+      return this.resolvePropertyAccessChain(expression.expression);
+    } else if (isObjectLiteralExpression(expression)) {
+      return {
+        properties: expression.properties.map((property) => {
+          if (isPropertyAssignment$1(property) && (isStringLiteral$8(property.name) || isIdentifier$9(property.name))) {
+            if (isIdentifier$9(property.initializer))
+              return {
+                name: property.name.text,
+                assignedFrom: this.resolveIdentifier(property.initializer)
+              };
+            else if (isObjectLiteralExpression(property.initializer)) {
+              let nestedProperty = this.resolvePropertyAccessChain(
+                property.initializer
+              );
+              nestedProperty.name = property.name.text;
+              return nestedProperty;
+            } else if (isArrowFunction$2(property.initializer) || isFunctionExpression(property.initializer)) {
+              return {
+                name: property.name.text,
+                root: mkFunctionVariableRoot(property.initializer)
+              };
+            } else
+              return {
+                name: property.name.text,
+                root: mkLiteralVariableRoot(property.initializer)
+              };
+          } else if (isShorthandPropertyAssignment(property))
+            return {
+              name: property.name.text,
+              assignedFrom: this.resolveIdentifier(property.name)
+            };
+        })
+      };
+    } else if (isArrowFunction$2(expression) || isFunctionExpression(expression)) {
+      return { root: mkFunctionVariableRoot(expression) };
+    } else if (isCallExpression$6(expression)) {
+      return { root: mkFunctionCallVariableRoot(expression) };
+    } else if (isStringLiteral$8(expression) || isNumericLiteral(expression) || isToken(expression) && expression.kind === SyntaxKind$5.TrueKeyword || isToken(expression) && expression.kind === SyntaxKind$5.FalseKeyword) {
+      return { root: mkLiteralVariableRoot(expression) };
+    } else {
+      return { root: mkOtherVariableRoot(expression) };
+    }
+  }
+  resolvePropertyAccess(expression) {
+    return this.resolvePropertyAccessChain(expression);
+  }
+  resolveIdentifier(expression) {
+    let variableName = expression.text;
+    let nameResolver = this;
+    let resolved;
+    while ((resolved = nameResolver.getVariable(variableName)) === UNKNOWN_VARIABLE && nameResolver.parentNameResolver)
+      nameResolver = nameResolver.parentNameResolver;
+    if (resolved === UNKNOWN_VARIABLE)
+      return { root: mkGlobalVariableRoot(variableName) };
+    return resolved;
+  }
+  addImportDeclaration(node) {
+    if (node.importClause?.name) {
+      let root = mkImportModuleVariableRoot(
+        node.moduleSpecifier,
+        0
+        /* defaultImport */
+      );
+      let variable = mkVariable({
+        name: node.importClause.name.text,
+        definingStatement: node,
+        root
+      });
+      this.variables.set(node.importClause.name.text, variable);
+    }
+    if (node.importClause?.namedBindings) {
+      let root = mkImportModuleVariableRoot(
+        node.moduleSpecifier,
+        1
+        /* namedImport */
+      );
+      let namedBindings = node.importClause.namedBindings;
+      if (isNamespaceImport(namedBindings)) {
+        let variable = mkVariable({
+          name: namedBindings.name.text,
+          definingStatement: node,
+          root
+        });
+        this.variables.set(namedBindings.name.text, variable);
+      } else if (isNamedImports$1(namedBindings)) {
+        namedBindings.elements.forEach((importSpecifier) => {
+          if (!importSpecifier.isTypeOnly) {
+            let variable = mkVariable({
+              name: importSpecifier.name.text,
+              accessedByProperty: (importSpecifier.propertyName || importSpecifier.name).text,
+              accessedFrom: {
+                definingStatement: node,
+                root
+              },
+              definingStatement: node
+            });
+            this.variables.set(importSpecifier.name.text, variable);
+          }
+        });
+      }
+    }
+  }
+}
+function flattenVariable(variable, path2 = []) {
+  if (variable.assignedFrom)
+    return flattenVariable(variable.assignedFrom, path2);
+  else if (variable.accessedFrom) {
+    return flattenVariable(variable.accessedFrom, [variable.accessedByProperty, ...path2]);
+  } else if (variable.properties && !!variable.properties.find((_) => _.name === path2[0])) {
+    return flattenVariable(
+      variable.properties.find((_) => _.name === path2[0]),
+      path2.slice(1)
+    );
+  } else
+    return { path: path2, root: variable.root };
+}
+function byAnd() {
+  return (agg, value) => agg && value;
+}
+const {
+  isIdentifier: isIdentifier$6,
+  SyntaxKind: SyntaxKind$4,
+  isStringLiteral: isStringLiteral$7,
+  visitNode: visitNode$4,
+  isFunctionDeclaration: isFunctionDeclaration$1,
+  isVariableStatement: isVariableStatement$2,
+  isImportDeclaration: isImportDeclaration$3,
+  isBlock: isBlock$2,
+  isForStatement: isForStatement$1,
+  isVariableDeclarationList,
+  isForInStatement: isForInStatement$1,
+  isForOfStatement: isForOfStatement$1,
+  isTypeReferenceNode: isTypeReferenceNode$1,
+  isArrayTypeNode,
+  isFunctionTypeNode,
+  isUnionTypeNode
+} = c;
+const BUILT_IN_TYPES = ["RegExp", "Date"];
+function builtInType(text) {
+  return BUILT_IN_TYPES.findIndex((_) => _ === text) > -1;
+}
+class BuiltInResolvedType {
+  constructor(name) {
+    this.name = name;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof BuiltInResolvedType && this.name === rightSide.name;
+  }
+}
+class ImportFromModuleResolvedType {
+  constructor(module, path2) {
+    this.module = module;
+    this.path = path2;
+  }
+  canBeAssignedFrom(rightSide) {
+    if (rightSide instanceof ImportFromModuleResolvedType) {
+      let pathEqual = this.path.length === rightSide.path.length;
+      if (pathEqual) {
+        pathEqual = this.path.map((value, index) => value === rightSide.path[index]).reduce(byAnd(), true);
+      }
+      return pathEqual && this.module === rightSide.module;
+    }
+    return false;
+  }
+}
+class ArrayResolvedType {
+  constructor(itemType) {
+    this.itemType = itemType;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof ArrayResolvedType && this.itemType === rightSide.itemType;
+  }
+}
+class FunctionResolvedType {
+  constructor(params, returns) {
+    this.params = params;
+    this.returns = returns;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof FunctionResolvedType && this.returns.canBeAssignedFrom(rightSide.returns);
+  }
+}
+class UnionResolvedType {
+  constructor(types) {
+    this.types = types;
+  }
+  canBeAssignedFrom(rightSide) {
+    if (rightSide instanceof UnionResolvedType) {
+      for (const item1 of this.types)
+        for (const item2 of rightSide.types)
+          if (item1.canBeAssignedFrom(item2))
+            return true;
+    } else
+      for (const item1 of this.types)
+        if (item1.canBeAssignedFrom(rightSide))
+          return true;
+    return false;
+  }
+}
+class GlobalResolvedType {
+  constructor(name) {
+    this.name = name;
+  }
+  canBeAssignedFrom(rightSide) {
+    return rightSide instanceof GlobalResolvedType && this.name === rightSide.name;
+  }
+}
+class SourceFileBindingResolver {
+  constructor(sourceFile) {
+    __publicField2(this, "nameBindingResolvers", /* @__PURE__ */ new Map());
+    this.nameBindingResolvers.set(sourceFile, new NameBindingResolver());
+    const nbResolversQueue = [
+      this.nameBindingResolvers.get(sourceFile)
+    ];
+    const doWithChildBindingResolver = (node, callback) => {
+      nbResolversQueue.unshift(new NameBindingResolver(nbResolversQueue[0]));
+      this.nameBindingResolvers.set(node, nbResolversQueue[0]);
+      callback();
+      node.getChildren().forEach((child) => visitNode$4(child, visitor));
+      nbResolversQueue.shift();
+      return node;
+    };
+    const visitor = (node) => {
+      if (isFunctionDeclaration$1(node))
+        nbResolversQueue[0].addFunctionDeclaration(node);
+      if (isVariableStatement$2(node))
+        nbResolversQueue[0].addVariableStatement(node);
+      else if (isImportDeclaration$3(node))
+        nbResolversQueue[0].addImportDeclaration(node);
+      else if (isBlock$2(node))
+        return doWithChildBindingResolver(node, () => {
+        });
+      else if (isFunctionLikeDeclarationBase(node)) {
+        return doWithChildBindingResolver(
+          node,
+          () => nbResolversQueue[0].addFunctionParams(node)
+        );
+      } else if (isForStatement$1(node) && isVariableDeclarationList(node.initializer)) {
+        return doWithChildBindingResolver(
+          node,
+          () => nbResolversQueue[0].addVariableDeclarationList(
+            node.initializer
+          )
+        );
+      } else if ((isForInStatement$1(node) || isForOfStatement$1(node)) && isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && isIdentifier$6(node.initializer.declarations[0].name)) {
+        return doWithChildBindingResolver(node, () => {
+          let name = node.initializer.declarations[0].name.text;
+          nbResolversQueue[0].addVariable(
+            name,
+            mkVariable({
+              name,
+              root: mkOtherVariableRoot(node),
+              definingStatement: node
+            })
+          );
+        });
+      }
+      node.getChildren().forEach((child) => visitNode$4(child, visitor));
+      return node;
+    };
+    visitNode$4(sourceFile, visitor);
+  }
+  findBindingResolver(node) {
+    let found;
+    while (!(found = this.nameBindingResolvers.get(node)) && node.parent)
+      node = node.parent;
+    return found;
+  }
+  explain(identifier) {
+    return this.findBindingResolver(identifier).resolvePropertyAccessChain(identifier);
+  }
+  explainFlattenedVariableType(flattened) {
+    if (!!flattened.root) {
+      if (isImportModuleVariableRoot(flattened.root) && isStringLiteral$7(flattened.root.module)) {
+        return new ImportFromModuleResolvedType(flattened.root.module.text, flattened.path);
+      }
+    } else
+      return void 0;
+  }
+  explainType(type) {
+    if (type) {
+      if (isTypeReferenceNode$1(type)) {
+        let typeName = type.typeName;
+        if (isIdentifier$6(typeName)) {
+          let resolved = this.findBindingResolver(typeName).resolveIdentifier(typeName);
+          let flattened = flattenVariable(resolved);
+          let typeFromFlattened = this.explainFlattenedVariableType(flattened);
+          if (typeFromFlattened)
+            return typeFromFlattened;
+          if (builtInType(typeName.text))
+            return new BuiltInResolvedType(typeName.text);
+        }
+      } else if (type.kind === SyntaxKind$4.StringKeyword)
+        return new BuiltInResolvedType("string");
+      else if (type.kind === SyntaxKind$4.NumberKeyword)
+        return new BuiltInResolvedType("number");
+      else if (type.kind === SyntaxKind$4.BooleanKeyword)
+        return new BuiltInResolvedType("boolean");
+      else if (type.kind === SyntaxKind$4.AnyKeyword)
+        return new BuiltInResolvedType("any");
+      else if (type.kind === SyntaxKind$4.VoidKeyword)
+        return new BuiltInResolvedType("void");
+      else if (isArrayTypeNode(type))
+        return new ArrayResolvedType(this.explainType(type.elementType));
+      else if (isFunctionTypeNode(type)) {
+        const params = type.parameters.map((param) => this.explainType(param.type));
+        const ret = this.explainType(type.type);
+        return new FunctionResolvedType(params, ret);
+      } else if (isUnionTypeNode(type))
+        return new UnionResolvedType(type.types.map((aType) => this.explainType(aType)));
+    }
+    return new BuiltInResolvedType("void");
+  }
+  globalType(globalVariableRoot) {
+    return new GlobalResolvedType(globalVariableRoot.name);
+  }
+}
+const { isStringLiteral: isStringLiteral$1 } = c;
+function areFlattenedAccessChainsEqual(chain1, chain2) {
+  if (chain1.path.length !== chain2.path.length) {
+    return false;
+  }
+  const pathsEqual = chain1.path.every((value, index) => value === chain2.path[index]);
+  if (!pathsEqual) {
+    return false;
+  }
+  return areVariableRootsEqual(chain1.root, chain2.root);
+}
+function areVariableRootsEqual(root1, root2) {
+  if (!root1 && !root2) {
+    return true;
+  }
+  if (!root1 || !root2) {
+    return false;
+  }
+  if (root1.kind !== root2.kind) {
+    return false;
+  }
+  switch (root1.kind) {
+    case VariableRootType.ImportModule:
+      if (isImportModuleVariableRoot(root1) && isImportModuleVariableRoot(root2)) {
+        const module1 = isStringLiteral$1(root1.module) ? root1.module.text : String(root1.module);
+        const module2 = isStringLiteral$1(root2.module) ? root2.module.text : String(root2.module);
+        return module1 === module2 && root1.importType === root2.importType;
+      }
+      return false;
+    case VariableRootType.FunctionParameter:
+    case VariableRootType.FunctionDefinition:
+    case VariableRootType.Literal:
+    case VariableRootType.FunctionCall:
+      return true;
+    case VariableRootType.Global:
+    case VariableRootType.Other:
+      return true;
+    default:
+      return false;
+  }
+}
+const COMPONENT_SERVER_METHODS = /* @__PURE__ */ new Set([
+  "withServices",
+  "withLoadParams",
+  "withSlowlyRender",
+  "withFastRender"
+]);
+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) {
+  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) {
+  const callsToRemove = [];
+  const removedVariables = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (isCallExpression$1(node) && isPropertyAccessExpression$1(node.expression) && isPartOfJayStackChain(node, bindingResolver)) {
+      const methodName = node.expression.name.text;
+      if (shouldRemoveMethod(methodName, environment)) {
+        const variable = bindingResolver.explain(node.expression);
+        const flattened = flattenVariable(variable);
+        callsToRemove.push(flattened);
+        collectVariablesFromArguments(node.arguments, bindingResolver, removedVariables);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  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) {
+    if (isPropertyAccessExpression$1(current)) {
+      current = current.expression;
+    } else if (isCallExpression$1(current)) {
+      if (isIdentifier$2(current.expression)) {
+        const variable = bindingResolver.explain(current.expression);
+        const flattened = flattenVariable(variable);
+        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)) {
+        current = current.expression.expression;
+        continue;
+      } else {
+        break;
+      }
+    } else {
+      break;
+    }
+  }
+  return false;
+}
+function collectVariablesFromArguments(args, bindingResolver, variables) {
+  const visitor = (node) => {
+    if (isIdentifier$2(node)) {
+      const variable = bindingResolver.explain(node);
+      if (variable && (variable.name || variable.root)) {
+        variables.add(variable);
+      }
+    }
+    node.forEachChild(visitor);
+  };
+  args.forEach((arg) => visitor(arg));
+}
+const {
+  isIdentifier: isIdentifier$1,
+  isImportDeclaration: isImportDeclaration$1,
+  isFunctionDeclaration,
+  isVariableStatement,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration,
+  isClassDeclaration,
+  isEnumDeclaration,
+  SyntaxKind
+} = c$1;
+function analyzeUnusedStatements(sourceFile) {
+  const statementsToRemove = /* @__PURE__ */ new Set();
+  const collectUsedIdentifiers = () => {
+    const used = /* @__PURE__ */ new Set();
+    for (const statement of sourceFile.statements) {
+      if (isImportDeclaration$1(statement) || statementsToRemove.has(statement)) {
+        continue;
+      }
+      const definedName = getStatementDefinedName(statement);
+      const visitor = (node, parent) => {
+        if (isIdentifier$1(node)) {
+          if (node.text !== definedName) {
+            used.add(node.text);
+          }
+        }
+        node.forEachChild((child) => visitor(child));
+      };
+      statement.forEachChild((child) => visitor(child));
+    }
+    return used;
+  };
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const stillUsedIdentifiers = collectUsedIdentifiers();
+    for (const statement of sourceFile.statements) {
+      if (statementsToRemove.has(statement) || isImportDeclaration$1(statement) || isExportStatement(statement)) {
+        continue;
+      }
+      const definedName = getStatementDefinedName(statement);
+      if (definedName && !stillUsedIdentifiers.has(definedName)) {
+        statementsToRemove.add(statement);
+        changed = true;
+      }
+    }
+  }
+  const finalUsedIdentifiers = collectUsedIdentifiers();
+  const unusedImports = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (isImportDeclaration$1(statement) && statement.importClause?.namedBindings) {
+      const namedBindings = statement.importClause.namedBindings;
+      if ("elements" in namedBindings) {
+        for (const element of namedBindings.elements) {
+          const importName = element.name.text;
+          if (!finalUsedIdentifiers.has(importName)) {
+            unusedImports.add(importName);
+          }
+        }
+      }
+    }
+  }
+  return { statementsToRemove, unusedImports };
+}
+function isExportStatement(statement) {
+  const modifiers = "modifiers" in statement ? statement.modifiers : void 0;
+  if (modifiers) {
+    return modifiers.some((mod) => mod.kind === SyntaxKind.ExportKeyword);
+  }
+  return false;
+}
+function getStatementDefinedName(statement) {
+  if (isFunctionDeclaration(statement) && statement.name) {
+    return statement.name.text;
+  }
+  if (isVariableStatement(statement)) {
+    const firstDecl = statement.declarationList.declarations[0];
+    if (firstDecl && isIdentifier$1(firstDecl.name)) {
+      return firstDecl.name.text;
+    }
+  }
+  if (isInterfaceDeclaration(statement) && statement.name) {
+    return statement.name.text;
+  }
+  if (isTypeAliasDeclaration(statement) && statement.name) {
+    return statement.name.text;
+  }
+  if (isClassDeclaration(statement) && statement.name) {
+    return statement.name.text;
+  }
+  if (isEnumDeclaration(statement) && statement.name) {
+    return statement.name.text;
+  }
+  return void 0;
+}
+const {
+  createPrinter,
+  createSourceFile,
+  ScriptTarget,
+  visitEachChild,
+  isCallExpression,
+  isPropertyAccessExpression,
+  isImportDeclaration,
+  isNamedImports,
+  isIdentifier
+} = c$1;
+function transformJayStackBuilder(code, filePath, environment) {
+  const sourceFile = createSourceFile(filePath, code, ScriptTarget.Latest, true);
+  const transformers = [mkTransformer(mkJayStackCodeSplitTransformer, { environment })];
+  const printer = createPrinter();
+  const result = c$1.transform(sourceFile, transformers);
+  const transformedFile = result.transformed[0];
+  const transformedCode = printer.printFile(transformedFile);
+  result.dispose();
+  return {
+    code: transformedCode
+  };
+}
+function isCallToRemove(flattened, callsToRemove) {
+  return callsToRemove.some((call) => areFlattenedAccessChainsEqual(flattened, call));
+}
+function mkJayStackCodeSplitTransformer({
+  factory,
+  sourceFile,
+  context,
+  environment
+}) {
+  const bindingResolver = new SourceFileBindingResolver(sourceFile);
+  const { callsToRemove } = findBuilderMethodsToRemove(sourceFile, bindingResolver, environment);
+  const transformVisitor = (node) => {
+    if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
+      const variable = bindingResolver.explain(node.expression);
+      const flattened = flattenVariable(variable);
+      if (isCallToRemove(flattened, callsToRemove)) {
+        const receiver = node.expression.expression;
+        return transformVisitor(receiver);
+      }
+    }
+    return visitEachChild(node, transformVisitor, context);
+  };
+  let transformedSourceFile = visitEachChild(
+    sourceFile,
+    transformVisitor,
+    context
+  );
+  const { statementsToRemove, unusedImports } = analyzeUnusedStatements(transformedSourceFile);
+  const transformedStatements = transformedSourceFile.statements.map((statement) => {
+    if (statementsToRemove.has(statement)) {
+      return void 0;
+    }
+    if (isImportDeclaration(statement)) {
+      return filterImportDeclaration(statement, unusedImports, factory);
+    }
+    return statement;
+  }).filter((s2) => s2 !== void 0);
+  return factory.updateSourceFile(transformedSourceFile, transformedStatements);
+}
+function filterImportDeclaration(statement, unusedImports, factory) {
+  const importClause = statement.importClause;
+  if (!importClause?.namedBindings || !isNamedImports(importClause.namedBindings)) {
+    return statement;
+  }
+  const usedElements = importClause.namedBindings.elements.filter(
+    (element) => !unusedImports.has(element.name.text)
+  );
+  if (usedElements.length === 0) {
+    return void 0;
+  }
+  return factory.updateImportDeclaration(
+    statement,
+    statement.modifiers,
+    factory.updateImportClause(
+      importClause,
+      importClause.isTypeOnly,
+      importClause.name,
+      factory.updateNamedImports(importClause.namedBindings, usedElements)
+    ),
+    statement.moduleSpecifier,
+    statement.assertClause
+  );
+}
+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, options2) {
+        if (!id.endsWith(".ts") && !id.includes(".ts?")) {
+          return null;
+        }
+        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) {
+          console.error(`[jay-stack:code-split] Error transforming ${id}:`, error);
+          return null;
+        }
+      }
+    },
+    // 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;
   }
@@ -27,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;
       }
@@ -42,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`);
     }
   }
   /**
@@ -100,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
@@ -133,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",
@@ -142,7 +1626,10 @@ async function initRoutes(pagesBaseFolder) {
 function defaults(options) {
   const publicBaseUrlPath = options.publicBaseUrlPath || process.env.BASE || "/";
   const projectRootFolder = options.projectRootFolder || ".";
-  const pagesRootFolder = path__default.resolve(projectRootFolder, options.pagesRootFolder || "./src/pages");
+  const pagesRootFolder = path__default.resolve(
+    projectRootFolder,
+    options.pagesRootFolder || "./src/pages"
+  );
   const tsConfigFilePath = options.jayRollupConfig.tsConfigFilePath || path__default.resolve(projectRootFolder, "./tsconfig.json");
   return {
     publicBaseUrlPath,
@@ -163,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 {
@@ -174,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 : "/",
@@ -214,40 +1724,50 @@ 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 (e) {
-      vite?.ssrFixStacktrace(e);
-      console.log(e.stack);
-      res.status(500).end(e.stack);
+    } catch (e2) {
+      vite?.ssrFixStacktrace(e2);
+      console.log(e2.stack);
+      res.status(500).end(e2.stack);
     }
   };
   return { path: path2, handler, fsRoute: route };
 }
 async function mkDevServer(options) {
-  const { publicBaseUrlPath, pagesRootFolder, projectRootFolder, jayRollupConfig, dontCacheSlowly } = defaults(options);
+  const {
+    publicBaseUrlPath,
+    pagesRootFolder,
+    projectRootFolder,
+    jayRollupConfig,
+    dontCacheSlowly
+  } = defaults(options);
   const lifecycleManager = new ServiceLifecycleManager(projectRootFolder);
   setupGracefulShutdown(lifecycleManager);
   const vite = await createServer({
     server: { middlewareMode: true },
-    plugins: [jayRuntime(jayRollupConfig)],
+    plugins: [...jayStackCompiler(jayRollupConfig)],
     appType: "custom",
     base: publicBaseUrlPath,
     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,
@@ -274,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({
@@ -287,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
 };