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

package/dist/index.d.ts

@@ -21,7 +21,15 @@ interface LoadedPageParts {
     /** 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 LoadPagePartsOptions {
+    /**
+     * Path to pre-rendered jay-html file to use instead of the original.
+     * When provided, this file (with slow-phase bindings resolved) is read.
+     * Import resolution still uses the original jay-html's directory.
+     */
+    preRenderedPath?: string;
+}
+declare function loadPageParts(vite: ViteDevServer, route: JayRoute, pagesBase: string, projectBase: string, jayRollupConfig: JayRollupConfig, options?: LoadPagePartsOptions): Promise<WithValidations<LoadedPageParts>>;
 
 interface SlowlyChangingPhase {
     runSlowlyForPage(pageParams: object, pageProps: PageProps, parts: Array<DevServerPagePart>): Promise<AnySlowlyRenderResult>;
@@ -183,6 +191,33 @@ declare function executeAction<T = any>(actionName: string, input: unknown): Pro
  * @deprecated Use actionRegistry.getCacheHeaders() instead
  */
 declare function getActionCacheHeaders(actionName: string): string | undefined;
+/**
+ * Executes an action directly with proper service injection.
+ * Use this when calling actions from backend code (e.g., render phases).
+ *
+ * Unlike calling the action directly (which bypasses service injection),
+ * this function resolves services and calls the handler correctly.
+ *
+ * @param action - The JayAction to execute (with definition metadata)
+ * @param input - The input data for the action
+ * @returns The action result (throws on error)
+ *
+ * @example
+ * ```typescript
+ * // In a render phase
+ * import { runAction } from '@jay-framework/stack-server-runtime';
+ * import { searchProducts } from '../actions/stores-actions';
+ *
+ * async function renderFastChanging(props, slowCarryForward, wixStores) {
+ *     // ✅ Correct - services are injected
+ *     const result = await runAction(searchProducts, { query: '', pageSize: 12 });
+ *
+ *     // ❌ Wrong - services are NOT injected (passes empty array)
+ *     // const result = await searchProducts({ query: '', pageSize: 12 });
+ * }
+ * ```
+ */
+declare function runAction<I, O>(action: JayAction<I, O> & JayActionDefinition<I, O, any[]>, input: I): Promise<O>;
 
 /**
  * Action discovery and auto-registration for Jay Stack.
@@ -332,6 +367,7 @@ interface PluginInitDiscoveryOptions {
  * in `plugin.yaml` via the `init` property.
  *
  * Scans both local plugins (src/plugins/) and NPM plugins (node_modules/).
+ * Also discovers transitive plugin dependencies (plugins that depend on other plugins).
  */
 declare function discoverPluginsWithInit(options: PluginInitDiscoveryOptions): Promise<PluginWithInit[]>;
 /**
@@ -383,7 +419,20 @@ interface ProjectClientInitInfo {
     /** 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;
+/**
+ * Options for client script generation.
+ */
+interface GenerateClientScriptOptions {
+    /** Enable automation integration (default: true in dev mode) */
+    enableAutomation?: boolean;
+    /**
+     * Slow ViewState that was baked into the pre-rendered jay-html.
+     * When provided, this is merged with fastViewState for the automation API
+     * so that AI/automation tools can see the complete page state.
+     */
+    slowViewState?: object;
+}
+declare function generateClientScript(defaultViewState: object, fastCarryForward: object, parts: DevServerPagePart[], jayHtmlPath: string, trackByMap?: TrackByMap, clientInitData?: Record<string, Record<string, any>>, projectInit?: ProjectClientInitInfo, pluginInits?: PluginClientInitInfo[], options?: GenerateClientScriptOptions): string;
 
 /**
  * Service registry for Jay Stack server-side dependency injection.
@@ -549,4 +598,83 @@ declare function getClientInitDataForKey(key: string): Record<string, any>;
  */
 declare function clearClientInitData(): void;
 
-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 };
+/**
+ * Cache entry for pre-rendered jay-html
+ */
+interface SlowRenderCacheEntry {
+    /** Path to the pre-rendered jay-html file on disk */
+    preRenderedPath: string;
+    /** Slow ViewState that was baked into the jay-html */
+    slowViewState: object;
+    /** CarryForward data from slow rendering (passed to fast phase) */
+    carryForward: object;
+    /** Timestamp when this entry was created */
+    createdAt: number;
+    /** Source jay-html path (for debugging) */
+    sourcePath: string;
+}
+/**
+ * Cache for pre-rendered jay-html files.
+ *
+ * This cache stores jay-html content that has been transformed with slow-phase
+ * data baked in. The key insight is that since slow ViewState is embedded directly
+ * into the jay-html, we don't need to pass it to the client - only fast and
+ * interactive ViewState is sent.
+ *
+ * Pre-rendered files are written to disk so Vite can pick them up and compile them.
+ */
+declare class SlowRenderCache {
+    private cache;
+    private pathToKeys;
+    private readonly cacheDir;
+    private readonly pagesRoot;
+    /**
+     * @param cacheDir - Directory where pre-rendered jay-html files are stored
+     * @param pagesRoot - Root directory of the pages (for relative path calculation)
+     */
+    constructor(cacheDir: string, pagesRoot: string);
+    /**
+     * Get a cached pre-rendered jay-html entry
+     */
+    get(jayHtmlPath: string, params: Record<string, string>): SlowRenderCacheEntry | undefined;
+    /**
+     * Store a pre-rendered jay-html entry in the cache.
+     * Writes the pre-rendered content to disk and stores metadata in memory.
+     */
+    set(jayHtmlPath: string, params: Record<string, string>, preRenderedJayHtml: string, slowViewState: object, carryForward: object): Promise<string>;
+    /**
+     * Check if a pre-rendered entry exists for the given path and params
+     */
+    has(jayHtmlPath: string, params: Record<string, string>): boolean;
+    /**
+     * Invalidate all cached entries for a given jay-html source path.
+     * This is called when the source file changes.
+     * Also deletes the cached files from disk.
+     */
+    invalidate(jayHtmlPath: string): Promise<void>;
+    /**
+     * Invalidate all entries that depend on a changed file.
+     * The changedPath could be:
+     * - A jay-html file itself
+     * - A component file (page.ts)
+     * - Any other dependency
+     *
+     * @param changedPath - Absolute path to the changed file
+     * @param resolveDependencies - Optional function to resolve which jay-html files depend on the changed file
+     */
+    invalidateByDependency(changedPath: string, resolveDependencies?: (changedPath: string) => string[]): Promise<void>;
+    /**
+     * Clear all cached entries and delete cached files from disk
+     */
+    clear(): Promise<void>;
+    /**
+     * Get the number of cached entries
+     */
+    get size(): number;
+    /**
+     * Get all cached jay-html paths (for debugging/monitoring)
+     */
+    getCachedPaths(): string[];
+}
+
+export { type ActionDiscoveryOptions, type ActionDiscoveryResult, type ActionErrorResponse, type ActionExecutionResult, ActionRegistry, type DevServerPagePart, DevSlowlyChangingPhase, type GenerateClientScriptOptions, type LoadedPageParts, type PluginActionDiscoveryOptions, type PluginClientInitInfo, type PluginInitDiscoveryOptions, type PluginWithInit, type ProjectClientInitInfo, type RegisteredAction, SlowRenderCache, type SlowRenderCacheEntry, 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, runAction, runInitCallbacks, runLoadParams, runShutdownCallbacks, runSlowlyChangingRender, setClientInitData, sortPluginsByDependencies };

