@jay-framework/stack-server-runtime 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import { AnyJayStackComponentDefinition, PageProps, AnySlowlyRenderResult, UrlParams, JayStackComponentDefinition, AnyFastRenderResult, ServiceMarker } from '@jay-framework/fullstack-component';
+import { AnyJayStackComponentDefinition, PageProps, AnySlowlyRenderResult, UrlParams, JayStackComponentDefinition, AnyFastRenderResult, HttpMethod, CacheOptions, JayAction, JayActionDefinition, ServiceMarker } from '@jay-framework/fullstack-component';
 import { JayComponentCore } from '@jay-framework/component';
 import { ViteDevServer } from 'vite';
 import { JayRoute } from '@jay-framework/stack-route-scanner';
 import { WithValidations } from '@jay-framework/compiler-shared';
 import { JayRollupConfig } from '@jay-framework/rollup-plugin';
+import { TrackByMap } from '@jay-framework/view-state-merge';
 
 interface DevServerPagePart {
     compDefinition: AnyJayStackComponentDefinition;
@@ -11,7 +12,16 @@ interface DevServerPagePart {
     clientImport: string;
     clientPart: string;
 }
-declare function loadPageParts(vite: ViteDevServer, route: JayRoute, pagesBase: string, jayRollupConfig: JayRollupConfig): Promise<WithValidations<DevServerPagePart[]>>;
+interface LoadedPageParts {
+    parts: DevServerPagePart[];
+    /** TrackBy map for server-side merge (slow → fast) */
+    serverTrackByMap?: Record<string, string>;
+    /** TrackBy map for client-side merge (fast → interactive) */
+    clientTrackByMap?: Record<string, string>;
+    /** NPM package names used on this page (for filtering plugin inits) */
+    usedPackages: Set<string>;
+}
+declare function loadPageParts(vite: ViteDevServer, route: JayRoute, pagesBase: string, projectBase: string, jayRollupConfig: JayRollupConfig): Promise<WithValidations<LoadedPageParts>>;
 
 interface SlowlyChangingPhase {
     runSlowlyForPage(pageParams: object, pageProps: PageProps, parts: Array<DevServerPagePart>): Promise<AnySlowlyRenderResult>;
@@ -26,7 +36,354 @@ declare function runSlowlyChangingRender<Refs extends object, SlowVS extends obj
 
 declare function renderFastChangingData(pageParams: object, pageProps: PageProps, carryForward: object, parts: Array<DevServerPagePart>): Promise<AnyFastRenderResult>;
 
-declare function generateClientScript(defaultViewState: object, fastCarryForward: object, parts: DevServerPagePart[], jayHtmlPath: string): string;
+/**
+ * Action registry for Jay Stack server-side action handling.
+ *
+ * Actions are registered at build/startup time and can be invoked via HTTP.
+ * The registry maps action names to their definitions (handler, services, method, etc.).
+ */
+
+/**
+ * Registered action entry with resolved metadata.
+ */
+interface RegisteredAction {
+    /** Unique action name */
+    actionName: string;
+    /** HTTP method */
+    method: HttpMethod;
+    /** Cache options (for GET requests) */
+    cacheOptions?: CacheOptions;
+    /** Service markers for dependency injection */
+    services: any[];
+    /** The handler function */
+    handler: (input: any, ...services: any[]) => Promise<any>;
+}
+/**
+ * Result of executing an action.
+ */
+type ActionExecutionResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ActionErrorResponse;
+};
+/**
+ * Error response structure for failed actions.
+ */
+interface ActionErrorResponse {
+    code: string;
+    message: string;
+    isActionError: boolean;
+}
+/**
+ * Registry for Jay Stack server actions.
+ *
+ * Manages action registration, lookup, and execution.
+ * Create instances for testing or use the default export for production.
+ *
+ * @example
+ * ```typescript
+ * // For testing - create isolated instance
+ * const registry = new ActionRegistry();
+ * registry.register(myAction);
+ * const result = await registry.execute('my.action', input);
+ *
+ * // For production - use default instance
+ * import { actionRegistry } from '@jay-framework/stack-server-runtime';
+ * actionRegistry.register(myAction);
+ * ```
+ */
+declare class ActionRegistry {
+    private readonly actions;
+    /**
+     * Registers an action with the registry.
+     *
+     * @param action - The JayAction to register (created via makeJayAction/makeJayQuery)
+     */
+    register<I, O, S extends any[]>(action: JayAction<I, O> & JayActionDefinition<I, O, S>): void;
+    /**
+     * Retrieves a registered action by name.
+     *
+     * @param actionName - The unique action name
+     * @returns The registered action or undefined
+     */
+    get(actionName: string): RegisteredAction | undefined;
+    /**
+     * Checks if an action is registered.
+     *
+     * @param actionName - The unique action name
+     * @returns true if the action is registered
+     */
+    has(actionName: string): boolean;
+    /**
+     * Gets all registered action names.
+     *
+     * @returns Array of registered action names
+     */
+    getNames(): string[];
+    /**
+     * Clears all registered actions.
+     */
+    clear(): void;
+    /**
+     * Executes a registered action with the given input.
+     * Resolves services and calls the handler.
+     *
+     * @param actionName - The action to execute
+     * @param input - The input data for the action
+     * @returns The action result or error
+     */
+    execute<T = any>(actionName: string, input: unknown): Promise<ActionExecutionResult<T>>;
+    /**
+     * Gets the cache headers for an action (if applicable).
+     *
+     * @param actionName - The action name
+     * @returns Cache-Control header value or undefined
+     */
+    getCacheHeaders(actionName: string): string | undefined;
+}
+/**
+ * Default action registry instance.
+ * Use this for production; create new instances for testing.
+ */
+declare const actionRegistry: ActionRegistry;
+/**
+ * Registers an action with the default registry.
+ * @deprecated Use actionRegistry.register() instead
+ */
+declare function registerAction<I, O, S extends any[]>(action: JayAction<I, O> & JayActionDefinition<I, O, S>): void;
+/**
+ * Retrieves a registered action by name from the default registry.
+ * @deprecated Use actionRegistry.get() instead
+ */
+declare function getRegisteredAction(actionName: string): RegisteredAction | undefined;
+/**
+ * Checks if an action is registered in the default registry.
+ * @deprecated Use actionRegistry.has() instead
+ */
+declare function hasAction(actionName: string): boolean;
+/**
+ * Gets all registered action names from the default registry.
+ * @deprecated Use actionRegistry.getNames() instead
+ */
+declare function getRegisteredActionNames(): string[];
+/**
+ * Clears all registered actions from the default registry.
+ * @deprecated Use actionRegistry.clear() instead
+ */
+declare function clearActionRegistry(): void;
+/**
+ * Executes an action from the default registry.
+ * @deprecated Use actionRegistry.execute() instead
+ */
+declare function executeAction<T = any>(actionName: string, input: unknown): Promise<ActionExecutionResult<T>>;
+/**
+ * Gets cache headers for an action from the default registry.
+ * @deprecated Use actionRegistry.getCacheHeaders() instead
+ */
+declare function getActionCacheHeaders(actionName: string): string | undefined;
+
+/**
+ * Action discovery and auto-registration for Jay Stack.
+ *
+ * Scans project and plugin directories to discover and register actions
+ * automatically on server startup.
+ */
+
+/**
+ * Vite server interface for SSR module loading.
+ * Using a minimal interface to avoid direct Vite dependency.
+ */
+interface ViteSSRLoader {
+    ssrLoadModule: (url: string) => Promise<Record<string, any>>;
+}
+/**
+ * Options for action discovery.
+ */
+interface ActionDiscoveryOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Custom actions directory (default: src/actions) */
+    actionsDir?: string;
+    /** Registry to register actions in (default: global actionRegistry) */
+    registry?: ActionRegistry;
+    /** Whether to log discovery progress */
+    verbose?: boolean;
+    /** Vite server for SSR module loading (required in dev for TypeScript files) */
+    viteServer?: ViteSSRLoader;
+}
+/**
+ * Result of action discovery.
+ */
+interface ActionDiscoveryResult {
+    /** Number of actions discovered and registered */
+    actionCount: number;
+    /** Names of registered actions */
+    actionNames: string[];
+    /** Paths of scanned action files */
+    scannedFiles: string[];
+}
+/**
+ * Discovers and registers actions from the project's actions directory.
+ *
+ * Scans `src/actions/*.actions.ts` for exported actions and registers them.
+ *
+ * @param options - Discovery options
+ * @returns Result with discovered action information
+ *
+ * @example
+ * ```typescript
+ * // In dev-server startup
+ * const result = await discoverAndRegisterActions({
+ *     projectRoot: process.cwd(),
+ *     verbose: true,
+ * });
+ * console.log(`Registered ${result.actionCount} actions`);
+ * ```
+ */
+declare function discoverAndRegisterActions(options: ActionDiscoveryOptions): Promise<ActionDiscoveryResult>;
+/**
+ * Options for discovering plugin actions.
+ */
+interface PluginActionDiscoveryOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Registry to register actions in (default: global actionRegistry) */
+    registry?: ActionRegistry;
+    /** Whether to log discovery progress */
+    verbose?: boolean;
+    /** Vite server for SSR module loading (required in dev for TypeScript files) */
+    viteServer?: ViteSSRLoader;
+}
+/**
+ * Discovers and registers actions from all plugins in a project.
+ *
+ * Scans both local plugins (src/plugins/) and installed NPM plugins.
+ *
+ * @param options - Discovery options
+ * @returns Array of registered action names
+ */
+declare function discoverAllPluginActions(options: PluginActionDiscoveryOptions): Promise<string[]>;
+/**
+ * Discovers actions from a single plugin's plugin.yaml file.
+ *
+ * Reads plugin.yaml, finds the `actions` array, and imports those
+ * named exports from the plugin's module.
+ *
+ * @param pluginPath - Path to the plugin directory (containing plugin.yaml)
+ * @param projectRoot - Project root for resolving imports
+ * @param registry - Registry to register actions in
+ * @param verbose - Whether to log progress
+ * @returns Array of registered action names
+ */
+declare function discoverPluginActions(pluginPath: string, projectRoot: string, registry?: ActionRegistry, verbose?: boolean, viteServer?: ViteSSRLoader): Promise<string[]>;
+
+/**
+ * Plugin initialization discovery and execution for Jay Stack.
+ *
+ * Discovers plugins with init configurations (using makeJayInit pattern),
+ * sorts them by dependencies, and executes their init functions in order.
+ *
+ * Auto-discovers `lib/init.ts` files in plugins, or uses the path specified
+ * in `plugin.yaml` via the `init` property.
+ */
+
+/**
+ * Information about a discovered plugin with init.
+ */
+interface PluginWithInit {
+    /** Plugin name from plugin.yaml (used as default init key) */
+    name: string;
+    /** Plugin path (directory containing plugin.yaml) */
+    pluginPath: string;
+    /** Package name for NPM plugins, or path for local plugins */
+    packageName: string;
+    /** Whether this is a local plugin (src/plugins/) or NPM */
+    isLocal: boolean;
+    /**
+     * Init module path relative to plugin root.
+     * Default is 'lib/init' (auto-discovered).
+     * Can be overridden via `init` property in plugin.yaml.
+     */
+    initModule: string;
+    /**
+     * Export name for the init constant.
+     * Default is 'init'.
+     * Can be overridden via `init` property in plugin.yaml (for compiled packages).
+     */
+    initExport: string;
+    /** Dependencies from package.json (for ordering) */
+    dependencies: string[];
+}
+/**
+ * Options for plugin init discovery.
+ */
+interface PluginInitDiscoveryOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Whether to log discovery progress */
+    verbose?: boolean;
+}
+/**
+ * Discovers all plugins with init configurations.
+ *
+ * Auto-discovers `lib/init.ts` files in plugins, or uses the path specified
+ * in `plugin.yaml` via the `init` property.
+ *
+ * Scans both local plugins (src/plugins/) and NPM plugins (node_modules/).
+ */
+declare function discoverPluginsWithInit(options: PluginInitDiscoveryOptions): Promise<PluginWithInit[]>;
+/**
+ * Sorts plugins by their dependencies (topological sort).
+ * Plugins with no dependencies come first, then plugins that depend on them, etc.
+ */
+declare function sortPluginsByDependencies(plugins: PluginWithInit[]): PluginWithInit[];
+/**
+ * Executes server init for all plugins in order.
+ *
+ * Uses the `makeJayInit` pattern:
+ * - Loads the init module and finds the JayInit object
+ * - Calls `_serverInit()` if defined
+ * - Stores returned data via `setClientInitData(pluginName, data)`
+ *
+ * @param plugins - Sorted list of plugins with init
+ * @param viteServer - Vite server for SSR module loading (optional)
+ * @param verbose - Whether to log progress
+ */
+declare function executePluginServerInits(plugins: PluginWithInit[], viteServer?: ViteSSRLoader, verbose?: boolean): Promise<void>;
+/**
+ * Information needed to generate client init script for a plugin.
+ */
+interface PluginClientInitInfo {
+    /** Plugin name (used for logging and as data key) */
+    name: string;
+    /** Import path for the init module */
+    importPath: string;
+    /** Export name for the JayInit constant */
+    initExport: string;
+}
+/**
+ * Prepares plugin information for client init script generation.
+ *
+ * For LOCAL plugins: Use the init file path directly
+ * For NPM plugins: Use the `/client` subpath (client bundle exports init)
+ *
+ * Filters to only plugins that have init modules and returns the
+ * information needed to generate client-side imports and execution.
+ */
+declare function preparePluginClientInits(plugins: PluginWithInit[]): PluginClientInitInfo[];
+
+/**
+ * Information needed to generate client init script for the project.
+ */
+interface ProjectClientInitInfo {
+    /** Import path for the init module */
+    importPath: string;
+    /** Export name for the JayInit constant (default: 'init') */
+    initExport?: string;
+}
+declare function generateClientScript(defaultViewState: object, fastCarryForward: object, parts: DevServerPagePart[], jayHtmlPath: string, trackByMap?: TrackByMap, clientInitData?: Record<string, Record<string, any>>, projectInit?: ProjectClientInitInfo, pluginInits?: PluginClientInitInfo[]): string;
 
 /**
  * Service registry for Jay Stack server-side dependency injection.
@@ -144,5 +501,52 @@ declare function runShutdownCallbacks(): Promise<void>;
  * Internal API used by dev-server during hot reload.
  */
 declare function clearLifecycleCallbacks(): void;
