@jay-framework/dev-server 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -1,15 +1,61 @@
-import { Connect, ViteDevServer } from 'vite';
+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';
 
 interface DevServerOptions {
-    serverBase?: string;
-    pagesBase?: string;
+    publicBaseUrlPath?: string;
+    projectRootFolder?: string;
+    pagesRootFolder?: string;
     jayRollupConfig: JayRollupConfig;
     dontCacheSlowly: boolean;
 }
 
+/**
+ * Service lifecycle management for the Jay Stack dev-server.
+ *
+ * Handles loading jay.init.ts, running init/shutdown callbacks,
+ * hot reloading services, and graceful shutdown.
+ */
+
+declare class ServiceLifecycleManager {
+    private projectRoot;
+    private sourceBase;
+    private initFilePath;
+    private isInitialized;
+    private viteServer;
+    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}
+     */
+    private findInitFile;
+    /**
+     * Initializes services by loading and executing jay.init.ts
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shuts down services gracefully with timeout
+     */
+    shutdown(timeoutMs?: number): Promise<void>;
+    /**
+     * Hot reload: shutdown, clear caches, re-import, and re-initialize
+     */
+    reload(): Promise<void>;
+    /**
+     * Returns the path to the init file if found
+     */
+    getInitFilePath(): string | null;
+    /**
+     * Checks if services are initialized
+     */
+    isReady(): boolean;
+}
+
 interface DevServerRoute {
     path: string;
     handler: RequestHandler;
@@ -19,6 +65,7 @@ interface DevServer {
     server: Connect.Server;
     viteServer: ViteDevServer;
     routes: DevServerRoute[];
+    lifecycleManager: ServiceLifecycleManager;
 }
 declare function mkDevServer(options: DevServerOptions): Promise<DevServer>;
 

package/dist/index.js

@@ -1,8 +1,1018 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 import { createServer } from "vite";
 import { scanRoutes, routeToExpressRoute } from "@jay-framework/stack-route-scanner";
-import { DevSlowlyChangingPhase, loadPageParts, renderFastChangingData, generateClientScript } from "@jay-framework/stack-server-runtime";
+import { runInitCallbacks, runShutdownCallbacks, clearLifecycleCallbacks, clearServiceRegistry, DevSlowlyChangingPhase, loadPageParts, renderFastChangingData, generateClientScript } from "@jay-framework/stack-server-runtime";
 import { jayRuntime } from "@jay-framework/vite-plugin";
-import path from "node:path";
+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$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$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 SERVER_METHODS = /* @__PURE__ */ new Set([
+  "withServices",
+  "withLoadParams",
+  "withSlowlyRender",
+  "withFastRender"
+]);
+const CLIENT_METHODS = /* @__PURE__ */ new Set([
+  "withInteractive",
+  "withContexts"
+]);
+function shouldRemoveMethod(methodName, environment) {
+  return environment === "client" && SERVER_METHODS.has(methodName) || environment === "server" && CLIENT_METHODS.has(methodName);
+}
+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 };
+}
+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 && flattened.path[0] === "makeJayStackComponent" && 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: isFunctionDeclaration$1,
+  isVariableStatement: isVariableStatement$1,
+  isInterfaceDeclaration: isInterfaceDeclaration$1,
+  isTypeAliasDeclaration: isTypeAliasDeclaration$1,
+  isClassDeclaration,
+  isEnumDeclaration,
+  SyntaxKind
+} = c$1;
+function analyzeUnusedStatements(sourceFile, bindingResolver) {
+  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$1(statement) && statement.name) {
+    return statement.name.text;
+  }
+  if (isVariableStatement$1(statement)) {
+    const firstDecl = statement.declarationList.declarations[0];
+    if (firstDecl && isIdentifier$1(firstDecl.name)) {
+      return firstDecl.name.text;
+    }
+  }
+  if (isInterfaceDeclaration$1(statement) && statement.name) {
+    return statement.name.text;
+  }
+  if (isTypeAliasDeclaration$1(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,
+  isFunctionDeclaration,
+  isVariableStatement,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration
+} = 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, removedVariables } = 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);
+  new SourceFileBindingResolver(transformedSourceFile);
+  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
+  );
+}
+function jayStackCompiler(jayOptions = {}) {
+  return [
+    // 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) {
+          return null;
+        }
+        const environment = isClientBuild ? "client" : "server";
+        if (!id.endsWith(".ts") && !id.includes(".ts?")) {
+          return null;
+        }
+        try {
+          return transformJayStackBuilder(code, id, environment);
+        } catch (error) {
+          console.error(`[jay-stack:code-split] Error transforming ${id}:`, error);
+          return null;
+        }
+      }
+    },
+    // Second: Jay runtime compilation (existing plugin)
+    jayRuntime(jayOptions)
+  ];
+}
+class ServiceLifecycleManager {
+  constructor(projectRoot, sourceBase = "src") {
+    __publicField(this, "initFilePath", null);
+    __publicField(this, "isInitialized", false);
+    __publicField(this, "viteServer", null);
+    this.projectRoot = projectRoot;
+    this.sourceBase = sourceBase;
+  }
+  /**
+   * Set the Vite server instance for SSR module loading
+   */
+  setViteServer(viteServer) {
+    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}
+   */
+  findInitFile() {
+    const extensions = [".ts", ".js", ".mts", ".mjs"];
+    const baseFilename = "jay.init";
+    for (const ext of extensions) {
+      const filePath = path.join(this.projectRoot, this.sourceBase, baseFilename + ext);
+      if (fs.existsSync(filePath)) {
+        return filePath;
+      }
+    }
+    return null;
+  }
+  /**
+   * Initializes services by loading and executing jay.init.ts
+   */
+  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;
+    }
+    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 runInitCallbacks();
+      this.isInitialized = true;
+      console.log("[Services] Initialization complete");
+    } catch (error) {
+      console.error("[Services] Failed to initialize:", error);
+      throw error;
+    }
+  }
+  /**
+   * Shuts down services gracefully with timeout
+   */
+  async shutdown(timeoutMs = 5e3) {
+    if (!this.isInitialized) {
+      return;
+    }
+    console.log("[Services] Shutting down...");
+    try {
+      await Promise.race([
+        runShutdownCallbacks(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Shutdown timeout")), timeoutMs)
+        )
+      ]);
+      console.log("[Services] Shutdown complete");
+    } catch (error) {
+      if (error.message === "Shutdown timeout") {
+        console.warn("[Services] Shutdown timed out after", timeoutMs, "ms");
+      } else {
+        console.error("[Services] Shutdown error:", error);
+      }
+    } finally {
+      this.isInitialized = false;
+    }
+  }
+  /**
+   * 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);
+      if (moduleNode) {
+        await this.viteServer.moduleGraph.invalidateModule(moduleNode);
+      }
+    } else {
+      delete require.cache[require.resolve(this.initFilePath)];
+    }
+    this.isInitialized = false;
+    await this.initialize();
+    console.log("[Services] Reload complete");
+  }
+  /**
+   * Returns the path to the init file if found
+   */
+  getInitFilePath() {
+    return this.initFilePath;
+  }
+  /**
+   * Checks if services are initialized
+   */
+  isReady() {
+    return this.isInitialized;
+  }
+}
 async function initRoutes(pagesBaseFolder) {
   return await scanRoutes(pagesBaseFolder, {
     jayHtmlFilename: "page.jay-html",
@@ -10,12 +1020,17 @@ async function initRoutes(pagesBaseFolder) {
   });
 }
 function defaults(options) {
-  const serverBase = options.serverBase || process.env.BASE || "/";
-  const pagesBase = path.resolve(serverBase, options.pagesBase || "./src/pages");
-  const tsConfigFilePath = options.jayRollupConfig.tsConfigFilePath || path.resolve(serverBase, "./tsconfig.json");
+  const publicBaseUrlPath = options.publicBaseUrlPath || process.env.BASE || "/";
+  const projectRootFolder = options.projectRootFolder || ".";
+  const pagesRootFolder = path__default.resolve(
+    projectRootFolder,
+    options.pagesRootFolder || "./src/pages"
+  );
+  const tsConfigFilePath = options.jayRollupConfig.tsConfigFilePath || path__default.resolve(projectRootFolder, "./tsconfig.json");
   return {
-    serverBase,
-    pagesBase,
+    publicBaseUrlPath,
+    pagesRootFolder,
+    projectRootFolder,
     dontCacheSlowly: options.dontCacheSlowly,
     jayRollupConfig: {
       ...options.jayRollupConfig || {},
@@ -35,7 +1050,7 @@ function mkRoute(route, vite, slowlyPhase, options) {
   const path2 = routeToExpressRoute(route);
   const handler = async (req, res) => {
     try {
-      const url = req.originalUrl.replace(options.serverBase, "");
+      const url = req.originalUrl.replace(options.publicBaseUrlPath, "");
       const pageParams = req.params;
       const pageProps = {
         language: "en",
@@ -45,7 +1060,7 @@ function mkRoute(route, vite, slowlyPhase, options) {
       const pageParts = await loadPageParts(
         vite,
         route,
-        options.pagesBase,
+        options.pagesRootFolder,
         options.jayRollupConfig
       );
       if (pageParts.val) {
@@ -85,24 +1100,40 @@ function mkRoute(route, vite, slowlyPhase, options) {
         console.log(pageParts.validations.join("\n"));
         res.status(500).end(pageParts.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 { serverBase, pagesBase, 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: serverBase,
-    root: pagesBase
+    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
+      external: ["@jay-framework/stack-server-runtime"]
+    }
   });
-  const routes = await initRoutes(pagesBase);
+  lifecycleManager.setViteServer(vite);
+  await lifecycleManager.initialize();
+  setupServiceHotReload(vite, lifecycleManager);
+  const routes = await initRoutes(pagesRootFolder);
   const slowlyPhase = new DevSlowlyChangingPhase(dontCacheSlowly);
   const devServerRoutes = routes.map(
     (route) => mkRoute(route, vite, slowlyPhase, options)
@@ -110,8 +1141,40 @@ async function mkDevServer(options) {
   return {
     server: vite.middlewares,
     viteServer: vite,
-    routes: devServerRoutes
+    routes: devServerRoutes,
+    lifecycleManager
+  };
+}
+function setupGracefulShutdown(lifecycleManager) {
+  const shutdown = async (signal) => {
+    console.log(`
+${signal} received, shutting down gracefully...`);
+    await lifecycleManager.shutdown();
+    process.exit(0);
   };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+function setupServiceHotReload(vite, lifecycleManager) {
+  const initFilePath = lifecycleManager.getInitFilePath();
+  if (!initFilePath) {
+    return;
+  }
+  vite.watcher.add(initFilePath);
+  vite.watcher.on("change", async (changedPath) => {
+    if (changedPath === initFilePath) {
+      console.log("[Services] jay.init.ts changed, reloading services...");
+      try {
+        await lifecycleManager.reload();
+        vite.ws.send({
+          type: "full-reload",
+          path: "*"
+        });
+      } catch (error) {
+        console.error("[Services] Failed to reload services:", error);
+      }
+    }
+  });
 }
 export {
   mkDevServer

package/package.json

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