package/dist/index.js

@@ -17,6 +17,7 @@ import "js-beautify";
 import fs$2 from "fs";
 import path$1 from "path";
 import YAML from "yaml";
+import crypto from "node:crypto";
 const serviceRegistry = /* @__PURE__ */ new Map();
 function registerService(marker, service) {
   serviceRegistry.set(marker, service);
@@ -158,7 +159,9 @@ async function renderFastChangingData(pageParams, pageProps, carryForward, parts
   }
   return Promise.resolve(phaseOutput(fastViewState, fastCarryForward));
 }
-function generateClientScript(defaultViewState, fastCarryForward, parts, jayHtmlPath, trackByMap = {}, clientInitData2 = {}, projectInit, pluginInits = []) {
+function generateClientScript(defaultViewState, fastCarryForward, parts, jayHtmlPath, trackByMap = {}, clientInitData2 = {}, projectInit, pluginInits = [], options = {}) {
+  const { enableAutomation = true, slowViewState } = options;
+  const hasSlowViewState = slowViewState && Object.keys(slowViewState).length > 0;
   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")}
@@ -187,6 +190,27 @@ ${parts.map((part) => "        " + part.clientPart).join(",\n")}
       // Project client initialization
       ${projectInitCall}
 ` : "";
+  const automationImport = enableAutomation ? hasSlowViewState ? `import { wrapWithAutomation, AUTOMATION_CONTEXT } from "@jay-framework/runtime-automation";
+      import { registerGlobalContext } from "@jay-framework/runtime";
+      import { deepMergeViewStates } from "@jay-framework/view-state-merge";` : `import { wrapWithAutomation, AUTOMATION_CONTEXT } from "@jay-framework/runtime-automation";
+      import { registerGlobalContext } from "@jay-framework/runtime";` : "";
+  const slowViewStateDecl = enableAutomation && hasSlowViewState ? `const slowViewState = ${JSON.stringify(slowViewState)};` : "";
+  const automationWrap = enableAutomation ? hasSlowViewState ? `
+      // Wrap with automation for dev tooling
+      // Deep merge slow+fast ViewState so automation can see full page state
+      const fullViewState = deepMergeViewStates(slowViewState, {...viewState, ...fastCarryForward}, trackByMap);
+      const wrapped = wrapWithAutomation(instance, { initialViewState: fullViewState, trackByMap });
+      registerGlobalContext(AUTOMATION_CONTEXT, wrapped.automation);
+      window.__jay = window.__jay || {};
+      window.__jay.automation = wrapped.automation;
+      target.appendChild(wrapped.element.dom);` : `
+      // Wrap with automation for dev tooling
+      const wrapped = wrapWithAutomation(instance);
+      registerGlobalContext(AUTOMATION_CONTEXT, wrapped.automation);
+      window.__jay = window.__jay || {};
+      window.__jay.automation = wrapped.automation;
+      target.appendChild(wrapped.element.dom);` : `
+      target.appendChild(instance.element.dom);`;
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -198,10 +222,11 @@ ${parts.map((part) => "        " + part.clientPart).join(",\n")}
     <div id="target"></div>
     <script type="module">
       import {makeCompositeJayComponent} from "@jay-framework/stack-client-runtime";
+      ${automationImport}
       ${pluginClientInitImports}
       ${projectInitImport}
       import { render } from '${jayHtmlPath}';
-      ${imports}
+      ${imports}${slowViewStateDecl}
       const viewState = ${JSON.stringify(defaultViewState)};
       const fastCarryForward = ${JSON.stringify(fastCarryForward)};
       const trackByMap = ${JSON.stringify(trackByMap)};
@@ -210,25 +235,25 @@ ${clientInitExecution}
       const pageComp = makeCompositeJayComponent(render, viewState, fastCarryForward, ${compositeParts}, trackByMap)
 
       const instance = pageComp({...viewState, ...fastCarryForward})
-      target.appendChild(instance.element.dom);
+${automationWrap}
     <\/script>
   </body>
 </html>`;
 }
 const require$2 = createRequire(import.meta.url);
-async function loadPageParts(vite, route, pagesBase, projectBase, jayRollupConfig) {
+async function loadPageParts(vite, route, pagesBase, projectBase, jayRollupConfig, options) {
   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)).page;
     parts.push({
       compDefinition: pageComponent,
-      // Client import uses client-only code (server code stripped)
       clientImport: `import {page} from '${route.compPath}'`,
-      clientPart: `{comp: page.comp, contextMarkers: []}`
+      clientPart: `{comp: page.comp, contextMarkers: page.contexts || []}`
     });
   }
