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

package/dist/index.js

@@ -1,8 +1,23 @@
-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";
+import crypto from "node:crypto";
 const serviceRegistry = /* @__PURE__ */ new Map();
 function registerService(marker, service) {
   serviceRegistry.set(marker, service);
@@ -50,6 +65,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 +112,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 +145,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 +157,60 @@ 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 = [], 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")}
         ]` : "[]";
+  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}
+` : "";
+  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>
@@ -147,38 +222,40 @@ ${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)};
+${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);
+${automationWrap}
     <\/script>
   </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, 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 + "?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'`,
-      clientPart: `{comp: page.comp, contextMarkers: []}`
+      clientImport: `import {page} from '${route.compPath}'`,
+      clientPart: `{comp: page.comp, contextMarkers: page.contexts || []}`
     });
   }
-  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 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(
     jayHtmlSource,
     fileName,
@@ -186,46 +263,926 @@ 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,
         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);
     }
-    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);
+}
+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) => {
+  __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 visitedPackages = /* @__PURE__ */ new Set();
+  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
+        });
+        visitedPackages.add(pluginPath);
+        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 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`, {
+            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}`);
+        }
+        for (const transitiveDep of dependencies) {
+          if (!visitedPackages.has(transitiveDep)) {
+            packagesToCheck.push(transitiveDep);
+          }
+        }
+      }
+    } 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
+    };
   });
 }
+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,
   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
+  runSlowlyChangingRender,
+  setClientInitData,
+  sortPluginsByDependencies
 };