@jay-framework/stack-server-build 0.24.2

package/dist/index.js

@@ -0,0 +1,2293 @@
+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);
+import fs$1 from "node:fs/promises";
+import * as path from "node:path";
+import path__default from "node:path";
+import { parseJayFile, JAY_IMPORT_RESOLVER, injectHeadfullFSTemplates, discoverHeadlessInstances, assignCoordinatesToJayHtml, generateServerElementFile, parseAction } from "@jay-framework/compiler-jay-html";
+import { createRequire } from "module";
+import jsBeautify from "js-beautify";
+import fs$2 from "fs";
+import path$1 from "path";
+import YAML from "yaml";
+import { serializeHeadTags, mergeHeadTags, actionRegistry, scanPlugins, resolveServices, sortPluginsByDependencies, getServiceRegistry } from "@jay-framework/stack-server-runtime";
+export * from "@jay-framework/stack-server-runtime";
+import crypto from "node:crypto";
+import { getLogger } from "@jay-framework/logger";
+import * as fs from "node:fs";
+import { createRequire as createRequire$1 } from "node:module";
+import { isJayAction, isJayStreamAction, isJayCliCommand } from "@jay-framework/fullstack-component";
+const require$3 = 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 = [];
+  const validations = [];
+  if (exists) {
+    const exportName = route.componentExport || "page";
+    const pageComponent = (await vite.ssrLoadModule(route.compPath))[exportName];
+    if (!pageComponent) {
+      validations.push(
+        `${route.compPath} does not export "${exportName}". The file exists but the expected export is missing — remove the file or add the export.`
+      );
+    } else {
+      const clientImportPath = route.componentExport ? route.compPath.replace(/index\.js$/, "index.client.js") : route.compPath;
+      parts.push({
+        compDefinition: pageComponent,
+        clientImport: `import {${exportName}} from '${clientImportPath}'`,
+        clientPart: `{comp: ${exportName}.comp, contextMarkers: ${exportName}.contexts || []}`
+      });
+    }
+  }
+  const jayHtmlFilePath = options?.preRenderedPath ?? route.jayHtmlPath;
+  const jayHtmlSource = options?.preRenderedContent ?? (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,
+    dirName,
+    {
+      relativePath: jayRollupConfig.tsConfigFilePath
+    },
+    JAY_IMPORT_RESOLVER,
+    projectBase
+  );
+  jayHtmlWithValidations.validations.push(...validations);
+  return jayHtmlWithValidations.mapAsync(async (jayHtml) => {
+    const usedPackages = /* @__PURE__ */ new Set();
+    const headlessInstanceComponents = [];
+    for await (const headlessImport of jayHtml.headlessImports) {
+      const module = headlessImport.codeLink.module;
+      const name = headlessImport.codeLink.names[0].name;
+      const isLocalModule = module[0] === "." || module[0] === "/";
+      let compDefinition;
+      let clientModuleImport;
+      let isNpmPackage;
+      if (headlessImport.structural) {
+        continue;
+      } else {
+        const modulePath = isLocalModule ? path__default.resolve(dirName, module) : require$3.resolve(module, { paths: require$3.resolve.paths(dirName) });
+        compDefinition = (await vite.ssrLoadModule(modulePath))[name];
+        const moduleImport = isLocalModule ? path__default.resolve(dirName, module) : module;
+        isNpmPackage = !isLocalModule;
+        clientModuleImport = isNpmPackage ? `${moduleImport}/client` : `${moduleImport}`;
+      }
+      if (isNpmPackage) {
+        const packageName = module.startsWith("@") ? module.split("/").slice(0, 2).join("/") : module.split("/")[0];
+        usedPackages.add(packageName);
+      }
+      if (headlessImport.key) {
+        const key = headlessImport.key;
+        const hasClientComp = !!compDefinition?.fastRender || !!compDefinition?.hasInteractive;
+        const part = {
+          key,
+          compDefinition,
+          clientImport: hasClientComp ? `import {${name}} from '${clientModuleImport}'` : "",
+          clientPart: hasClientComp ? `{comp: ${name}.comp, contextMarkers: ${name}.contexts || [], key: '${key}'}` : "",
+          contractInfo: headlessImport.contract ? {
+            contractName: headlessImport.contract.name,
+            metadata: headlessImport.metadata
+          } : void 0,
+          headlessProps: headlessImport.headlessProps
+        };
+        parts.push(part);
+      }
+      if (!headlessImport.key && headlessImport.contract) {
+        headlessInstanceComponents.push({
+          contractName: headlessImport.contractName,
+          compDefinition,
+          contract: headlessImport.contract
+        });
+      }
+    }
+    const headlessContracts = jayHtml.headlessImports.filter((hi) => hi.contract !== void 0 && hi.key !== void 0).map((hi) => ({
+      key: hi.key,
+      contract: hi.contract,
+      contractPath: hi.contractPath
+    }));
+    const jayHtmlForDiscovery = injectHeadfullFSTemplates(
+      jayHtmlSource,
+      dirName,
+      JAY_IMPORT_RESOLVER
+    );
+    let discoveryResult;
+    if (headlessInstanceComponents.length > 0) {
+      const firstDiscovery = discoverHeadlessInstances(jayHtmlForDiscovery);
+      const headlessContractNameSet = new Set(
+        jayHtml.headlessImports.map((hi) => hi.contractName)
+      );
+      const jayHtmlWithCoords = assignCoordinatesToJayHtml(
+        firstDiscovery.preRenderedJayHtml,
+        headlessContractNameSet
+      );
+      discoveryResult = discoverHeadlessInstances(jayHtmlWithCoords);
+    } else {
+      discoveryResult = {
+        instances: [],
+        forEachInstances: [],
+        preRenderedJayHtml: jayHtmlSource
+      };
+    }
+    return {
+      parts,
+      serverTrackByMap: jayHtml.serverTrackByMap,
+      clientTrackByMap: jayHtml.clientTrackByMap,
+      usedPackages,
+      headlessContracts,
+      headlessInstanceComponents,
+      discoveredInstances: discoveryResult.instances,
+      forEachInstances: discoveryResult.forEachInstances,
+      linkedCssFiles: jayHtml.linkedCssFiles ?? [],
+      linkedComponentFiles: jayHtml.linkedComponentFiles ?? [],
+      scripts: jayHtml.scripts
+    };
+  });
+}
+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, key + "", value);
+class JayAtomicType {
+  constructor(name) {
+    __publicField2(this, "kind", 0);
+    this.name = name;
+  }
+}
+new JayAtomicType("string");
+new JayAtomicType("string");
+new JayAtomicType("number");
+new JayAtomicType("boolean");
+new JayAtomicType("Date");
+new JayAtomicType("file");
+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")
+});
+function isOptionalType(aType) {
+  return aType.kind === 14;
+}
+function isAtomicType(aType) {
+  return aType.kind === 0;
+}
+function isEnumType(aType) {
+  return aType.kind === 2;
+}
+function isImportedType(aType) {
+  return aType.kind === 4;
+}
+function isObjectType(aType) {
+  return aType.kind === 8;
+}
+function isArrayType(aType) {
+  return aType.kind === 9;
+}
+function isRecordType(aType) {
+  return aType.kind === 11;
+}
+function jayTypeToJsonSchema(type) {
+  if (isOptionalType(type)) {
+    return jayTypeToJsonSchema(type.innerType);
+  }
+  if (isAtomicType(type)) {
+    const name = type.name.toLowerCase();
+    if (name === "string" || name === "number" || name === "boolean") {
+      return { type: name };
+    }
+    if (name === "file") {
+      return { type: "string", description: "Binary file upload (JayFile)" };
+    }
+    return { type: "string" };
+  }
+  if (isEnumType(type)) {
+    return { type: "string", enum: type.values };
+  }
+  if (isImportedType(type)) {
+    return { type: "object", description: `Contract: ${type.name}` };
+  }
+  if (isArrayType(type)) {
+    const itemSchema = jayTypeToJsonSchema(type.itemType);
+    if (itemSchema) {
+      return { type: "array", items: itemSchema };
+    }
+    return { type: "array" };
+  }
+  if (isRecordType(type)) {
+    const valueSchema = jayTypeToJsonSchema(type.itemType);
+    if (valueSchema) {
+      return { type: "object", additionalProperties: valueSchema };
+    }
+    return { type: "object" };
+  }
+  if (isObjectType(type)) {
+    const properties = {};
+    const required = [];
+    for (const [key, propType] of Object.entries(type.props)) {
+      const isOpt = isOptionalType(propType);
+      const schema = jayTypeToJsonSchema(propType);
+      if (schema) {
+        properties[key] = schema;
+        if (!isOpt) {
+          required.push(key);
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 && { required }
+    };
+  }
+  return null;
+}
+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-";
+const JAY_QUERY_HYDRATE = `${JAY_QUERY_PREFIX}hydrate`;
+[
+  // Hydrate target
+  {
+    pattern: JAY_QUERY_HYDRATE,
+    buildEnv: "client",
+    isHydrate: true
+  },
+  // 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
+  }
+];
+function checkValidationErrors(withValidations) {
+  const { validations } = withValidations;
+  if (validations.length > 0) {
+    throw new Error(validations.join("\n"));
+  }
+  return withValidations.val;
+}
+const { html: htmlBeautify } = jsBeautify;
+createRequire(import.meta.url);
+function normalizeActionEntry(entry) {
+  if (typeof entry === "string") {
+    return { name: entry };
+  }
+  return { name: entry.name, action: entry.action };
+}
+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];
+  }
+});
+function asyncSwapScript(id, html) {
+  const escapedHtml = html.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return `<script>(function(){var t=document.querySelector('[jay-async="${id}:pending"]');if(t){var d=document.createElement('div');d.innerHTML='${escapedHtml}';t.replaceWith(d.firstChild);}window.__jay&&window.__jay.hydrateAsync&&window.__jay.hydrateAsync('${id}');})()<\/script>`;
+}
+function generatePromiseReconstruction(outcomes) {
+  if (outcomes.length === 0) return "";
+  return outcomes.map((outcome) => {
+    if (outcome.status === "resolved") {
+      return `      viewState[${JSON.stringify(outcome.id)}] = Promise.resolve(${JSON.stringify(outcome.value)});`;
+    } else {
+      const errMsg = outcome.value?.message ?? "Unknown error";
+      return `      viewState[${JSON.stringify(outcome.id)}] = Promise.reject(new Error(${JSON.stringify(errMsg)}));`;
+    }
+  }).join("\n") + "\n";
+}
+function buildScriptFragments(parts, clientInitData, projectInit, pluginInits, options) {
+  const { enableAutomation = true, slowViewState } = options;
+  const hasSlowViewState = slowViewState && Object.keys(slowViewState).length > 0;
+  const clientParts = parts.filter((part) => part.clientPart);
+  const partImports = clientParts.length > 0 ? clientParts.map((part) => part.clientImport).join("\n") + "\n" : "";
+  const compositeParts = clientParts.length > 0 ? `[
+${clientParts.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 = clientInitData[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(clientInitData["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)};` : "";
+  return {
+    partImports,
+    compositeParts,
+    pluginClientInitImports,
+    projectInitImport,
+    clientInitExecution,
+    automationImport,
+    slowViewStateDecl
+  };
+}
+function buildFreezeScript(routePattern) {
+  const routePatternLiteral = routePattern ? `'${routePattern}'` : "undefined";
+  return `
+      // Page Freeze (DL#127, DL#128 iframe addendum)
+      // Sticky embed mode: URL param sets a session cookie so in-iframe navigation preserves it
+      if (new URLSearchParams(window.location.search).has('_jay_embed')) {
+        document.cookie = '_jay_embed=1;path=/;samesite=lax';
+      }
+      const __jayEmbedMode = document.cookie.split(';').some(c => c.trim().startsWith('_jay_embed='));
+
+      async function __jayDoFreeze() {
+          const automation = window.__jay?.automation;
+          if (!automation) return;
+
+          // Visual feedback: white flash
+          const flash = document.createElement('div');
+          flash.style.cssText = 'position:fixed;inset:0;background:white;z-index:999999;opacity:0.8;pointer-events:none;transition:opacity 0.3s';
+          document.body.appendChild(flash);
+          requestAnimationFrame(() => { flash.style.opacity = '0'; });
+          setTimeout(() => flash.remove(), 400);
+
+          // Audio feedback: camera shutter
+          try {
+            const ctx = new AudioContext();
+            const buf = ctx.createBuffer(1, ctx.sampleRate * 0.15, ctx.sampleRate);
+            const data = buf.getChannelData(0);
+            for (let i = 0; i < data.length; i++) {
+              data[i] = (Math.random() * 2 - 1) * Math.exp(-i / (ctx.sampleRate * 0.02));
+            }
+            const src = ctx.createBufferSource();
+            src.buffer = buf;
+            src.connect(ctx.destination);
+            src.start();
+          } catch {}
+
+          // Capture and save
+          try {
+            const state = automation.getPageState();
+            const route = window.location.pathname;
+            const routePattern = ${routePatternLiteral};
+            const resp = await fetch('/_jay/freeze', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ route, routePattern, viewState: state.viewState }),
+            });
+            const { id } = await resp.json();
+            if (__jayEmbedMode) {
+              window.parent.postMessage({ type: 'jay:freeze', id, route }, '*');
+            } else {
+              window.open(route + '?_jay_freeze=' + id, '_blank');
+            }
+          } catch (err) {
+            console.error('[Freeze] Failed:', err);
+          }
+      }
+
+      if (__jayEmbedMode) {
+        // Notify parent of the current route on load (DL#128 route addendum)
+        window.parent.postMessage({ type: 'jay:route', route: window.location.pathname, routePattern: ${routePatternLiteral} }, '*');
+
+        // Embed mode: parent triggers freeze via postMessage
+        window.addEventListener('message', (e) => {
+          if (e.data?.type === 'jay:requestFreeze') __jayDoFreeze();
+        });
+      } else {
+        // Standalone: Alt+S / Option+S keyboard shortcut
+        document.addEventListener('keydown', (e) => {
+          if (e.altKey && e.code === 'KeyS') {
+            e.preventDefault();
+            __jayDoFreeze();
+          }
+        });
+      }
+
+      // Targeted page reload: only reload if this page matches the changed route prefix
+      if (import.meta.hot) {
+        import.meta.hot.on('jay:page-reload', (data) => {
+          const prefix = data.routePrefix;
+          const pathname = window.location.pathname;
+          if (pathname === prefix || pathname.startsWith(prefix + '/')) {
+            window.location.reload();
+          }
+        });
+      }`;
+}
+function buildAutomationWrap(options, mode) {
+  const { enableAutomation = true, slowViewState } = options;
+  const hasSlowViewState = slowViewState && Object.keys(slowViewState).length > 0;
+  const appendDom = mode === "client";
+  if (!enableAutomation) {
+    return appendDom ? `
+      target.appendChild(instance.element.dom);` : "";
+  }
+  const appendLine = appendDom ? `
+      target.appendChild(wrapped.element.dom);` : "";
+  const freezeScript = buildFreezeScript(options.routePattern);
+  if (hasSlowViewState) {
+    return `
+      // 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;
+      window.dispatchEvent(new Event('jay:automation-ready'));${appendLine}
+${freezeScript}`;
+  }
+  return `
+      // Wrap with automation for dev tooling
+      const wrapped = wrapWithAutomation(instance);
+      registerGlobalContext(AUTOMATION_CONTEXT, wrapped.automation);
+      window.__jay = window.__jay || {};
+      window.__jay.automation = wrapped.automation;
+      window.dispatchEvent(new Event('jay:automation-ready'));${appendLine}
+${freezeScript}`;
+}
+async function resolveViewStatePromises(viewState) {
+  const entries = Object.entries(viewState);
+  const hasPromises = entries.some(([, v]) => v instanceof Promise);
+  if (!hasPromises) return { resolved: viewState, outcomes: [] };
+  const result = { ...viewState };
+  const outcomes = [];
+  for (const [key, value] of entries) {
+    if (value instanceof Promise) {
+      try {
+        const val = await value;
+        result[key] = val;
+        outcomes.push({ id: key, status: "resolved", value: val });
+      } catch (err) {
+        delete result[key];
+        outcomes.push({
+          id: key,
+          status: "rejected",
+          value: { message: err?.message ?? String(err) }
+        });
+      }
+    }
+  }
+  return { resolved: result, outcomes };
+}
+async function generateClientScript(defaultViewState, fastCarryForward, parts, jayHtmlPath, trackByMap = {}, clientInitData = {}, projectInit, pluginInits = [], options = {}) {
+  const { resolved, outcomes } = await resolveViewStatePromises(defaultViewState);
+  defaultViewState = resolved;
+  const {
+    partImports,
+    compositeParts,
+    pluginClientInitImports,
+    projectInitImport,
+    clientInitExecution,
+    automationImport,
+    slowViewStateDecl
+  } = buildScriptFragments(parts, clientInitData, projectInit, pluginInits, options);
+  const automationWrap = buildAutomationWrap(options, "client");
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + TS</title>
+  </head>
+  <body>
+    <div id="target"></div>
+    <script type="module">
+      import {makeCompositeJayComponent} from "@jay-framework/stack-client-runtime";
+      ${automationImport}
+      ${pluginClientInitImports}
+      ${projectInitImport}
+      import { render } from '${jayHtmlPath}';
+      ${partImports}${slowViewStateDecl}
+      const viewState = ${JSON.stringify(defaultViewState)};
+${generatePromiseReconstruction(outcomes)}      
+      const fastCarryForward = ${JSON.stringify(fastCarryForward)};
+      const trackByMap = ${JSON.stringify(trackByMap)};
+${clientInitExecution}
+      const target = document.getElementById('target');
+      const pageComp = makeCompositeJayComponent(render, viewState, fastCarryForward, ${compositeParts}, trackByMap)
+
+      const instance = pageComp({/* placeholder for page props */})
+${automationWrap}
+    <\/script>
+  </body>
+</html>`;
+}
+const serverModuleCache = /* @__PURE__ */ new Map();
+function invalidateServerElementCache(jayHtmlPath) {
+  if (serverModuleCache.delete(jayHtmlPath)) {
+    getLogger().info(`[SSR] Invalidated server element cache for ${jayHtmlPath}`);
+  }
+}
+function clearServerElementCache() {
+  serverModuleCache.clear();
+}
+function getByPath(obj, dotPath) {
+  const segments = dotPath.split(".");
+  let current = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+function resolveParts(parts, viewState) {
+  return parts.map((p) => {
+    if (p.kind === "static") return p.value;
+    if (!viewState) return `{${p.value}}`;
+    const resolved = getByPath(viewState, p.value);
+    return resolved !== void 0 && resolved !== null ? String(resolved) : `{${p.value}}`;
+  }).join("");
+}
+function headMetaToHeadTags(headMeta, viewState) {
+  if (!headMeta) return [];
+  const tags = [];
+  if (headMeta.title) {
+    tags.push({ tag: "title", children: resolveParts(headMeta.title, viewState) });
+  }
+  for (const m of headMeta.meta) {
+    const attrs = {};
+    if (m.name) attrs.name = m.name;
+    if (m.property) attrs.property = m.property;
+    attrs.content = resolveParts(m.content, viewState);
+    tags.push({ tag: "meta", attrs });
+  }
+  for (const l of headMeta.links) {
+    if (l.rel === "stylesheet" || l.rel === "import") continue;
+    const attrs = { rel: l.rel };
+    attrs.href = resolveParts(l.href, viewState);
+    for (const [k, v] of Object.entries(l)) {
+      if (k !== "rel" && k !== "href" && typeof v === "string") attrs[k] = v;
+    }
+    tags.push({ tag: "link", attrs });
+  }
+  return tags;
+}
+async function generateSSRPageHtml(vite, jayHtmlContent, jayHtmlFilename, jayHtmlDir, viewState, jayHtmlImportPath, parts, carryForward, trackByMap = {}, clientInitData = {}, buildFolder, projectRoot, routeDir, tsConfigFilePath, projectInit, pluginInits = [], options = {}, sourceDir, headTags, scripts) {
+  const jayHtmlPath = path__default.join(jayHtmlDir, jayHtmlFilename);
+  let cached = serverModuleCache.get(jayHtmlPath);
+  if (!cached) {
+    cached = await compileAndLoadServerElement(
+      vite,
+      jayHtmlContent,
+      jayHtmlFilename,
+      jayHtmlDir,
+      buildFolder,
+      projectRoot,
+      routeDir,
+      tsConfigFilePath,
+      sourceDir
+    );
+    serverModuleCache.set(jayHtmlPath, cached);
+  }
+  const htmlChunks = [];
+  const asyncPromises = [];
+  const asyncOutcomes = [];
+  const ctx = {
+    write: (chunk) => {
+      htmlChunks.push(chunk);
+    },
+    onAsync: (promise, id, templates) => {
+      const asyncPromise = promise.then(
+        (val) => {
+          asyncOutcomes.push({ id, status: "resolved", value: val });
+          if (templates.resolved) {
+            return asyncSwapScript(id, templates.resolved(val));
+          }
+          return "";
+        },
+        (err) => {
+          asyncOutcomes.push({
+            id,
+            status: "rejected",
+            value: { message: err?.message ?? String(err) }
+          });
+          if (templates.rejected) {
+            return asyncSwapScript(id, templates.rejected(err));
+          }
+          return "";
+        }
+      );
+      asyncPromises.push(asyncPromise);
+    }
+  };
+  cached.renderToStream(viewState, ctx);
+  const asyncResults = await Promise.all(asyncPromises);
+  const ssrHtml = htmlChunks.join("");
+  const asyncScripts = asyncResults.filter((r) => r !== "").join("");
+  const hydrationScript = generateHydrationScript(
+    viewState,
+    carryForward,
+    parts,
+    jayHtmlImportPath,
+    trackByMap,
+    clientInitData,
+    projectInit,
+    pluginInits,
+    options,
+    asyncOutcomes
+  );
+  const cssLink = cached.cssHref ? `    <link rel="stylesheet" href="${cached.cssHref}" />` : "";
+  const tagSources = [];
+  if (headTags && headTags.length > 0) tagSources.push(headTags);
+  const headMetaTags = headMetaToHeadTags(cached.headMeta, viewState);
+  if (headMetaTags.length > 0) tagSources.push(headMetaTags);
+  const mergedTags = mergeHeadTags(tagSources);
+  const hasCustomTitle = mergedTags.some((t) => t.tag.toLowerCase() === "title");
+  const titleTag = hasCustomTitle ? "" : "    <title>Vite + TS</title>\n";
+  const headTagsHtml = mergedTags.length > 0 ? serializeHeadTags(mergedTags) : "";
+  const headScriptsHtml = serializeScripts(scripts, "head");
+  const bodyScriptsHtml = serializeScripts(scripts, "body");
+  const headExtras = [cssLink, headTagsHtml, headScriptsHtml].filter((_) => _).join("\n");
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+${titleTag}${headExtras ? headExtras + "\n" : ""}  </head>
+  <body>
+    <div id="target">${ssrHtml}</div>${asyncScripts}
+    ${hydrationScript}${bodyScriptsHtml ? "\n    " + bodyScriptsHtml : ""}
+  </body>
+</html>`;
+}
+async function generateFrozenPageHtml(vite, jayHtmlContent, jayHtmlFilename, jayHtmlDir, viewState, buildFolder, projectRoot, routeDir, tsConfigFilePath, sourceDir, format = "page", freezeName) {
+  const jayHtmlPath = path__default.join(jayHtmlDir, jayHtmlFilename);
+  let cached = serverModuleCache.get(jayHtmlPath);
+  if (!cached) {
+    cached = await compileAndLoadServerElement(
+      vite,
+      jayHtmlContent,
+      jayHtmlFilename,
+      jayHtmlDir,
+      buildFolder,
+      projectRoot,
+      routeDir,
+      tsConfigFilePath,
+      sourceDir
+    );
+    serverModuleCache.set(jayHtmlPath, cached);
+  }
+  const htmlChunks = [];
+  const ctx = {
+    write: (chunk) => {
+      htmlChunks.push(chunk);
+    },
+    onAsync: () => {
+    }
+  };
+  cached.renderToStream(viewState, ctx);
+  const ssrHtml = htmlChunks.join("");
+  if (format === "fragment") {
+    let inlineCss = "";
+    if (cached.cssHref) {
+      try {
+        const cssPath = cached.cssHref.replace(/^\/@fs/, "").replace(/\?.*$/, "");
+        const cssContent = await fs$1.readFile(cssPath, "utf-8");
+        inlineCss = `<style>${cssContent}</style>`;
+      } catch {
+        inlineCss = `<link rel="stylesheet" href="${cached.cssHref}" />`;
+      }
+    }
+    return `${inlineCss}
+${ssrHtml}`;
+  }
+  const frozenHeadTags = headMetaToHeadTags(cached.headMeta, viewState);
+  const frozenHeadTagsHtml = frozenHeadTags.length > 0 ? serializeHeadTags(frozenHeadTags) : "";
+  const cssLink = cached.cssHref ? `    <link rel="stylesheet" href="${cached.cssHref}" />` : "";
+  const headExtras = [cssLink, frozenHeadTagsHtml].filter((_) => _).join("\n");
+  const label = freezeName ? ` — ${freezeName}` : "";
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Frozen${label}</title>
+${headExtras ? headExtras + "\n" : ""}    <style>
+      body::before {
+        content: 'FROZEN${label ? `: ${freezeName}` : ""}';
+        position: fixed;
+        top: 0;
+        right: 0;
+        background: #1a1a2e;
+        color: #e0e0ff;
+        padding: 2px 10px;
+        font: 11px/1.6 system-ui;
+        z-index: 99999;
+        border-bottom-left-radius: 4px;
+        opacity: 0.8;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="target">${ssrHtml}</div>
+  </body>
+</html>`;
+}
+function serializeScripts(scripts, position) {
+  if (!scripts) return "";
+  const filtered = scripts.filter((s2) => s2.position === position);
+  if (filtered.length === 0) return "";
+  return filtered.map((s2) => {
+    const attrs = Object.entries(s2.attributes).map(([k, v]) => v === "" ? k : `${k}="${v}"`).join(" ");
+    const attrStr = attrs ? " " + attrs : "";
+    if (s2.src) {
+      return `    <script src="${s2.src}"${attrStr}><\/script>`;
+    }
+    return `    <script${attrStr}>${s2.inline}<\/script>`;
+  }).join("\n");
+}
+function rebaseRelativeImports(code, fromDir, toDir) {
+  return code.replace(/from "(\.\.\/[^"]+)"/g, (_match, relPath) => {
+    const absolutePath = path__default.resolve(fromDir, relPath);
+    let newRelPath = path__default.relative(toDir, absolutePath);
+    if (!newRelPath.startsWith(".")) {
+      newRelPath = "./" + newRelPath;
+    }
+    return `from "${newRelPath}"`;
+  });
+}
+async function compileAndLoadServerElement(vite, jayHtmlContent, jayHtmlFilename, jayHtmlDir, buildFolder, projectRoot, routeDir, tsConfigFilePath, sourceDir) {
+  const jayFile = await parseJayFile(
+    jayHtmlContent,
+    jayHtmlFilename,
+    jayHtmlDir,
+    { relativePath: tsConfigFilePath },
+    JAY_IMPORT_RESOLVER,
+    projectRoot,
+    sourceDir
+  );
+  const parsedJayFile = checkValidationErrors(jayFile);
+  const pageName = jayHtmlFilename.replace(".jay-html", "");
+  const debugCoordinatePreprocessPath = path__default.join(
+    buildFolder,
+    "debug",
+    routeDir,
+    `${pageName}.coordinate-preprocess.jay-html`
+  );
+  const serverElementOptions = {
+    debugCoordinatePreprocessPath
+  };
+  const serverElementCode = checkValidationErrors(
+    generateServerElementFile(parsedJayFile, serverElementOptions)
+  );
+  const serverElementDir = path__default.join(buildFolder, "pre-rendered", routeDir);
+  await fs$1.mkdir(serverElementDir, { recursive: true });
+  const adjustedCode = rebaseRelativeImports(serverElementCode, jayHtmlDir, serverElementDir);
+  const serverElementFilename = jayHtmlFilename.replace(".jay-html", ".server-element.ts");
+  const serverElementPath = path__default.join(serverElementDir, serverElementFilename);
+  await fs$1.writeFile(serverElementPath, adjustedCode, "utf-8");
+  const existingModule = vite.moduleGraph.getModuleById(serverElementPath);
+  if (existingModule) {
+    vite.moduleGraph.invalidateModule(existingModule);
+  }
+  const jayHtmlPath = path__default.join(serverElementDir, jayHtmlFilename);
+  invalidateJayHtmlModules(vite, jayHtmlPath);
+  const serverModule = await vite.ssrLoadModule(serverElementPath);
+  let cssHref;
+  if (parsedJayFile.css) {
+    const cssFilename = jayHtmlFilename.replace(".jay-html", ".css");
+    const cssPath = path__default.join(serverElementDir, cssFilename);
+    await fs$1.writeFile(cssPath, parsedJayFile.css, "utf-8");
+    const cssModules = vite.moduleGraph.getModulesByFile(cssPath);
+    if (cssModules) {
+      for (const mod of cssModules) {
+        vite.moduleGraph.invalidateModule(mod);
+      }
+    }
+    const hash = crypto.createHash("md5").update(parsedJayFile.css).digest("hex").slice(0, 8);
+    cssHref = "/@fs" + cssPath + "?v=" + hash + "&direct";
+  }
+  return {
+    renderToStream: serverModule.renderToStream,
+    headLinks: parsedJayFile.headLinks,
+    headMeta: parsedJayFile.headMeta,
+    cssHref
+  };
+}
+function invalidateJayHtmlModules(vite, jayHtmlPath) {
+  let count = 0;
+  const byFile = vite.moduleGraph.getModulesByFile(jayHtmlPath);
+  if (byFile) {
+    for (const mod of byFile) {
+      vite.moduleGraph.invalidateModule(mod);
+      count++;
+    }
+  }
+  const knownIds = [jayHtmlPath + ".ts", jayHtmlPath + JAY_QUERY_HYDRATE + ".ts"];
+  for (const id of knownIds) {
+    const mod = vite.moduleGraph.getModuleById(id);
+    if (mod) {
+      vite.moduleGraph.invalidateModule(mod);
+      count++;
+    }
+  }
+  const idMap = vite.moduleGraph.idToModuleMap;
+  for (const [id, mod] of idMap) {
+    if (id.includes(jayHtmlPath)) {
+      vite.moduleGraph.invalidateModule(mod);
+      count++;
+    }
+  }
+  if (count > 0) {
+    getLogger().info(`[SSR] Invalidated ${count} Vite module(s) for ${jayHtmlPath}`);
+  }
+}
+function generateHydrationScript(defaultViewState, fastCarryForward, parts, jayHtmlPath, trackByMap = {}, clientInitData = {}, projectInit, pluginInits = [], options = {}, asyncOutcomes = []) {
+  const {
+    partImports,
+    compositeParts,
+    pluginClientInitImports,
+    projectInitImport,
+    clientInitExecution,
+    automationImport,
+    slowViewStateDecl
+  } = buildScriptFragments(parts, clientInitData, projectInit, pluginInits, options);
+  const automationWrap = buildAutomationWrap(options, "hydrate");
+  const hydrateImportPath = `${jayHtmlPath}${JAY_QUERY_HYDRATE}`;
+  return `<script type="module">
+      import {hydrateCompositeJayComponent} from "@jay-framework/stack-client-runtime";
+      ${automationImport}
+      ${pluginClientInitImports}
+      ${projectInitImport}
+      import { hydrate } from '${hydrateImportPath}';
+      ${partImports}${slowViewStateDecl}
+      const viewState = ${JSON.stringify(defaultViewState)};
+${generatePromiseReconstruction(asyncOutcomes)}      const fastCarryForward = ${JSON.stringify(fastCarryForward)};
+      const trackByMap = ${JSON.stringify(trackByMap)};
+
+      const target = document.getElementById('target');
+      const rootElement = target.firstElementChild;
+      const pageComp = hydrateCompositeJayComponent(hydrate, viewState, fastCarryForward, ${compositeParts}, trackByMap, rootElement);
+${clientInitExecution}
+      const instance = pageComp({/* placeholder for page props */});
+${automationWrap}
+    <\/script>`;
+}
+function parseActionMetadata(yamlContent, fileName) {
+  try {
+    const parsed = parseAction(yamlContent, fileName);
+    if (parsed.validations.length > 0) {
+      getLogger().warn(
+        `[ActionMetadata] ${fileName}: validation errors: ${parsed.validations.join(", ")}`
+      );
+      return null;
+    }
+    if (!parsed.val) {
+      getLogger().warn(`[ActionMetadata] ${fileName}: parsing returned no result`);
+      return null;
+    }
+    const action = parsed.val;
+    const inputJsonSchema = jayTypeToJsonSchema(action.inputType);
+    let inputSchema;
+    if (inputJsonSchema && inputJsonSchema.type === "object") {
+      inputSchema = {
+        type: "object",
+        properties: inputJsonSchema.properties || {},
+        ...inputJsonSchema.required && inputJsonSchema.required.length > 0 && { required: inputJsonSchema.required }
+      };
+    } else {
+      inputSchema = { type: "object", properties: {} };
+    }
+    const metadata = {
+      name: action.name,
+      description: action.description,
+      inputSchema
+    };
+    if (action.outputType) {
+      const outputJsonSchema = jayTypeToJsonSchema(action.outputType);
+      if (outputJsonSchema) {
+        metadata.outputSchema = outputJsonSchema;
+      }
+    }
+    return metadata;
+  } catch (error) {
+    getLogger().error(
+      `[ActionMetadata] Failed to parse ${fileName}: ${error instanceof Error ? error.message : error}`
+    );
+    return null;
+  }
+}
+function loadActionMetadata(filePath) {
+  if (!fs.existsSync(filePath)) {
+    getLogger().warn(`[ActionMetadata] File not found: ${filePath}`);
+    return null;
+  }
+  const yamlContent = fs.readFileSync(filePath, "utf-8");
+  const fileName = path.basename(filePath);
+  return parseActionMetadata(yamlContent, fileName);
+}
+function resolveActionMetadataPath(actionPath, pluginDir) {
+  return path.resolve(pluginDir, actionPath);
+}
+const require$2 = 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) {
+      getLogger().info(`[Actions] No actions directory found at ${actionsPath}`);
+    }
+    return result;
+  }
+  const actionFiles = await findActionFiles(actionsPath);
+  if (verbose) {
+    getLogger().info(`[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) {
+            getLogger().info(
+              `[Actions] Registered: ${exportValue.actionName}`
+            );
+          }
+        } else if (isJayStreamAction(exportValue)) {
+          registry.registerStream(exportValue);
+          result.actionNames.push(exportValue.actionName);
+          result.actionCount++;
+          if (verbose) {
+            getLogger().info(
+              `[Actions] Registered stream: ${exportValue.actionName}`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      getLogger().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) {
+          getLogger().info(
+            `[Actions] NPM plugin "${packageName}" declares actions: ${JSON.stringify(pluginConfig.actions)}`
+          );
+        }
+        const actions = await registerNpmPluginActions(
+          packageName,
+          pluginConfig,
+          pluginDir,
+          registry,
+          verbose,
+          viteServer
+        );
+        allActions.push(...actions);
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    getLogger().error(`[Actions] Failed to read project package.json: ${error}`);
+  }
+  return allActions;
+}
+function tryResolvePluginYaml(packageName, projectRoot) {
+  try {
+    return require$2.resolve(`${packageName}/plugin.yaml`, {
+      paths: [projectRoot]
+    });
+  } catch {
+    return null;
+  }
+}
+function resolveNpmActionMetadataPath(actionPath, packageName, pluginDir) {
+  if (!actionPath.startsWith(".")) {
+    try {
+      return require$2.resolve(`${packageName}/${actionPath}`, {
+        paths: [pluginDir]
+      });
+    } catch {
+    }
+  }
+  const resolved = resolveActionMetadataPath(actionPath, pluginDir);
+  if (fs.existsSync(resolved)) {
+    return resolved;
+  }
+  getLogger().warn(
+    `[Actions] Could not resolve .jay-action file "${actionPath}" for package "${packageName}"`
+  );
+  return null;
+}
+async function registerNpmPluginActions(packageName, pluginConfig, pluginDir, registry, verbose, viteServer) {
+  const registeredActions = [];
+  try {
+    let pluginModule;
+    if (viteServer) {
+      pluginModule = await viteServer.ssrLoadModule(packageName);
+    } else {
+      pluginModule = await import(packageName);
+    }
+    for (const entry of pluginConfig.actions) {
+      const { name: actionName, action: actionPath } = normalizeActionEntry(entry);
+      const actionExport = pluginModule[actionName];
+      if (actionExport && isJayAction(actionExport)) {
+        registry.register(actionExport);
+        const registeredName = actionExport.actionName;
+        registeredActions.push(registeredName);
+        if (actionPath) {
+          const metadataFilePath = resolveNpmActionMetadataPath(
+            actionPath,
+            packageName,
+            pluginDir
+          );
+          if (metadataFilePath) {
+            const metadata = loadActionMetadata(metadataFilePath);
+            if (metadata) {
+              registry.setMetadata(registeredName, metadata);
+              if (verbose) {
+                getLogger().info(
+                  `[Actions] Loaded metadata for "${registeredName}" from ${actionPath}`
+                );
+              }
+            }
+          }
+        }
+        if (verbose) {
+          getLogger().info(`[Actions] Registered NPM plugin action: ${registeredName}`);
+        }
+      } else if (actionExport && isJayStreamAction(actionExport)) {
+        registry.registerStream(actionExport);
+        const registeredName = actionExport.actionName;
+        registeredActions.push(registeredName);
+        if (verbose) {
+          getLogger().info(`[Actions] Registered NPM plugin stream: ${registeredName}`);
+        }
+      } else {
+        getLogger().warn(
+          `[Actions] NPM plugin "${packageName}" declares action "${actionName}" but it's not exported or not a JayAction`
+        );
+      }
+    }
+  } catch (importError) {
+    getLogger().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) {
+    getLogger().info(
+      `[Actions] Plugin "${pluginName}" declares actions: ${JSON.stringify(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 {
+      getLogger().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 entry of pluginConfig.actions) {
+      const { name: actionName, action: actionPath } = normalizeActionEntry(entry);
+      const actionExport = pluginModule[actionName];
+      if (actionExport && isJayAction(actionExport)) {
+        registry.register(actionExport);
+        const registeredName = actionExport.actionName;
+        registeredActions.push(registeredName);
+        if (actionPath) {
+          const metadataFilePath = resolveActionMetadataPath(actionPath, pluginPath);
+          const metadata = loadActionMetadata(metadataFilePath);
+          if (metadata) {
+            registry.setMetadata(registeredName, metadata);
+            if (verbose) {
+              getLogger().info(
+                `[Actions] Loaded metadata for "${registeredName}" from ${actionPath}`
+              );
+            }
+          }
+        }
+        if (verbose) {
+          getLogger().info(`[Actions] Registered plugin action: ${registeredName}`);
+        }
+      } else if (actionExport && isJayStreamAction(actionExport)) {
+        registry.registerStream(actionExport);
+        const registeredName = actionExport.actionName;
+        registeredActions.push(registeredName);
+        if (verbose) {
+          getLogger().info(`[Actions] Registered plugin stream: ${registeredName}`);
+        }
+      } else {
+        getLogger().warn(
+          `[Actions] Plugin "${pluginName}" declares action "${actionName}" but it's not exported or not a JayAction`
+        );
+      }
+    }
+  } catch (importError) {
+    getLogger().error(
+      `[Actions] Failed to import plugin module at ${modulePath}: ${importError}`
+    );
+  }
+  return registeredActions;
+}
+const require$1 = createRequire(import.meta.url);
+async function executeDynamicGenerator(plugin, config, projectRoot, services, verbose, viteServer) {
+  const { pluginPath, name: pluginName, isLocal, packageName } = plugin;
+  if (!config.generator) {
+    throw new Error(
+      `Plugin "${pluginName}" has dynamic_contracts entry but no generator specified`
+    );
+  }
+  const isFilePath = config.generator.startsWith("./") || config.generator.startsWith("/") || config.generator.includes(".ts") || config.generator.includes(".js");
+  let generator;
+  if (isFilePath) {
+    let generatorPath;
+    if (!isLocal) {
+      try {
+        generatorPath = require$1.resolve(`${packageName}/${config.generator}`, {
+          paths: [projectRoot]
+        });
+      } catch {
+        generatorPath = path.join(pluginPath, config.generator);
+      }
+    } else {
+      generatorPath = path.join(pluginPath, config.generator);
+    }
+    if (!fs.existsSync(generatorPath)) {
+      const withTs = generatorPath + ".ts";
+      const withJs = generatorPath + ".js";
+      if (fs.existsSync(withTs)) {
+        generatorPath = withTs;
+      } else if (fs.existsSync(withJs)) {
+        generatorPath = withJs;
+      }
+    }
+    if (!fs.existsSync(generatorPath)) {
+      throw new Error(
+        `Generator file not found for plugin "${pluginName}": ${config.generator}`
+      );
+    }
+    if (verbose) {
+      getLogger().info(`   Loading generator from file: ${generatorPath}`);
+    }
+    let generatorModule;
+    if (viteServer) {
+      generatorModule = await viteServer.ssrLoadModule(generatorPath);
+    } else {
+      generatorModule = await import(generatorPath);
+    }
+    generator = generatorModule.generator || generatorModule.default;
+  } else {
+    if (verbose) {
+      getLogger().info(
+        `   Loading generator export: ${config.generator} from ${packageName}`
+      );
+    }
+    let pluginModule;
+    if (viteServer) {
+      pluginModule = await viteServer.ssrLoadModule(packageName);
+    } else {
+      pluginModule = await import(packageName);
+    }
+    generator = pluginModule[config.generator];
+    if (!generator) {
+      throw new Error(
+        `Generator "${config.generator}" not exported from plugin "${pluginName}". Ensure it's exported from the package's index.ts`
+      );
+    }
+  }
+  if (!generator || typeof generator.generate !== "function") {
+    throw new Error(
+      `Generator "${config.generator}" for plugin "${pluginName}" must have a 'generate' function. Use makeContractGenerator() to create valid generators.`
+    );
+  }
+  const resolvedServices = [];
+  for (const marker of generator.services) {
+    const service = services.get(marker);
+    if (!service) {
+      const markerName = marker.description ?? "unknown";
+      throw new Error(
+        `Service "${markerName}" required by ${pluginName} generator not found. Ensure it's registered in init.ts`
+      );
+    }
+    resolvedServices.push(service);
+  }
+  if (verbose) {
+    getLogger().info(`   Executing generator...`);
+  }
+  return await generator.generate(...resolvedServices);
+}
+function resolveStaticContractPath(plugin, contractSpec, projectRoot) {
+  const { pluginPath, isLocal, packageName } = plugin;
+  if (!isLocal) {
+    try {
+      return require$1.resolve(`${packageName}/${contractSpec}`, {
+        paths: [projectRoot]
+      });
+    } catch {
+      const possiblePaths = [
+        path.join(pluginPath, "dist", contractSpec),
+        path.join(pluginPath, "lib", contractSpec),
+        path.join(pluginPath, contractSpec)
+      ];
+      const found = possiblePaths.find((p) => fs.existsSync(p));
+      return found || possiblePaths[0];
+    }
+  } else {
+    return path.join(pluginPath, contractSpec);
+  }
+}
+function resolveActionFilePath(actionPath, packageName, pluginPath, isLocal, projectRoot) {
+  if (!isLocal && !actionPath.startsWith(".")) {
+    try {
+      return require$1.resolve(`${packageName}/${actionPath}`, {
+        paths: [projectRoot]
+      });
+    } catch {
+      const possiblePaths = [
+        path.join(pluginPath, "dist", actionPath),
+        path.join(pluginPath, "lib", actionPath),
+        path.join(pluginPath, actionPath)
+      ];
+      const found = possiblePaths.find((p) => fs.existsSync(p));
+      return found || null;
+    }
+  }
+  const resolved = resolveActionMetadataPath(actionPath, pluginPath);
+  return fs.existsSync(resolved) ? resolved : null;
+}
+function toKebabCase(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+async function materializeContracts(options, services = /* @__PURE__ */ new Map()) {
+  const {
+    projectRoot,
+    outputDir = path.join(projectRoot, "agent-kit", "materialized-contracts"),
+    dynamicOnly = false,
+    pluginFilter,
+    verbose = false,
+    viteServer
+  } = options;
+  const pluginsIndexMap = /* @__PURE__ */ new Map();
+  let staticCount = 0;
+  let dynamicCount = 0;
+  if (verbose) {
+    getLogger().info("Scanning for plugins...");
+  }
+  const plugins = await scanPlugins({
+    projectRoot,
+    verbose,
+    includeDevDeps: true
+    // Include dev deps for contract discovery
+  });
+  if (verbose) {
+    getLogger().info(`Found ${plugins.size} plugin(s)`);
+  }
+  for (const [pluginKey, plugin] of plugins) {
+    if (pluginFilter && plugin.name !== pluginFilter && pluginKey !== pluginFilter) continue;
+    if (verbose) {
+      getLogger().info(`
+📦 Processing plugin: ${plugin.name}`);
+    }
+    const { manifest } = plugin;
+    const pluginRelPath = path.relative(projectRoot, plugin.pluginPath);
+    if (!pluginsIndexMap.has(plugin.name)) {
+      const entry = {
+        path: "./" + pluginRelPath.replace(/\\/g, "/"),
+        contracts: [],
+        actions: []
+      };
+      if (manifest.services?.length) {
+        entry.services = manifest.services.map((s2) => {
+          const docPath = s2.doc ? "./" + path.relative(projectRoot, path.resolve(plugin.pluginPath, s2.doc)) : void 0;
+          return {
+            name: s2.name,
+            marker: s2.marker,
+            ...s2.description && { description: s2.description },
+            ...docPath && { doc: docPath }
+          };
+        });
+      }
+      if (manifest.contexts?.length) {
+        entry.contexts = manifest.contexts.map((c) => {
+          const docPath = c.doc ? "./" + path.relative(projectRoot, path.resolve(plugin.pluginPath, c.doc)) : void 0;
+          return {
+            name: c.name,
+            marker: c.marker,
+            ...c.description && { description: c.description },
+            ...docPath && { doc: docPath }
+          };
+        });
+      }
+      if (manifest.routes?.length) {
+        entry.routes = manifest.routes.map((r) => ({
+          path: r.path,
+          ...r.description && { description: r.description }
+        }));
+      }
+      if (manifest.commands?.length) {
+        entry.commands = manifest.commands.map((c) => {
+          let description;
+          if (c.command) {
+            try {
+              const cmdPath = path.resolve(plugin.pluginPath, c.command);
+              const cmdContent = fs.readFileSync(cmdPath, "utf-8");
+              const parsed = YAML.parse(cmdContent);
+              description = parsed?.description;
+            } catch {
+            }
+          }
+          return {
+            name: c.name,
+            ...description && { description }
+          };
+        });
+      }
+      pluginsIndexMap.set(plugin.name, entry);
+    }
+    if (!dynamicOnly && manifest.contracts) {
+      for (const contract of manifest.contracts) {
+        const contractPath = resolveStaticContractPath(
+          plugin,
+          contract.contract,
+          projectRoot
+        );
+        const relativePath = path.relative(projectRoot, contractPath);
+        let description = contract.description;
+        if (!description) {
+          try {
+            const contractContent = fs.readFileSync(contractPath, "utf-8");
+            const parsed = YAML.parse(contractContent);
+            if (parsed?.description && typeof parsed.description === "string") {
+              description = parsed.description;
+            }
+          } catch {
+          }
+        }
+        pluginsIndexMap.get(plugin.name).contracts.push({
+          name: contract.name,
+          ...description && { description },
+          type: "static",
+          path: "./" + relativePath
+        });
+        staticCount++;
+        if (verbose) {
+          getLogger().info(`   📄 Static: ${contract.name}`);
+        }
+      }
+    }
+    if (manifest.dynamic_contracts) {
+      const dynamicConfigs = Array.isArray(manifest.dynamic_contracts) ? manifest.dynamic_contracts : [manifest.dynamic_contracts];
+      const pluginOutputDir = path.join(outputDir, plugin.name.replace(/[@/]/g, "_"));
+      fs.mkdirSync(pluginOutputDir, { recursive: true });
+      for (const config of dynamicConfigs) {
+        if (verbose) {
+          getLogger().info(`   ⚡ Dynamic contracts (prefix: ${config.prefix})`);
+        }
+        try {
+          const generatedContracts = await executeDynamicGenerator(
+            plugin,
+            config,
+            projectRoot,
+            services,
+            verbose,
+            viteServer
+          );
+          const prefix = config.prefix;
+          if (generatedContracts.length > 1) {
+            const missing = generatedContracts.filter((c) => !c.name);
+            if (missing.length > 0) {
+              getLogger().error(
+                `   ❌ Dynamic contract generator for "${prefix}" returned ${generatedContracts.length} contracts but ${missing.length} are missing a name. Names are required when a generator returns multiple contracts.`
+              );
+              continue;
+            }
+          }
+          for (const generated of generatedContracts) {
+            const kebabName = generated.name ? toKebabCase(generated.name) : null;
+            const fullName = kebabName ? `${prefix}/${kebabName}` : prefix;
+            const fileName = kebabName ? `${prefix}-${kebabName}.jay-contract` : `${prefix}.jay-contract`;
+            const filePath = path.join(pluginOutputDir, fileName);
+            fs.writeFileSync(filePath, generated.yaml, "utf-8");
+            const relativePath = path.relative(projectRoot, filePath);
+            let dynDescription;
+            try {
+              const parsedYaml = YAML.parse(generated.yaml);
+              if (parsedYaml?.description && typeof parsedYaml.description === "string") {
+                dynDescription = parsedYaml.description;
+              }
+            } catch {
+            }
+            const contractEntry = {
+              name: fullName,
+              ...dynDescription && { description: dynDescription },
+              type: "dynamic",
+              path: "./" + relativePath,
+              ...generated.metadata && { metadata: generated.metadata }
+            };
+            pluginsIndexMap.get(plugin.name).contracts.push(contractEntry);
+            dynamicCount++;
+            if (verbose) {
+              getLogger().info(`   ⚡ Materialized: ${fullName}`);
+            }
+          }
+        } catch (error) {
+          getLogger().error(
+            `   ❌ Failed to materialize dynamic contracts for ${plugin.name} (${config.prefix}): ${error}`
+          );
+        }
+      }
+    }
+    if (manifest.actions && Array.isArray(manifest.actions)) {
+      for (const entry of manifest.actions) {
+        const { name: actionName, action: actionPath } = normalizeActionEntry(entry);
+        if (!actionPath) continue;
+        const metadataFilePath = resolveActionFilePath(
+          actionPath,
+          plugin.packageName,
+          plugin.pluginPath,
+          plugin.isLocal,
+          projectRoot
+        );
+        if (!metadataFilePath) continue;
+        const metadata = loadActionMetadata(metadataFilePath);
+        if (!metadata) continue;
+        const actionRelPath = path.relative(projectRoot, metadataFilePath);
+        const pluginEntry = pluginsIndexMap.get(plugin.name);
+        if (!pluginEntry.actions) pluginEntry.actions = [];
+        pluginEntry.actions.push({
+          name: metadata.name,
+          description: metadata.description,
+          path: "./" + actionRelPath.replace(/\\/g, "/")
+        });
+        if (verbose) {
+          getLogger().info(`   🔧 Action: ${metadata.name} (${actionPath})`);
+        }
+      }
+    }
+  }
+  const pluginsIndex = {
+    plugins: Array.from(pluginsIndexMap.entries()).map(([name, data]) => ({
+      name,
+      path: data.path,
+      contracts: data.contracts,
+      ...data.actions && data.actions.length > 0 && { actions: data.actions },
+      ...data.services?.length && { services: data.services },
+      ...data.contexts?.length && { contexts: data.contexts },
+      ...data.routes?.length && { routes: data.routes },
+      ...data.commands?.length && { commands: data.commands }
+    }))
+  };
+  fs.mkdirSync(outputDir, { recursive: true });
+  const agentKitDir = path.dirname(outputDir);
+  const pluginsIndexPath = path.join(agentKitDir, "plugins-index.yaml");
+  fs.writeFileSync(pluginsIndexPath, YAML.stringify(pluginsIndex), "utf-8");
+  if (verbose) {
+    getLogger().info(`
+✅ Plugins index written to: ${pluginsIndexPath}`);
+  }
+  return {
+    pluginsIndex,
+    staticCount,
+    dynamicCount,
+    outputDir
+  };
+}
+async function listContracts(options) {
+  const { projectRoot, dynamicOnly = false, pluginFilter } = options;
+  const pluginsMap = /* @__PURE__ */ new Map();
+  const plugins = await scanPlugins({
+    projectRoot,
+    includeDevDeps: true
+  });
+  for (const [pluginKey, plugin] of plugins) {
+    if (pluginFilter && plugin.name !== pluginFilter && pluginKey !== pluginFilter) continue;
+    const { manifest } = plugin;
+    const pluginRelPath = path.relative(projectRoot, plugin.pluginPath);
+    if (!pluginsMap.has(plugin.name)) {
+      const entry = {
+        path: "./" + pluginRelPath.replace(/\\/g, "/"),
+        contracts: []
+      };
+      if (manifest.services?.length) {
+        entry.services = manifest.services.map((s2) => {
+          const docPath = s2.doc ? "./" + path.relative(projectRoot, path.resolve(plugin.pluginPath, s2.doc)) : void 0;
+          return {
+            name: s2.name,
+            marker: s2.marker,
+            ...s2.description && { description: s2.description },
+            ...docPath && { doc: docPath }
+          };
+        });
+      }
+      if (manifest.contexts?.length) {
+        entry.contexts = manifest.contexts.map((c) => {
+          const docPath = c.doc ? "./" + path.relative(projectRoot, path.resolve(plugin.pluginPath, c.doc)) : void 0;
+          return {
+            name: c.name,
+            marker: c.marker,
+            ...c.description && { description: c.description },
+            ...docPath && { doc: docPath }
+          };
+        });
+      }
+      if (manifest.routes?.length) {
+        entry.routes = manifest.routes.map((r) => ({
+          path: r.path,
+          ...r.description && { description: r.description }
+        }));
+      }
+      if (manifest.commands?.length) {
+        entry.commands = manifest.commands.map((c) => {
+          let description;
+          if (c.command) {
+            try {
+              const cmdPath = path.resolve(plugin.pluginPath, c.command);
+              const cmdContent = fs.readFileSync(cmdPath, "utf-8");
+              const parsed = YAML.parse(cmdContent);
+              description = parsed?.description;
+            } catch {
+            }
+          }
+          return {
+            name: c.name,
+            ...description && { description }
+          };
+        });
+      }
+      pluginsMap.set(plugin.name, entry);
+    }
+    if (!dynamicOnly && manifest.contracts) {
+      for (const contract of manifest.contracts) {
+        const contractPath = resolveStaticContractPath(
+          plugin,
+          contract.contract,
+          projectRoot
+        );
+        const relativePath = path.relative(projectRoot, contractPath);
+        let listDescription = contract.description;
+        if (!listDescription) {
+          try {
+            const contractContent = fs.readFileSync(contractPath, "utf-8");
+            const parsed = YAML.parse(contractContent);
+            if (parsed?.description && typeof parsed.description === "string") {
+              listDescription = parsed.description;
+            }
+          } catch {
+          }
+        }
+        pluginsMap.get(plugin.name).contracts.push({
+          name: contract.name,
+          ...listDescription && { description: listDescription },
+          type: "static",
+          path: "./" + relativePath
+        });
+      }
+    }
+    if (manifest.dynamic_contracts) {
+      const dynamicConfigs = Array.isArray(manifest.dynamic_contracts) ? manifest.dynamic_contracts : [manifest.dynamic_contracts];
+      for (const config of dynamicConfigs) {
+        pluginsMap.get(plugin.name).contracts.push({
+          name: `${config.prefix}/*`,
+          type: "dynamic",
+          path: "(run materialization to generate)"
+        });
+      }
+    }
+  }
+  return {
+    plugins: Array.from(pluginsMap.entries()).map(([name, data]) => ({
+      name,
+      path: data.path,
+      contracts: data.contracts,
+      ...data.services?.length && { services: data.services },
+      ...data.contexts?.length && { contexts: data.contexts },
+      ...data.routes?.length && { routes: data.routes },
+      ...data.commands?.length && { commands: data.commands }
+    }))
+  };
+}
+async function discoverPluginCommands(options) {
+  const { projectRoot, verbose, pluginFilter } = options;
+  const allPlugins = await scanPlugins({
+    projectRoot,
+    verbose,
+    discoverTransitive: true,
+    includeDevDeps: true
+  });
+  const commands = [];
+  for (const [packageName, plugin] of allPlugins) {
+    if (!plugin.manifest.commands || plugin.manifest.commands.length === 0) continue;
+    if (pluginFilter && plugin.name !== pluginFilter && packageName !== pluginFilter) {
+      continue;
+    }
+    for (const cmd of plugin.manifest.commands) {
+      let metadata;
+      let metadataPath;
+      if (cmd.command) {
+        metadataPath = path.resolve(plugin.pluginPath, cmd.command);
+        metadata = loadCommandMetadata(metadataPath);
+      }
+      commands.push({
+        pluginName: plugin.name,
+        pluginPath: plugin.pluginPath,
+        packageName: plugin.packageName,
+        isLocal: plugin.isLocal,
+        commandName: cmd.name,
+        handlerExport: cmd.name,
+        pluginModule: plugin.manifest.module,
+        metadata,
+        metadataPath
+      });
+      if (verbose) {
+        getLogger().info(`[Commands] Found ${plugin.name}/${cmd.name}`);
+      }
+    }
+  }
+  return commands;
+}
+function loadCommandMetadata(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return YAML.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function commandSchemaToFlags(inputSchema) {
+  const flags = [];
+  for (const [field, type] of Object.entries(inputSchema)) {
+    const isOptional = field.endsWith("?");
+    const cleanName = isOptional ? field.slice(0, -1) : field;
+    const kebabName = camelToKebab(cleanName);
+    const cleanType = type.toLowerCase().trim();
+    const isBoolean = cleanType === "boolean";
+    flags.push({
+      flag: isBoolean ? `--${kebabName}` : `--${kebabName} <value>`,
+      description: "",
+      required: !isOptional,
+      type: cleanType === "number" ? "number" : isBoolean ? "boolean" : "string"
+    });
+  }
+  return flags;
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function parseInputFromFlags(rawOptions, schema) {
+  const input = {};
+  for (const [field, type] of Object.entries(schema)) {
+    const isOptional = field.endsWith("?");
+    const cleanName = isOptional ? field.slice(0, -1) : field;
+    const kebabName = camelToKebab(cleanName);
+    const value = rawOptions[kebabName];
+    if (value === void 0) {
+      if (!isOptional) {
+        throw new Error(`Missing required flag: --${kebabName}`);
+      }
+      continue;
+    }
+    const cleanType = type.toLowerCase().trim();
+    if (cleanType === "number") {
+      const parsed = Number(value);
+      if (isNaN(parsed)) throw new Error(`Flag --${kebabName} must be a number`);
+      input[cleanName] = parsed;
+    } else if (cleanType === "boolean") {
+      input[cleanName] = value === true || value === "true";
+    } else {
+      input[cleanName] = String(value);
+    }
+  }
+  return input;
+}
+async function executePluginCommand(command, input, viteServer) {
+  const cliCommand = await loadCommandHandler(command, viteServer);
+  const services = resolveServices(cliCommand.services);
+  return cliCommand.handler(input, ...services);
+}
+async function loadCommandHandler(command, viteServer) {
+  let module;
+  if (command.isLocal) {
+    const moduleFile = command.pluginModule || "index";
+    const modulePath = path.resolve(command.pluginPath, moduleFile);
+    if (viteServer) {
+      module = await viteServer.ssrLoadModule(modulePath);
+    } else {
+      module = await import(modulePath);
+    }
+  } else {
+    if (viteServer) {
+      module = await viteServer.ssrLoadModule(command.packageName);
+    } else {
+      module = await import(command.packageName);
+    }
+  }
+  for (const [, exported] of Object.entries(module)) {
+    if (isJayCliCommand(exported) && exported.commandName === command.commandName) {
+      return exported;
+    }
+  }
+  const byName = module[command.handlerExport];
+  if (byName && isJayCliCommand(byName)) {
+    return byName;
+  }
+  throw new Error(
+    `CLI command "${command.commandName}" not found as export in "${command.isLocal ? command.pluginPath : command.packageName}". Available exports: ${Object.keys(module).join(", ")}`
+  );
+}
+class SetupNeedsAnswerError extends Error {
+  constructor(plugin, key, type, promptMessage, choices) {
+    super(`Setup needs answer for "${key}": ${promptMessage}`);
+    this.plugin = plugin;
+    this.key = key;
+    this.type = type;
+    this.promptMessage = promptMessage;
+    this.choices = choices;
+    this.name = "SetupNeedsAnswerError";
+  }
+}
+async function discoverPluginsWithSetup(options) {
+  const { projectRoot, verbose, pluginFilter } = options;
+  const allPlugins = await scanPlugins({
+    projectRoot,
+    verbose,
+    includeDevDeps: true,
+    discoverTransitive: true
+  });
+  const pluginsWithSetup = [];
+  for (const [packageName, plugin] of allPlugins) {
+    if (!plugin.manifest.setup) continue;
+    if (pluginFilter && plugin.name !== pluginFilter && packageName !== pluginFilter) {
+      continue;
+    }
+    pluginsWithSetup.push({
+      name: plugin.name,
+      pluginPath: plugin.pluginPath,
+      packageName: plugin.packageName,
+      isLocal: plugin.isLocal,
+      setupHandler: plugin.manifest.setup,
+      setupDescription: plugin.manifest.description,
+      dependencies: plugin.dependencies
+    });
+    if (verbose) {
+      getLogger().info(`[Setup] Found plugin with setup: ${plugin.name}`);
+    }
+  }
+  return sortPluginsByDependencies(pluginsWithSetup);
+}
+async function discoverPluginsWithAgentKit(options) {
+  const { projectRoot, verbose, pluginFilter } = options;
+  const allPlugins = await scanPlugins({
+    projectRoot,
+    verbose,
+    includeDevDeps: true,
+    discoverTransitive: true
+  });
+  const pluginsWithAgentKit = [];
+  for (const [packageName, plugin] of allPlugins) {
+    if (!plugin.manifest.agentkit) continue;
+    if (pluginFilter && plugin.name !== pluginFilter && packageName !== pluginFilter) {
+      continue;
+    }
+    pluginsWithAgentKit.push({
+      name: plugin.name,
+      pluginPath: plugin.pluginPath,
+      packageName: plugin.packageName,
+      isLocal: plugin.isLocal,
+      agentKitHandler: plugin.manifest.agentkit,
+      dependencies: plugin.dependencies
+    });
+    if (verbose) {
+      getLogger().info(`[AgentKit] Found plugin with agent-kit handler: ${plugin.name}`);
+    }
+  }
+  return sortPluginsByDependencies(pluginsWithAgentKit);
+}
+async function executePluginSetup(plugin, options) {
+  const { projectRoot, configDir, force, interactive, prompt, initError, viteServer } = options;
+  const context = {
+    pluginName: plugin.name,
+    projectRoot,
+    configDir,
+    services: getServiceRegistry(),
+    initError,
+    force,
+    interactive,
+    prompt
+  };
+  const handler = await loadHandler(plugin, plugin.setupHandler, viteServer);
+  return handler(context);
+}
+async function executePluginAgentKit(plugin, options) {
+  const { projectRoot, force, initError, viteServer } = options;
+  const referencesDir = path.join(projectRoot, "agent-kit", "references", plugin.name);
+  const context = {
+    pluginName: plugin.name,
+    projectRoot,
+    referencesDir,
+    services: getServiceRegistry(),
+    initError,
+    force
+  };
+  const handler = await loadHandler(
+    plugin,
+    plugin.agentKitHandler,
+    viteServer
+  );
+  return handler(context);
+}
+async function loadHandler(plugin, handlerName, viteServer) {
+  let module;
+  if (plugin.isLocal) {
+    const handlerPath = path.resolve(plugin.pluginPath, handlerName);
+    if (viteServer) {
+      module = await viteServer.ssrLoadModule(handlerPath);
+    } else {
+      module = await import(handlerPath);
+    }
+    if (typeof module[handlerName] === "function") return module[handlerName];
+    if (typeof module.agentkit === "function") return module.agentkit;
+    if (typeof module.setup === "function") return module.setup;
+    if (typeof module.default === "function") return module.default;
+    throw new Error(
+      `Handler "${handlerName}" not found in "${plugin.pluginPath}". Available exports: ${Object.keys(module).join(", ")}`
+    );
+  } else {
+    if (viteServer) {
+      module = await viteServer.ssrLoadModule(plugin.packageName);
+    } else {
+      module = await import(plugin.packageName);
+    }
+    if (typeof module[handlerName] !== "function") {
+      throw new Error(
+        `Handler "${handlerName}" not found as export in "${plugin.packageName}". Available exports: ${Object.keys(module).join(", ")}`
+      );
+    }
+    return module[handlerName];
+  }
+}
+const CACHE_TAG_START = '<script type="application/jay-cache">';
+const CACHE_TAG_END = "<\/script>";
+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);
+}
+function embedCacheMetadata(jayHtmlContent, slowViewState, carryForward, sourcePath) {
+  const metadata = JSON.stringify({ slowViewState, carryForward, sourcePath });
+  const cacheTag = `${CACHE_TAG_START}${metadata}${CACHE_TAG_END}`;
+  const headMatch = jayHtmlContent.match(/<head[^>]*>/i);
+  if (headMatch) {
+    const insertPos = headMatch.index + headMatch[0].length;
+    return jayHtmlContent.substring(0, insertPos) + "\n" + cacheTag + jayHtmlContent.substring(insertPos);
+  }
+  return `${cacheTag}
+${jayHtmlContent}`;
+}
+function extractCacheMetadata(fileContent) {
+  const startIdx = fileContent.indexOf(CACHE_TAG_START);
+  if (startIdx === -1) return void 0;
+  const jsonStart = startIdx + CACHE_TAG_START.length;
+  const endIdx = fileContent.indexOf(CACHE_TAG_END, jsonStart);
+  if (endIdx === -1) return void 0;
+  const jsonStr = fileContent.substring(jsonStart, endIdx);
+  const metadata = JSON.parse(jsonStr);
+  const tagEnd = endIdx + CACHE_TAG_END.length;
+  const afterTag = fileContent[tagEnd] === "\n" ? tagEnd + 1 : tagEnd;
+  const content = fileContent.substring(0, startIdx) + fileContent.substring(afterTag);
+  return {
+    content,
+    slowViewState: metadata.slowViewState,
+    carryForward: metadata.carryForward,
+    sourcePath: metadata.sourcePath
+  };
+}
+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) {
+    /** Maps source jay-html path → set of pre-rendered file paths (for invalidation) */
+    __publicField(this, "pathToFiles", /* @__PURE__ */ new Map());
+    __publicField(this, "cacheDir");
+    __publicField(this, "pagesRoot");
+    this.cacheDir = cacheDir;
+    this.pagesRoot = pagesRoot;
+  }
+  /**
+   * Get a cached pre-rendered jay-html entry by reading from disk.
+   * Returns undefined if the cache file doesn't exist or has no metadata tag.
+   */
+  async get(jayHtmlPath, params, routeDir) {
+    const preRenderedPath = this.computeCachePath(jayHtmlPath, params, routeDir);
+    let fileContent;
+    try {
+      fileContent = await fs$1.readFile(preRenderedPath, "utf-8");
+    } catch {
+      return void 0;
+    }
+    const extracted = extractCacheMetadata(fileContent);
+    if (!extracted) return void 0;
+    this.trackFile(jayHtmlPath, preRenderedPath);
+    return {
+      preRenderedPath,
+      preRenderedContent: extracted.content,
+      slowViewState: extracted.slowViewState,
+      carryForward: extracted.carryForward,
+      sourcePath: extracted.sourcePath
+    };
+  }
+  /**
+   * Store a pre-rendered jay-html entry.
+   * Embeds metadata as a <script> tag and writes to disk.
+   * Returns the full cache entry with stripped content.
+   */
+  async set(jayHtmlPath, params, preRenderedJayHtml, slowViewState, carryForward, routeDir) {
+    const preRenderedPath = this.computeCachePath(jayHtmlPath, params, routeDir);
+    const fileContent = embedCacheMetadata(
+      preRenderedJayHtml,
+      slowViewState,
+      carryForward,
+      jayHtmlPath
+    );
+    await fs$1.mkdir(path__default.dirname(preRenderedPath), { recursive: true });
+    await fs$1.writeFile(preRenderedPath, fileContent, "utf-8");
+    this.trackFile(jayHtmlPath, preRenderedPath);
+    return {
+      preRenderedPath,
+      preRenderedContent: preRenderedJayHtml,
+      slowViewState,
+      carryForward,
+      sourcePath: jayHtmlPath
+    };
+  }
+  /**
+   * Check if a pre-rendered entry exists for the given path and params
+   */
+  async has(jayHtmlPath, params, routeDir) {
+    const preRenderedPath = this.computeCachePath(jayHtmlPath, params, routeDir);
+    try {
+      await fs$1.access(preRenderedPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Invalidate all cached entries for a given jay-html source path.
+   * Deletes cached files from disk.
+   */
+  async invalidate(jayHtmlPath) {
+    const files = this.pathToFiles.get(jayHtmlPath);
+    if (files) {
+      for (const filePath of files) {
+        try {
+          await fs$1.unlink(filePath);
+        } catch {
+        }
+      }
+      this.pathToFiles.delete(jayHtmlPath);
+    }
+    await this.scanAndDeleteCacheFiles(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 files of this.pathToFiles.values()) {
+      for (const filePath of files) {
+        try {
+          await fs$1.unlink(filePath);
+        } catch {
+        }
+      }
+    }
+    this.pathToFiles.clear();
+    try {
+      await fs$1.rm(this.cacheDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  /**
+   * Get all cached jay-html paths (for debugging/monitoring)
+   */
+  getCachedPaths() {
+    return Array.from(this.pathToFiles.keys());
+  }
+  /**
+   * Compute the cache file path for a given jay-html path and params.
+   */
+  computeCachePath(jayHtmlPath, params, routeDir) {
+    let dir;
+    if (routeDir) {
+      dir = routeDir;
+    } else {
+      const relativePath = path__default.relative(this.pagesRoot, jayHtmlPath);
+      dir = relativePath.startsWith("..") ? path__default.join(
+        "_plugins",
+        crypto.createHash("md5").update(jayHtmlPath).digest("hex").slice(0, 12)
+      ) : path__default.dirname(relativePath);
+    }
+    const basename = path__default.basename(jayHtmlPath, ".jay-html");
+    const paramsHash = hashParams(params);
+    const cacheFileName = `${basename}${paramsHash}.jay-html`;
+    return path__default.join(this.cacheDir, dir, cacheFileName);
+  }
+  /**
+   * Track a pre-rendered file path for invalidation.
+   */
+  trackFile(jayHtmlPath, preRenderedPath) {
+    if (!this.pathToFiles.has(jayHtmlPath)) {
+      this.pathToFiles.set(jayHtmlPath, /* @__PURE__ */ new Set());
+    }
+    this.pathToFiles.get(jayHtmlPath).add(preRenderedPath);
+  }
+  /**
+   * Scan the cache directory for files matching a route and delete them.
+   * Handles the startup case where pathToFiles is not populated from a previous session.
+   */
+  async scanAndDeleteCacheFiles(jayHtmlPath) {
+    const relativePath = path__default.relative(this.pagesRoot, jayHtmlPath);
+    const dir = relativePath.startsWith("..") ? path__default.join(
+      "_plugins",
+      crypto.createHash("md5").update(jayHtmlPath).digest("hex").slice(0, 12)
+    ) : path__default.dirname(relativePath);
+    const basename = path__default.basename(jayHtmlPath, ".jay-html");
+    const cacheSubDir = path__default.join(this.cacheDir, dir);
+    try {
+      const files = await fs$1.readdir(cacheSubDir);
+      for (const file of files) {
+        if (file.startsWith(basename)) {
+          try {
+            await fs$1.unlink(path__default.join(cacheSubDir, file));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+}
+export {
+  SetupNeedsAnswerError,
+  SlowRenderCache,
+  buildAutomationWrap,
+  buildScriptFragments,
+  clearServerElementCache,
+  commandSchemaToFlags,
+  discoverAllPluginActions,
+  discoverAndRegisterActions,
+  discoverPluginActions,
+  discoverPluginCommands,
+  discoverPluginsWithAgentKit,
+  discoverPluginsWithSetup,
+  executePluginAgentKit,
+  executePluginCommand,
+  executePluginSetup,
+  generateClientScript,
+  generateFrozenPageHtml,
+  generatePromiseReconstruction,
+  generateSSRPageHtml,
+  headMetaToHeadTags,
+  invalidateServerElementCache,
+  listContracts,
+  loadActionMetadata,
+  loadPageParts,
+  materializeContracts,
+  parseActionMetadata,
+  parseInputFromFlags,
+  resolveActionMetadataPath,
+  resolveViewStatePromises
+};