-  const jayHtmlSource = (await fs$1.readFile(route.jayHtmlPath)).toString();
+  const jayHtmlFilePath = options?.preRenderedPath ?? route.jayHtmlPath;
+  const jayHtmlSource = (await fs$1.readFile(jayHtmlFilePath)).toString();
   const fileName = path__default.basename(route.jayHtmlPath);
   const dirName = path__default.dirname(route.jayHtmlPath);
   const jayHtmlWithValidations = await parseJayFile(
@@ -261,7 +286,7 @@ async function loadPageParts(vite, route, pagesBase, projectBase, jayRollupConfi
         key,
         compDefinition,
         clientImport: `import {${name}} from '${clientModuleImport}'`,
-        clientPart: `{comp: ${name}.comp, contextMarkers: [], key: '${headlessImport.key}'}`
+        clientPart: `{comp: ${name}.comp, contextMarkers: ${name}.contexts || [], key: '${headlessImport.key}'}`
       };
       parts.push(part);
     }
@@ -420,6 +445,10 @@ async function executeAction(actionName, input) {
 function getActionCacheHeaders(actionName) {
   return actionRegistry.getCacheHeaders(actionName);
 }
+async function runAction(action, input) {
+  const services = resolveServices(action.services);
+  return action.handler(input, ...services);
+}
 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) => {
@@ -747,6 +776,7 @@ const require2 = createRequire$1(import.meta.url);
 async function discoverPluginsWithInit(options) {
   const { projectRoot, verbose = false } = options;
   const plugins = [];
+  const visitedPackages = /* @__PURE__ */ new Set();
   const localPluginsPath = path.join(projectRoot, "src/plugins");
   if (fs.existsSync(localPluginsPath)) {
     try {
@@ -772,6 +802,7 @@ async function discoverPluginsWithInit(options) {
           initExport: initConfig.export,
           dependencies
         });
+        visitedPackages.add(pluginPath);
         if (verbose) {
           console.log(
             `[PluginInit] Found local plugin with init: ${manifest.name || entry.name}`
@@ -786,11 +817,13 @@ async function discoverPluginsWithInit(options) {
   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)) {
+      const initialDeps = Object.keys(projectPackageJson.dependencies || {});
+      const packagesToCheck = [...initialDeps];
+      while (packagesToCheck.length > 0) {
+        const depName = packagesToCheck.shift();
+        if (visitedPackages.has(depName))
+          continue;
+        visitedPackages.add(depName);
         let pluginYamlPath;
         try {
           pluginYamlPath = require2.resolve(`${depName}/plugin.yaml`, {
@@ -819,6 +852,11 @@ async function discoverPluginsWithInit(options) {
         if (verbose) {
           console.log(`[PluginInit] Found NPM plugin with init: ${depName}`);
         }
+        for (const transitiveDep of dependencies) {
+          if (!visitedPackages.has(transitiveDep)) {
+            packagesToCheck.push(transitiveDep);
+          }
+        }
       }
     } catch (error) {
       console.warn(`[PluginInit] Failed to scan NPM plugins: ${error}`);
@@ -961,9 +999,157 @@ function preparePluginClientInits(plugins) {
     };
   });
 }
+function makeCacheKey(jayHtmlPath, params) {
+  const sortedParams = Object.keys(params).sort().reduce(
+    (acc, key) => {
+      acc[key] = params[key];
+      return acc;
+    },
+    {}
+  );
+  return `${jayHtmlPath}:${JSON.stringify(sortedParams)}`;
+}
+function hashParams(params) {
+  const sortedParams = Object.keys(params).sort().reduce(
+    (acc, key) => {
+      acc[key] = params[key];
+      return acc;
+    },
+    {}
+  );
+  const json = JSON.stringify(sortedParams);
+  if (json === "{}")
+    return "";
+  return "_" + crypto.createHash("md5").update(json).digest("hex").substring(0, 8);
+}
+class SlowRenderCache {
+  /**
+   * @param cacheDir - Directory where pre-rendered jay-html files are stored
+   * @param pagesRoot - Root directory of the pages (for relative path calculation)
+   */
+  constructor(cacheDir, pagesRoot) {
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "pathToKeys", /* @__PURE__ */ new Map());
+    __publicField(this, "cacheDir");
+    __publicField(this, "pagesRoot");
+    this.cacheDir = cacheDir;
+    this.pagesRoot = pagesRoot;
+  }
+  /**
+   * Get a cached pre-rendered jay-html entry
+   */
+  get(jayHtmlPath, params) {
+    const key = makeCacheKey(jayHtmlPath, params);
+    return this.cache.get(key);
+  }
+  /**
+   * Store a pre-rendered jay-html entry in the cache.
+   * Writes the pre-rendered content to disk and stores metadata in memory.
+   */
+  async set(jayHtmlPath, params, preRenderedJayHtml, slowViewState, carryForward) {
+    const key = makeCacheKey(jayHtmlPath, params);
+    const relativePath = path__default.relative(this.pagesRoot, jayHtmlPath);
+    const dir = path__default.dirname(relativePath);
+    const basename = path__default.basename(relativePath, ".jay-html");
+    const paramsHash = hashParams(params);
+    const cacheFileName = `${basename}${paramsHash}.jay-html`;
+    const preRenderedPath = path__default.join(this.cacheDir, dir, cacheFileName);
+    await fs$1.mkdir(path__default.dirname(preRenderedPath), { recursive: true });
+    await fs$1.writeFile(preRenderedPath, preRenderedJayHtml, "utf-8");
+    if (!this.pathToKeys.has(jayHtmlPath)) {
+      this.pathToKeys.set(jayHtmlPath, /* @__PURE__ */ new Set());
+    }
+    this.pathToKeys.get(jayHtmlPath).add(key);
+    const entry = {
+      preRenderedPath,
+      slowViewState,
+      carryForward,
+      createdAt: Date.now(),
+      sourcePath: jayHtmlPath
+    };
+    this.cache.set(key, entry);
+    return preRenderedPath;
+  }
+  /**
+   * Check if a pre-rendered entry exists for the given path and params
+   */
+  has(jayHtmlPath, params) {
+    const key = makeCacheKey(jayHtmlPath, params);
+    return this.cache.has(key);
+  }
+  /**
+   * Invalidate all cached entries for a given jay-html source path.
+   * This is called when the source file changes.
+   * Also deletes the cached files from disk.
+   */
+  async invalidate(jayHtmlPath) {
+    const keys = this.pathToKeys.get(jayHtmlPath);
+    if (keys) {
+      for (const key of keys) {
+        const entry = this.cache.get(key);
+        if (entry) {
+          try {
+            await fs$1.unlink(entry.preRenderedPath);
+          } catch {
+          }
+        }
+        this.cache.delete(key);
+      }
+      this.pathToKeys.delete(jayHtmlPath);
+    }
+  }
+  /**
+   * Invalidate all entries that depend on a changed file.
+   * The changedPath could be:
+   * - A jay-html file itself
+   * - A component file (page.ts)
+   * - Any other dependency
+   *
+   * @param changedPath - Absolute path to the changed file
+   * @param resolveDependencies - Optional function to resolve which jay-html files depend on the changed file
+   */
+  async invalidateByDependency(changedPath, resolveDependencies) {
+    if (changedPath.endsWith(".jay-html")) {
+      await this.invalidate(changedPath);
+      return;
+    }
+    if (resolveDependencies) {
+      const dependentPaths = resolveDependencies(changedPath);
+      for (const depPath of dependentPaths) {
+        await this.invalidate(depPath);
+      }
+    }
+  }
+  /**
+   * Clear all cached entries and delete cached files from disk
+   */
+  async clear() {
+    for (const entry of this.cache.values()) {
+      try {
+        await fs$1.unlink(entry.preRenderedPath);
+      } catch {
+      }
+    }
+    this.cache.clear();
+    this.pathToKeys.clear();
+  }
+  /**
+   * Get the number of cached entries
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get all cached jay-html paths (for debugging/monitoring)
+   */
+  getCachedPaths() {
+    return Array.from(this.pathToKeys.keys());
+  }
+}
 export {
   ActionRegistry,
   DevSlowlyChangingPhase,
+  SlowRenderCache,
   actionRegistry,
   clearActionRegistry,
   clearClientInitData,
@@ -992,6 +1178,7 @@ export {
   registerService,
   renderFastChangingData,
   resolveServices,
+  runAction,
   runInitCallbacks,
   runLoadParams,
   runShutdownCallbacks,

package/package.json

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