+/**
+ * Sets client init data for a specific namespace (plugin or project).
+ * Each namespace's data is kept separate and passed only to the matching
+ * client init callback.
+ *
+ * @param key - Namespace key (plugin name or 'project')
+ * @param data - Data object for this namespace
+ *
+ * @example
+ * ```typescript
+ * // In plugin server init
+ * onInit(async () => {
+ *   setClientInitData('wix-stores', {
+ *     currency: 'USD',
+ *     apiEndpoint: process.env.STORES_API_URL,
+ *   });
+ * });
+ *
+ * // In project jay.init.ts
+ * onInit(async () => {
+ *   setClientInitData('project', {
+ *     oauthClientId: process.env.OAUTH_CLIENT_ID,
+ *     featureFlags: await loadFeatureFlags(),
+ *   });
+ * });
+ * ```
+ */
+declare function setClientInitData(key: string, data: Record<string, any>): void;
+/**
+ * Gets all namespaced client init data.
+ * Internal API used by page rendering to embed data in HTML.
+ *
+ * @returns Object with namespace keys and their data
+ */
+declare function getClientInitData(): Record<string, Record<string, any>>;
+/**
+ * Gets client init data for a specific namespace.
+ *
+ * @param key - Namespace key
+ * @returns Data for that namespace, or empty object if not set
+ */
+declare function getClientInitDataForKey(key: string): Record<string, any>;
+/**
+ * Clears client init data.
+ * Internal API used by dev-server during hot reload.
+ */
+declare function clearClientInitData(): void;
 
-export { DevSlowlyChangingPhase, type SlowlyChangingPhase, clearLifecycleCallbacks, clearServiceRegistry, generateClientScript, getService, hasService, loadPageParts, onInit, onShutdown, registerService, renderFastChangingData, resolveServices, runInitCallbacks, runLoadParams, runShutdownCallbacks, runSlowlyChangingRender };
+export { type ActionDiscoveryOptions, type ActionDiscoveryResult, type ActionErrorResponse, type ActionExecutionResult, ActionRegistry, type DevServerPagePart, DevSlowlyChangingPhase, type LoadedPageParts, type PluginActionDiscoveryOptions, type PluginClientInitInfo, type PluginInitDiscoveryOptions, type PluginWithInit, type ProjectClientInitInfo, type RegisteredAction, type SlowlyChangingPhase, type ViteSSRLoader, actionRegistry, clearActionRegistry, clearClientInitData, clearLifecycleCallbacks, clearServiceRegistry, discoverAllPluginActions, discoverAndRegisterActions, discoverPluginActions, discoverPluginsWithInit, executeAction, executePluginServerInits, generateClientScript, getActionCacheHeaders, getClientInitData, getClientInitDataForKey, getRegisteredAction, getRegisteredActionNames, getService, hasAction, hasService, loadPageParts, onInit, onShutdown, preparePluginClientInits, registerAction, registerService, renderFastChangingData, resolveServices, runInitCallbacks, runLoadParams, runShutdownCallbacks, runSlowlyChangingRender, setClientInitData, sortPluginsByDependencies };

package/dist/index.js

@@ -1,8 +1,22 @@
-import { notFound, partialRender } from "@jay-framework/fullstack-component";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { parseJayFile } from "@jay-framework/compiler-jay-html";
+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 { notFound, partialRender, phaseOutput, isJayAction } from "@jay-framework/fullstack-component";
+import fs$1 from "node:fs/promises";
+import * as path from "node:path";
+import path__default from "node:path";
+import { parseJayFile, JAY_IMPORT_RESOLVER } from "@jay-framework/compiler-jay-html";
 import { createRequire } from "module";
+import * as fs from "node:fs";
+import { createRequire as createRequire$1 } from "node:module";
+import "prettier";
+import "js-beautify";
+import fs$2 from "fs";
+import path$1 from "path";
+import YAML from "yaml";
 const serviceRegistry = /* @__PURE__ */ new Map();
 function registerService(marker, service) {
   serviceRegistry.set(marker, service);
@@ -50,6 +64,19 @@ function clearLifecycleCallbacks() {
   initCallbacks.length = 0;
   shutdownCallbacks.length = 0;
 }
+let clientInitData = {};
+function setClientInitData(key, data) {
+  clientInitData[key] = { ...clientInitData[key] || {}, ...data };
+}
+function getClientInitData() {
+  return clientInitData;
+}
+function getClientInitDataForKey(key) {
+  return clientInitData[key] || {};
+}
+function clearClientInitData() {
+  clientInitData = {};
+}
 function isLeftSideParamsSubsetOfRightSideParams(left, right) {
   return Object.keys(left).reduce((prev, curr) => prev && left[curr] === right[curr], true);
 }
@@ -84,7 +111,7 @@ class DevSlowlyChangingPhase {
           { ...pageProps, ...pageParams },
           ...services
         );
-        if (slowlyRenderedPart.kind === "PartialRender") {
+        if (slowlyRenderedPart.kind === "PhaseOutput") {
           if (!key) {
             slowlyViewState = { ...slowlyViewState, ...slowlyRenderedPart.rendered };
             carryForward = { ...carryForward, ...slowlyRenderedPart.carryForward };
@@ -117,7 +144,7 @@ async function renderFastChangingData(pageParams, pageProps, carryForward, parts
         partSlowlyCarryForward,
         ...services
       );
-      if (fastRenderedPart.kind === "PartialRender") {
+      if (fastRenderedPart.kind === "PhaseOutput") {
         if (!key) {
           fastViewState = { ...fastViewState, ...fastRenderedPart.rendered };
           fastCarryForward = { ...fastCarryForward, ...fastRenderedPart.carryForward };
@@ -129,13 +156,37 @@ async function renderFastChangingData(pageParams, pageProps, carryForward, parts
         return fastRenderedPart;
     }
   }
-  return Promise.resolve(partialRender(fastViewState, fastCarryForward));
+  return Promise.resolve(phaseOutput(fastViewState, fastCarryForward));
 }
-function generateClientScript(defaultViewState, fastCarryForward, parts, jayHtmlPath) {
+function generateClientScript(defaultViewState, fastCarryForward, parts, jayHtmlPath, trackByMap = {}, clientInitData2 = {}, projectInit, pluginInits = []) {
   const imports = parts.length > 0 ? parts.map((part) => part.clientImport).join("\n") + "\n" : "";
   const compositeParts = parts.length > 0 ? `[
 ${parts.map((part) => "        " + part.clientPart).join(",\n")}
         ]` : "[]";
+  const hasClientInit = projectInit || pluginInits.length > 0;
+  const pluginClientInitImports = pluginInits.map((plugin, idx) => {
+    return `import { ${plugin.initExport} as jayInit${idx} } from "${plugin.importPath}";`;
+  }).join("\n      ");
+  const projectInitImport = projectInit ? `import { ${projectInit.initExport || "init"} as projectJayInit } from "${projectInit.importPath}";` : "";
+  const pluginClientInitCalls = pluginInits.map((plugin, idx) => {
+    const pluginData = clientInitData2[plugin.name] || {};
+    return `if (typeof jayInit${idx}._clientInit === 'function') {
+        console.log('[DevServer] Running client init: ${plugin.name}');
+        await jayInit${idx}._clientInit(${JSON.stringify(pluginData)});
+      }`;
+  }).join("\n      ");
+  const projectInitCall = projectInit ? `if (typeof projectJayInit._clientInit === 'function') {
+        console.log('[DevServer] Running client init: project');
+        const projectData = ${JSON.stringify(clientInitData2["project"] || {})};
+        await projectJayInit._clientInit(projectData);
+      }` : "";
+  const clientInitExecution = hasClientInit ? `
+      // Plugin client initialization (in dependency order)
+      ${pluginClientInitCalls}
+      
+      // Project client initialization
+      ${projectInitCall}
+` : "";
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -147,13 +198,16 @@ ${parts.map((part) => "        " + part.clientPart).join(",\n")}
     <div id="target"></div>
     <script type="module">
       import {makeCompositeJayComponent} from "@jay-framework/stack-client-runtime";
+      ${pluginClientInitImports}
+      ${projectInitImport}
       import { render } from '${jayHtmlPath}';
       ${imports}
       const viewState = ${JSON.stringify(defaultViewState)};
       const fastCarryForward = ${JSON.stringify(fastCarryForward)};
-
+      const trackByMap = ${JSON.stringify(trackByMap)};
+${clientInitExecution}
       const target = document.getElementById('target');
-      const pageComp = makeCompositeJayComponent(render, viewState, fastCarryForward, ${compositeParts})
+      const pageComp = makeCompositeJayComponent(render, viewState, fastCarryForward, ${compositeParts}, trackByMap)
 
       const instance = pageComp({...viewState, ...fastCarryForward})
       target.appendChild(instance.element.dom);
@@ -161,24 +215,22 @@ ${parts.map((part) => "        " + part.clientPart).join(",\n")}
   </body>
 </html>`;
 }
-const require2 = createRequire(import.meta.url);
-async function loadPageParts(vite, route, pagesBase, jayRollupConfig) {
-  const exists = await fs.access(route.compPath, fs.constants.F_OK).then(() => true).catch(() => false);
+const require$2 = createRequire(import.meta.url);
+async function loadPageParts(vite, route, pagesBase, projectBase, jayRollupConfig) {
+  const exists = await fs$1.access(route.compPath, fs$1.constants.F_OK).then(() => true).catch(() => false);
   const parts = [];
   if (exists) {
-    const pageComponent = (await vite.ssrLoadModule(route.compPath + "?jay-server")).page;
+    const pageComponent = (await vite.ssrLoadModule(route.compPath)).page;
     parts.push({
       compDefinition: pageComponent,
       // Client import uses client-only code (server code stripped)
-      clientImport: `import {page} from '${route.compPath}?jay-client'`,
+      clientImport: `import {page} from '${route.compPath}'`,
       clientPart: `{comp: page.comp, contextMarkers: []}`
     });
   }
-  const jayHtmlSource = (await fs.readFile(route.jayHtmlPath)).toString();
-  const fileName = path.basename(route.jayHtmlPath);
-  const dirName = path.dirname(route.jayHtmlPath);
-  const module = await import("@jay-framework/compiler-jay-html");
-  const JAY_IMPORT_RESOLVER = module.JAY_IMPORT_RESOLVER;
+  const jayHtmlSource = (await fs$1.readFile(route.jayHtmlPath)).toString();
+  const fileName = path__default.basename(route.jayHtmlPath);
+  const dirName = path__default.dirname(route.jayHtmlPath);
   const jayHtmlWithValidations = await parseJayFile(
     jayHtmlSource,
     fileName,
@@ -186,19 +238,24 @@ async function loadPageParts(vite, route, pagesBase, jayRollupConfig) {
     {
       relativePath: jayRollupConfig.tsConfigFilePath
     },
-    JAY_IMPORT_RESOLVER
+    JAY_IMPORT_RESOLVER,
+    projectBase
   );
   return jayHtmlWithValidations.mapAsync(async (jayHtml) => {
+    const usedPackages = /* @__PURE__ */ new Set();
     for await (const headlessImport of jayHtml.headlessImports) {
-      const module2 = headlessImport.codeLink.module;
+      const module = headlessImport.codeLink.module;
       const name = headlessImport.codeLink.names[0].name;
-      const isLocalModule = module2[0] === "." || module2[0] === "/";
-      const modulePath = isLocalModule ? path.resolve(dirName, module2) : require2.resolve(module2, { paths: require2.resolve.paths(dirName) });
-      const serverModulePath = isLocalModule ? modulePath + "?jay-server" : modulePath;
-      const compDefinition = (await vite.ssrLoadModule(serverModulePath))[name];
-      const moduleImport = module2.startsWith("./") ? path.resolve(pagesBase, module2) : module2;
-      const isNpmPackage = !module2.startsWith("./") && !module2.startsWith("../");
-      const clientModuleImport = isNpmPackage ? `${moduleImport}/client` : `${moduleImport}?jay-client`;
+      const isLocalModule = module[0] === "." || module[0] === "/";
+      const modulePath = isLocalModule ? path__default.resolve(dirName, module) : require$2.resolve(module, { paths: require$2.resolve.paths(dirName) });
+      const compDefinition = (await vite.ssrLoadModule(modulePath))[name];
+      const moduleImport = isLocalModule ? path__default.resolve(dirName, module) : module;
+      const isNpmPackage = !isLocalModule;
+      const clientModuleImport = isNpmPackage ? `${moduleImport}/client` : `${moduleImport}`;
+      if (isNpmPackage) {
+        const packageName = module.startsWith("@") ? module.split("/").slice(0, 2).join("/") : module.split("/")[0];
+        usedPackages.add(packageName);
+      }
       const key = headlessImport.key;
       const part = {
         key,
@@ -208,24 +265,737 @@ async function loadPageParts(vite, route, pagesBase, jayRollupConfig) {
       };
       parts.push(part);
     }
-    return parts;
+    return {
+      parts,
+      serverTrackByMap: jayHtml.serverTrackByMap,
+      clientTrackByMap: jayHtml.clientTrackByMap,
+      usedPackages
+    };
+  });
+}
+class ActionRegistry {
+  constructor() {
+    __publicField(this, "actions", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Registers an action with the registry.
+   *
+   * @param action - The JayAction to register (created via makeJayAction/makeJayQuery)
+   */
+  register(action) {
+    const entry = {
+      actionName: action.actionName,
+      method: action.method,
+      cacheOptions: action.cacheOptions,
+      services: action.services,
+      handler: action.handler
+    };
+    this.actions.set(action.actionName, entry);
+  }
+  /**
+   * Retrieves a registered action by name.
+   *
+   * @param actionName - The unique action name
+   * @returns The registered action or undefined
+   */
+  get(actionName) {
+    return this.actions.get(actionName);
+  }
+  /**
+   * Checks if an action is registered.
+   *
+   * @param actionName - The unique action name
+   * @returns true if the action is registered
+   */
+  has(actionName) {
+    return this.actions.has(actionName);
+  }
+  /**
+   * Gets all registered action names.
+   *
+   * @returns Array of registered action names
+   */
+  getNames() {
+    return Array.from(this.actions.keys());
+  }
+  /**
+   * Clears all registered actions.
+   */
+  clear() {
+    this.actions.clear();
+  }
+  /**
+   * Executes a registered action with the given input.
+   * Resolves services and calls the handler.
+   *
+   * @param actionName - The action to execute
+   * @param input - The input data for the action
+   * @returns The action result or error
+   */
+  async execute(actionName, input) {
+    const action = this.actions.get(actionName);
+    if (!action) {
+      return {
+        success: false,
+        error: {
+          code: "ACTION_NOT_FOUND",
+          message: `Action '${actionName}' is not registered`,
+          isActionError: false
+        }
+      };
+    }
+    try {
+      const services = resolveServices(action.services);
+      const result = await action.handler(input, ...services);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && "message" in error) {
+        const actionError = error;
+        if (actionError.name === "ActionError") {
+          return {
+            success: false,
+            error: {
+              code: actionError.code,
+              message: actionError.message,
+              isActionError: true
+            }
+          };
+        }
+      }
+      const message = error instanceof Error ? error.message : "Unknown error occurred";
+      return {
+        success: false,
+        error: {
+          code: "INTERNAL_ERROR",
+          message,
+          isActionError: false
+        }
+      };
+    }
+  }
+  /**
+   * Gets the cache headers for an action (if applicable).
+   *
+   * @param actionName - The action name
+   * @returns Cache-Control header value or undefined
+   */
+  getCacheHeaders(actionName) {
+    const action = this.actions.get(actionName);
+    if (!action || action.method !== "GET" || !action.cacheOptions) {
+      return void 0;
+    }
+    const { maxAge, staleWhileRevalidate } = action.cacheOptions;
+    const parts = [];
+    if (maxAge !== void 0) {
+      parts.push(`max-age=${maxAge}`);
+    }
+    if (staleWhileRevalidate !== void 0) {
+      parts.push(`stale-while-revalidate=${staleWhileRevalidate}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : void 0;
+  }
+}
+const actionRegistry = new ActionRegistry();
+function registerAction(action) {
+  actionRegistry.register(action);
+}
+function getRegisteredAction(actionName) {
+  return actionRegistry.get(actionName);
+}
+function hasAction(actionName) {
+  return actionRegistry.has(actionName);
+}
+function getRegisteredActionNames() {
+  return actionRegistry.getNames();
+}
+function clearActionRegistry() {
+  actionRegistry.clear();
+}
+async function executeAction(actionName, input) {
+  return actionRegistry.execute(actionName, input);
+}
+function getActionCacheHeaders(actionName) {
+  return actionRegistry.getCacheHeaders(actionName);
+}
+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;
+};
+class JayAtomicType {
+  constructor(name) {
+    __publicField2(this, "kind", 0);
+    this.name = name;
+  }
+}
+new JayAtomicType("string");
+new JayAtomicType("number");
+new JayAtomicType("boolean");
+new JayAtomicType("Date");
+new JayAtomicType("Unknown");
+class JayObjectType {
+  constructor(name, props) {
+    __publicField2(this, "kind", 8);
+    this.name = name;
+    this.props = props;
+  }
+}
+new JayObjectType("Error", {
+  message: new JayAtomicType("string"),
+  name: new JayAtomicType("string"),
+  stack: new JayAtomicType("string")
+});
+var RuntimeMode = /* @__PURE__ */ ((RuntimeMode2) => {
+  RuntimeMode2["MainTrusted"] = "mainTrusted";
+  RuntimeMode2["MainSandbox"] = "mainSandbox";
+  RuntimeMode2["WorkerTrusted"] = "workerTrusted";
+  RuntimeMode2["WorkerSandbox"] = "workerSandbox";
+  return RuntimeMode2;
+})(RuntimeMode || {});
+const TS_EXTENSION = ".ts";
+const JAY_QUERY_PREFIX = "?jay-";
+[
+  // Build environments
+  {
+    pattern: `${JAY_QUERY_PREFIX}${"client"}`,
+    buildEnv: "client"
+    /* Client */
+  },
+  {
+    pattern: `${JAY_QUERY_PREFIX}${"server"}`,
+    buildEnv: "server"
+    /* Server */
+  },
+  // Runtime modes (with .ts suffix)
+  {
+    pattern: `${JAY_QUERY_PREFIX}${RuntimeMode.MainSandbox}${TS_EXTENSION}`,
+    runtimeMode: RuntimeMode.MainSandbox
+  },
+  {
+    pattern: `${JAY_QUERY_PREFIX}${RuntimeMode.WorkerTrusted}${TS_EXTENSION}`,
+    runtimeMode: RuntimeMode.WorkerTrusted
+  },
+  {
+    pattern: `${JAY_QUERY_PREFIX}${RuntimeMode.WorkerSandbox}${TS_EXTENSION}`,
+    runtimeMode: RuntimeMode.WorkerSandbox
+  },
+  // Runtime modes (without .ts suffix)
+  {
+    pattern: `${JAY_QUERY_PREFIX}${RuntimeMode.MainSandbox}`,
+    runtimeMode: RuntimeMode.MainSandbox
+  },
+  {
+    pattern: `${JAY_QUERY_PREFIX}${RuntimeMode.WorkerTrusted}`,
+    runtimeMode: RuntimeMode.WorkerTrusted
+  },
+  {
+    pattern: `${JAY_QUERY_PREFIX}${RuntimeMode.WorkerSandbox}`,
+    runtimeMode: RuntimeMode.WorkerSandbox
+  }
+];
+createRequire(import.meta.url);
+function loadPluginManifest(pluginDir) {
+  const pluginYamlPath = path$1.join(pluginDir, "plugin.yaml");
+  if (!fs$2.existsSync(pluginYamlPath)) {
+    return null;
+  }
+  try {
+    const yamlContent = fs$2.readFileSync(pluginYamlPath, "utf-8");
+    return YAML.parse(yamlContent);
+  } catch (error) {
+    return null;
+  }
+}
+const s = createRequire(import.meta.url), e = s("typescript");
+new Proxy(e, {
+  get(t, r) {
+    return t[r];
+  }
+});
+const require$1 = createRequire$1(import.meta.url);
+async function discoverAndRegisterActions(options) {
+  const {
+    projectRoot,
+    actionsDir = "src/actions",
+    registry = actionRegistry,
+    verbose = false,
+    viteServer
+  } = options;
+  const result = {
+    actionCount: 0,
+    actionNames: [],
+    scannedFiles: []
+  };
+  const actionsPath = path.resolve(projectRoot, actionsDir);
+  if (!fs.existsSync(actionsPath)) {
+    if (verbose) {
+      console.log(`[Actions] No actions directory found at ${actionsPath}`);
+    }
+    return result;
+  }
+  const actionFiles = await findActionFiles(actionsPath);
+  if (verbose) {
+    console.log(`[Actions] Found ${actionFiles.length} action file(s)`);
+  }
+  for (const filePath of actionFiles) {
+    result.scannedFiles.push(filePath);
+    try {
+      let module;
+      if (viteServer) {
+        module = await viteServer.ssrLoadModule(filePath);
+      } else {
+        module = await import(filePath);
+      }
+      for (const [exportName, exportValue] of Object.entries(module)) {
+        if (isJayAction(exportValue)) {
+          registry.register(exportValue);
+          result.actionNames.push(exportValue.actionName);
+          result.actionCount++;
+          if (verbose) {
+            console.log(`[Actions] Registered: ${exportValue.actionName}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`[Actions] Failed to import ${filePath}:`, error);
+    }
+  }
+  return result;
+}
+async function findActionFiles(dir) {
+  const files = [];
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const subFiles = await findActionFiles(fullPath);
+      files.push(...subFiles);
+    } else if (entry.isFile() && entry.name.endsWith(".actions.ts")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function discoverAllPluginActions(options) {
+  const { projectRoot, registry = actionRegistry, verbose = false, viteServer } = options;
+  const allActions = [];
+  const localPluginsPath = path.join(projectRoot, "src/plugins");
+  if (fs.existsSync(localPluginsPath)) {
+    const pluginDirs = await fs.promises.readdir(localPluginsPath, { withFileTypes: true });
+    for (const entry of pluginDirs) {
+      if (entry.isDirectory()) {
+        const pluginPath = path.join(localPluginsPath, entry.name);
+        const actions = await discoverPluginActions(
+          pluginPath,
+          projectRoot,
+          registry,
+          verbose,
+          viteServer
+        );
+        allActions.push(...actions);
+      }
+    }
+  }
+  const npmActions = await discoverNpmPluginActions(projectRoot, registry, verbose, viteServer);
+  allActions.push(...npmActions);
+  return allActions;
+}
+async function discoverNpmPluginActions(projectRoot, registry, verbose, viteServer) {
+  const allActions = [];
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return allActions;
+  }
+  try {
+    const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, "utf-8"));
+    const dependencies = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    for (const packageName of Object.keys(dependencies)) {
+      try {
+        const pluginYamlPath = tryResolvePluginYaml(packageName, projectRoot);
+        if (!pluginYamlPath) {
+          continue;
+        }
+        const pluginDir = path.dirname(pluginYamlPath);
+        const pluginConfig = loadPluginManifest(pluginDir);
+        if (!pluginConfig || !pluginConfig.actions || !Array.isArray(pluginConfig.actions)) {
+          continue;
+        }
+        if (verbose) {
+          console.log(
+            `[Actions] NPM plugin "${packageName}" declares actions:`,
+            pluginConfig.actions
+          );
+        }
+        const actions = await registerNpmPluginActions(
+          packageName,
+          pluginConfig,
+          registry,
+          verbose,
+          viteServer
+        );
+        allActions.push(...actions);
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error("[Actions] Failed to read project package.json:", error);
+  }
+  return allActions;
+}
+function tryResolvePluginYaml(packageName, projectRoot) {
+  try {
+    return require$1.resolve(`${packageName}/plugin.yaml`, {
+      paths: [projectRoot]
+    });
+  } catch {
+    return null;
+  }
+}
+async function registerNpmPluginActions(packageName, pluginConfig, registry, verbose, viteServer) {
+  const registeredActions = [];
+  try {
+    let pluginModule;
+    if (viteServer) {
+      pluginModule = await viteServer.ssrLoadModule(packageName);
+    } else {
+      pluginModule = await import(packageName);
+    }
+    for (const actionName of pluginConfig.actions) {
+      const actionExport = pluginModule[actionName];
+      if (actionExport && isJayAction(actionExport)) {
+        registry.register(actionExport);
+        registeredActions.push(actionExport.actionName);
+        if (verbose) {
+          console.log(
+            `[Actions] Registered NPM plugin action: ${actionExport.actionName}`
+          );
+        }
+      } else {
+        console.warn(
+          `[Actions] NPM plugin "${packageName}" declares action "${actionName}" but it's not exported or not a JayAction`
+        );
+      }
+    }
+  } catch (importError) {
+    console.error(`[Actions] Failed to import NPM plugin "${packageName}":`, importError);
+  }
+  return registeredActions;
+}
+async function discoverPluginActions(pluginPath, projectRoot, registry = actionRegistry, verbose = false, viteServer) {
+  const pluginConfig = loadPluginManifest(pluginPath);
+  if (!pluginConfig) {
+    return [];
+  }
+  if (!pluginConfig.actions || !Array.isArray(pluginConfig.actions)) {
+    return [];
+  }
+  const registeredActions = [];
+  const pluginName = pluginConfig.name || path.basename(pluginPath);
+  if (verbose) {
+    console.log(`[Actions] Plugin "${pluginName}" declares actions:`, pluginConfig.actions);
+  }
+  let modulePath = pluginConfig.module ? path.join(pluginPath, pluginConfig.module) : path.join(pluginPath, "index.ts");
+  if (!fs.existsSync(modulePath)) {
+    const tsPath = modulePath + ".ts";
+    const jsPath = modulePath + ".js";
+    if (fs.existsSync(tsPath)) {
+      modulePath = tsPath;
+    } else if (fs.existsSync(jsPath)) {
+      modulePath = jsPath;
+    } else {
+      console.warn(`[Actions] Plugin "${pluginName}" module not found at ${modulePath}`);
+      return [];
+    }
+  }
+  try {
+    let pluginModule;
+    if (viteServer) {
+      pluginModule = await viteServer.ssrLoadModule(modulePath);
+    } else {
+      pluginModule = await import(modulePath);
+    }
+    for (const actionName of pluginConfig.actions) {
+      const actionExport = pluginModule[actionName];
+      if (actionExport && isJayAction(actionExport)) {
+        registry.register(actionExport);
+        registeredActions.push(actionExport.actionName);
+        if (verbose) {
+          console.log(
+            `[Actions] Registered plugin action: ${actionExport.actionName}`
+          );
+        }
+      } else {
+        console.warn(
+          `[Actions] Plugin "${pluginName}" declares action "${actionName}" but it's not exported or not a JayAction`
+        );
+      }
+    }
+  } catch (importError) {
+    console.error(`[Actions] Failed to import plugin module at ${modulePath}:`, importError);
+  }
+  return registeredActions;
+}
+const require2 = createRequire$1(import.meta.url);
+async function discoverPluginsWithInit(options) {
+  const { projectRoot, verbose = false } = options;
+  const plugins = [];
+  const localPluginsPath = path.join(projectRoot, "src/plugins");
+  if (fs.existsSync(localPluginsPath)) {
+    try {
+      const entries = fs.readdirSync(localPluginsPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const pluginPath = path.join(localPluginsPath, entry.name);
+        const manifest = loadPluginManifest(pluginPath);
+        if (!manifest)
+          continue;
+        const initConfig = resolvePluginInit(pluginPath, manifest.init, true);
+        if (!initConfig)
+          continue;
+        const dependencies = await getPackageDependencies(pluginPath);
+        plugins.push({
+          name: manifest.name || entry.name,
+          pluginPath,
+          packageName: pluginPath,
+          // For local, use path
+          isLocal: true,
+          initModule: initConfig.module,
+          initExport: initConfig.export,
+          dependencies
+        });
+        if (verbose) {
+          console.log(
+            `[PluginInit] Found local plugin with init: ${manifest.name || entry.name}`
+          );
+        }
+      }
+    } catch (error) {
+      console.warn(`[PluginInit] Failed to scan local plugins: ${error}`);
+    }
+  }
+  const projectPackageJsonPath = path.join(projectRoot, "package.json");
+  if (fs.existsSync(projectPackageJsonPath)) {
+    try {
+      const projectPackageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, "utf-8"));
+      const allDeps = {
+        ...projectPackageJson.dependencies,
+        ...projectPackageJson.devDependencies
+      };
+      for (const depName of Object.keys(allDeps)) {
+        let pluginYamlPath;
+        try {
+          pluginYamlPath = require2.resolve(`${depName}/plugin.yaml`, {
+            paths: [projectRoot]
+          });
+        } catch {
+          continue;
+        }
+        const pluginPath = path.dirname(pluginYamlPath);
+        const manifest = loadPluginManifest(pluginPath);
+        if (!manifest)
+          continue;
+        const initConfig = resolvePluginInit(pluginPath, manifest.init, false);
+        if (!initConfig)
+          continue;
+        const dependencies = await getPackageDependencies(pluginPath);
+        plugins.push({
+          name: manifest.name || depName,
+          pluginPath,
+          packageName: depName,
+          isLocal: false,
+          initModule: initConfig.module,
+          initExport: initConfig.export,
+          dependencies
+        });
+        if (verbose) {
+          console.log(`[PluginInit] Found NPM plugin with init: ${depName}`);
+        }
+      }
+    } catch (error) {
+      console.warn(`[PluginInit] Failed to scan NPM plugins: ${error}`);
+    }
+  }
+  return plugins;
+}
+function resolvePluginInit(pluginPath, initConfig, isLocal) {
+  const defaultExport = "init";
+  if (isLocal) {
+    const initPaths = [
+      path.join(pluginPath, "lib/init.ts"),
+      path.join(pluginPath, "lib/init.js"),
+      path.join(pluginPath, "init.ts"),
+      path.join(pluginPath, "init.js")
+    ];
+    for (const initPath of initPaths) {
+      if (fs.existsSync(initPath)) {
+        const relativePath = path.relative(pluginPath, initPath);
+        const modulePath = relativePath.replace(/\.(ts|js)$/, "");
+        const exportName = typeof initConfig === "string" ? initConfig : defaultExport;
+        return { module: modulePath, export: exportName };
+      }
+    }
+    return null;
+  }
+  const packageJsonPath = path.join(pluginPath, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const hasMain = packageJson.main || packageJson.exports;
+    if (!hasMain && !initConfig) {
+      return null;
+    }
+    const exportName = typeof initConfig === "string" ? initConfig : defaultExport;
+    return { module: "", export: exportName };
+  } catch {
+    return null;
+  }
+}
+async function getPackageDependencies(pluginPath) {
+  const packageJsonPath = path.join(pluginPath, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return [];
+  }
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return Object.keys(packageJson.dependencies || {});
+  } catch {
+    return [];
+  }
+}
+function sortPluginsByDependencies(plugins) {
+  const pluginNames = new Set(plugins.map((p) => p.packageName));
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(plugin) {
+    if (visited.has(plugin.packageName))
+      return;
+    if (visiting.has(plugin.packageName)) {
+      console.warn(`[PluginInit] Circular dependency detected for ${plugin.name}`);
+      return;
+    }
+    visiting.add(plugin.packageName);
+    for (const dep of plugin.dependencies) {
+      if (pluginNames.has(dep)) {
+        const depPlugin = plugins.find((p) => p.packageName === dep);
+        if (depPlugin) {
+          visit(depPlugin);
+        }
+      }
+    }
+    visiting.delete(plugin.packageName);
+    visited.add(plugin.packageName);
+    sorted.push(plugin);
+  }
+  for (const plugin of plugins) {
+    visit(plugin);
+  }
+  return sorted;
+}
+async function executePluginServerInits(plugins, viteServer, verbose = false) {
+  for (const plugin of plugins) {
+    try {
+      let modulePath;
+      if (plugin.isLocal) {
+        modulePath = path.join(plugin.pluginPath, plugin.initModule);
+      } else if (plugin.initModule) {
+        modulePath = `${plugin.packageName}/${plugin.initModule}`;
+      } else {
+        modulePath = plugin.packageName;
+      }
+      let pluginModule;
+      if (viteServer) {
+        pluginModule = await viteServer.ssrLoadModule(modulePath);
+      } else {
+        pluginModule = await import(modulePath);
+      }
+      const jayInit = pluginModule[plugin.initExport];
+      if (!jayInit || jayInit.__brand !== "JayInit") {
+        console.warn(
+          `[PluginInit] Plugin "${plugin.name}" init module doesn't export a valid JayInit at "${plugin.initExport}"`
+        );
+        continue;
+      }
+      if (typeof jayInit._serverInit === "function") {
+        if (verbose) {
+          console.log(`[DevServer] Running server init: ${plugin.name}`);
+        }
+        const clientData = await jayInit._serverInit();
+        if (clientData !== void 0 && clientData !== null) {
+          setClientInitData(plugin.name, clientData);
+        }
+      }
+    } catch (error) {
+      console.error(
+        `[PluginInit] Failed to execute server init for "${plugin.name}":`,
+        error
+      );
+    }
+  }
+}
+function preparePluginClientInits(plugins) {
+  return plugins.map((plugin) => {
+    let importPath;
+    if (plugin.isLocal) {
+      importPath = path.join(plugin.pluginPath, plugin.initModule);
+    } else if (plugin.initModule) {
+      importPath = `${plugin.packageName}/${plugin.initModule}`;
+    } else {
+      importPath = `${plugin.packageName}/client`;
+    }
+    return {
+      name: plugin.name,
+      importPath,
+      initExport: plugin.initExport
+    };
   });
 }
 export {
+  ActionRegistry,
   DevSlowlyChangingPhase,
+  actionRegistry,
+  clearActionRegistry,
+  clearClientInitData,
   clearLifecycleCallbacks,
   clearServiceRegistry,
+  discoverAllPluginActions,
+  discoverAndRegisterActions,
+  discoverPluginActions,
+  discoverPluginsWithInit,
+  executeAction,
+  executePluginServerInits,
   generateClientScript,
+  getActionCacheHeaders,
+  getClientInitData,
+  getClientInitDataForKey,
+  getRegisteredAction,
+  getRegisteredActionNames,
   getService,
+  hasAction,
   hasService,
   loadPageParts,
   onInit,
   onShutdown,
+  preparePluginClientInits,
+  registerAction,
   registerService,
   renderFastChangingData,
   resolveServices,
   runInitCallbacks,
   runLoadParams,
   runShutdownCallbacks,
-  runSlowlyChangingRender
+  runSlowlyChangingRender,
+  setClientInitData,
+  sortPluginsByDependencies
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/stack-server-runtime",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.mts",
@@ -26,16 +26,18 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/compiler-jay-html": "^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-route-scanner": "^0.9.0"
+    "@jay-framework/compiler-jay-html": "^0.10.0",
+    "@jay-framework/compiler-shared": "^0.10.0",
+    "@jay-framework/component": "^0.10.0",
+    "@jay-framework/fullstack-component": "^0.10.0",
+    "@jay-framework/runtime": "^0.10.0",
+    "@jay-framework/stack-route-scanner": "^0.10.0",
+    "@jay-framework/view-state-merge": "^0.10.0"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.9.0",
-    "@jay-framework/jay-cli": "^0.9.0",
-    "@jay-framework/stack-client-runtime": "^0.9.0",
+    "@jay-framework/dev-environment": "^0.10.0",
+    "@jay-framework/jay-cli": "^0.10.0",
+    "@jay-framework/stack-client-runtime": "^0.10.0",
     "@types/express": "^5.0.2",
     "@types/node": "^22.15.21",
     "nodemon": "^3.0.3",