@jay-framework/jay-stack-cli 0.22.1 → 0.23.0

package/dist/index.js

@@ -2,20 +2,19 @@
 import express from "express";
 import http from "node:http";
 import { mkDevServer, createViteForCli } from "@jay-framework/dev-server";
-import { createEditorServer } from "@jay-framework/editor-server";
 import getPort from "get-port";
 import path from "path";
 import fs, { promises } from "fs";
 import YAML from "yaml";
 import { getLogger, setDevLogger, createDevLogger } from "@jay-framework/logger";
-import { parseJayFile, JAY_IMPORT_RESOLVER, generateElementDefinitionFile, ContractTagType, parseContract, generateElementFile, generateServerElementFile, htmlElementTagNameMap, loadLinkedContract, getLinkedContractDir } from "@jay-framework/compiler-jay-html";
-import { JAY_CONTRACT_EXTENSION, JAY_EXTENSION, resolvePluginManifest, LOCAL_PLUGIN_PATH, JayAtomicType, JayEnumType, loadPluginManifest, RuntimeMode, GenerateTarget, findDynamicContract } from "@jay-framework/compiler-shared";
-import { scanPlugins as scanPlugins$1, listContracts, materializeContracts, SetupNeedsAnswerError } from "@jay-framework/stack-server-runtime";
+import { JAY_IMPORT_RESOLVER, parseJayFile, generateElementDefinitionFile, parseContract, generateElementFile, generateServerElementFile, htmlElementTagNameMap, loadLinkedContract, getLinkedContractDir } from "@jay-framework/compiler-jay-html";
+import { scanPlugins, listContracts, materializeContracts, SetupNeedsAnswerError, discoverPluginsWithSetup, discoverPluginsWithInit, sortPluginsByDependencies, executePluginSetup, executePluginServerInits, runInitCallbacks } from "@jay-framework/stack-server-runtime";
 import { listContracts as listContracts2, materializeContracts as materializeContracts2 } from "@jay-framework/stack-server-runtime";
 import { Command } from "commander";
 import chalk from "chalk";
 import path$1 from "node:path";
 import fs$1 from "node:fs/promises";
+import { loadPluginManifest, JAY_EXTENSION, RuntimeMode, GenerateTarget, JAY_CONTRACT_EXTENSION, findDynamicContract } from "@jay-framework/compiler-shared";
 import { createRequire } from "module";
 import { glob } from "glob";
 import fsSync from "node:fs";
@@ -28,9 +27,6 @@ const DEFAULT_CONFIG = {
     componentsBase: "./src/components",
     publicFolder: "./public",
     configBase: "./config"
-  },
-  editorServer: {
-    portRange: [3101, 3200]
   }
 };
 function loadConfig() {
@@ -45,2317 +41,42 @@ function loadConfig() {
       devServer: {
         ...DEFAULT_CONFIG.devServer,
         ...userConfig.devServer
-      },
-      editorServer: {
-        ...DEFAULT_CONFIG.editorServer,
-        ...userConfig.editorServer
-      }
-    };
-  } catch (error) {
-    getLogger().warn(`Failed to parse .jay YAML config file, using defaults: ${error}`);
-    return DEFAULT_CONFIG;
-  }
-}
-function getConfigWithDefaults(config) {
-  return {
-    devServer: {
-      portRange: config.devServer?.portRange || DEFAULT_CONFIG.devServer.portRange,
-      pagesBase: config.devServer?.pagesBase || DEFAULT_CONFIG.devServer.pagesBase,
-      componentsBase: config.devServer?.componentsBase || DEFAULT_CONFIG.devServer.componentsBase,
-      publicFolder: config.devServer?.publicFolder || DEFAULT_CONFIG.devServer.publicFolder,
-      configBase: config.devServer?.configBase || DEFAULT_CONFIG.devServer.configBase
-    },
-    editorServer: {
-      portRange: config.editorServer?.portRange || DEFAULT_CONFIG.editorServer.portRange,
-      editorId: config.editorServer?.editorId
-    }
-  };
-}
-function updateConfig(updates) {
-  const configPath = path.resolve(".jay");
-  try {
-    const existingConfig = loadConfig();
-    const updatedConfig = {
-      ...existingConfig,
-      ...updates,
-      devServer: {
-        ...existingConfig.devServer,
-        ...updates.devServer
-      },
-      editorServer: {
-        ...existingConfig.editorServer,
-        ...updates.editorServer
-      }
-    };
-    const yamlContent = YAML.stringify(updatedConfig, { indent: 2 });
-    fs.writeFileSync(configPath, yamlContent);
-  } catch (error) {
-    getLogger().warn(`Failed to update .jay config file: ${error}`);
-  }
-}
-function rgbToHex(color, opacity) {
-  const r = Math.round(color.r * 255);
-  const g = Math.round(color.g * 255);
-  const b = Math.round(color.b * 255);
-  if (opacity !== void 0 && opacity < 1) {
-    const alphaHex = Math.round(opacity * 255).toString(16).padStart(2, "0");
-    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}${alphaHex}`;
-  } else {
-    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
-  }
-}
-function getPositionType(node) {
-  if (node.layoutPositioning === "ABSOLUTE") {
-    return "absolute";
-  }
-  if (node.parentOverflowDirection && node.parentOverflowDirection !== "NONE") {
-    if (node.parentNumberOfFixedChildren && node.parentChildIndex !== void 0) {
-      if (node.parentChildIndex >= 0 && node.parentChildIndex < node.parentNumberOfFixedChildren) {
-        return "sticky";
-      }
-    }
-  }
-  if (node.scrollBehavior === "FIXED" && node.parentLayoutMode === "NONE") {
-    return "fixed";
-  }
-  if (node.parentType === "SECTION") {
-    return "absolute";
-  }
-  if (node.parentLayoutMode === "NONE") {
-    return "absolute";
-  }
-  if (node.parentLayoutMode && (node.parentLayoutMode === "HORIZONTAL" || node.parentLayoutMode === "VERTICAL")) {
-    return "relative";
-  }
-  return "static";
-}
-function getPositionStyle(node) {
-  if (node.type === "COMPONENT") {
-    return "";
-  }
-  const positionType = getPositionType(node);
-  if (positionType === "static") {
-    return "";
-  }
-  if (positionType === "absolute" || positionType === "fixed") {
-    const top = node.y !== void 0 ? node.y : 0;
-    const left = node.x !== void 0 ? node.x : 0;
-    return `position: ${positionType};top: ${top}px;left: ${left}px;`;
-  }
-  if (positionType === "sticky") {
-    return `position: ${positionType};top: 0;z-index: 10;`;
-  }
-  return `position: ${positionType};`;
-}
-function getAutoLayoutChildSizeStyles(node) {
-  if (!node.parentLayoutMode || node.parentLayoutMode === "NONE") {
-    const width2 = node.width !== void 0 ? node.width : 0;
-    const height2 = node.height !== void 0 ? node.height : 0;
-    return `width: ${width2}px;height: ${height2}px;`;
-  }
-  let styles = "";
-  if (!node.layoutGrow && !node.layoutAlign) {
-    const width2 = node.width !== void 0 ? node.width : 0;
-    const height2 = node.height !== void 0 ? node.height : 0;
-    return `width: ${width2}px;height: ${height2}px;`;
-  }
-  const isHorizontalLayout = node.parentLayoutMode === "HORIZONTAL";
-  const width = node.width !== void 0 ? node.width : 0;
-  const height = node.height !== void 0 ? node.height : 0;
-  if (node.layoutSizingHorizontal) {
-    switch (node.layoutSizingHorizontal) {
-      case "FIXED":
-        styles += `width: ${width}px;`;
-        break;
-      case "HUG":
-        styles += "width: fit-content;";
-        break;
-      case "FILL":
-        if (node.type === "TEXT") {
-          styles += "width: auto;";
-        } else if (isHorizontalLayout) {
-          styles += "flex-grow: 1;";
-        } else {
-          styles += "width: 100%;";
-        }
-        break;
-    }
-  } else {
-    if (isHorizontalLayout && node.layoutGrow && node.layoutGrow > 0) {
-      styles += `flex-grow: ${node.layoutGrow};width: 0;`;
-    } else if (!isHorizontalLayout && node.layoutAlign === "STRETCH") {
-      styles += "width: 100%;";
-    } else {
-      styles += `width: ${width}px;`;
-    }
-  }
-  if (node.layoutSizingVertical) {
-    switch (node.layoutSizingVertical) {
-      case "FIXED":
-        styles += `height: ${height}px;`;
-        break;
-      case "HUG":
-        styles += "height: fit-content;";
-        break;
-      case "FILL":
-        if (!isHorizontalLayout) {
-          styles += "flex-grow: 1;";
-        } else {
-          styles += "height: 100%;";
-        }
-        break;
-    }
-  } else {
-    if (!isHorizontalLayout && node.layoutGrow && node.layoutGrow > 0) {
-      styles += `flex-grow: ${node.layoutGrow};height: 0;`;
-    } else if (isHorizontalLayout && node.layoutAlign === "STRETCH") {
-      styles += "height: 100%;";
-    } else {
-      styles += `height: ${height}px;`;
-    }
-  }
-  if (node.layoutAlign) {
-    switch (node.layoutAlign) {
-      case "MIN":
-        styles += "align-self: flex-start;";
-        break;
-      case "CENTER":
-        styles += "align-self: center;";
-        break;
-      case "MAX":
-        styles += "align-self: flex-end;";
-        break;
-      case "STRETCH":
-        styles += "align-self: stretch;";
-        break;
-    }
-  }
-  return styles;
-}
-function getNodeSizeStyles(node) {
-  if (node.parentType === "SECTION") {
-    const height = node.height !== void 0 ? node.height : 0;
-    return `width: 100%;height: ${height}px;`;
-  }
-  return getAutoLayoutChildSizeStyles(node);
-}
-function getCommonStyles(node) {
-  let styles = "";
-  const transformStyles = [];
-  if (node.opacity !== void 0 && node.opacity < 1) {
-    styles += `opacity: ${node.opacity};`;
-  }
-  if (node.rotation !== void 0 && node.rotation !== 0) {
-    transformStyles.push(`rotate(${node.rotation}deg)`);
-  }
-  if (node.effects && Array.isArray(node.effects) && node.effects.length > 0) {
-    const visibleEffects = node.effects.filter((e2) => e2.visible !== false).reverse();
-    const filterFunctions = [];
-    const boxShadows = [];
-    for (const effect of visibleEffects) {
-      switch (effect.type) {
-        case "DROP_SHADOW":
-        case "INNER_SHADOW": {
-          if (effect.color && effect.offset && effect.radius !== void 0) {
-            const { offset, radius, color, spread } = effect;
-            const shadowColor = `rgba(${Math.round(color.r * 255)}, ${Math.round(color.g * 255)}, ${Math.round(color.b * 255)}, ${color.a ?? 1})`;
-            const inset = effect.type === "INNER_SHADOW" ? "inset " : "";
-            boxShadows.push(
-              `${inset}${offset.x}px ${offset.y}px ${radius}px ${spread ?? 0}px ${shadowColor}`
-            );
-          }
-          break;
-        }
-        case "LAYER_BLUR":
-          if (effect.radius !== void 0) {
-            filterFunctions.push(`blur(${effect.radius}px)`);
-          }
-          break;
-        case "BACKGROUND_BLUR":
-          if (effect.radius !== void 0) {
-            styles += `backdrop-filter: blur(${effect.radius}px);`;
-            styles += `-webkit-backdrop-filter: blur(${effect.radius}px);`;
-          }
-          break;
-      }
-    }
-    if (boxShadows.length > 0) {
-      styles += `box-shadow: ${boxShadows.join(", ")};`;
-    }
-    if (filterFunctions.length > 0) {
-      styles += `filter: ${filterFunctions.join(" ")};`;
-    }
-  }
-  if (transformStyles.length > 0) {
-    styles += `transform: ${transformStyles.join(" ")};`;
-    const width = node.width !== void 0 ? node.width : 0;
-    const height = node.height !== void 0 ? node.height : 0;
-    styles += `transform-origin: ${width / 2}px ${height / 2}px;`;
-  }
-  return styles;
-}
-function getBorderRadius(node) {
-  if (typeof node.cornerRadius === "number") {
-    return `border-radius: ${node.cornerRadius}px;`;
-  } else if (node.cornerRadius === "MIXED" && node.topLeftRadius !== void 0) {
-    return `border-radius: ${node.topLeftRadius}px ${node.topRightRadius}px ${node.bottomRightRadius}px ${node.bottomLeftRadius}px;`;
-  }
-  return "border-radius: 0px;";
-}
-function getAutoLayoutStyles(node) {
-  if (node.layoutMode === "NONE" || !node.layoutMode) {
-    return "";
-  }
-  let flexStyles = "display: flex;";
-  if (node.layoutMode === "HORIZONTAL") {
-    flexStyles += "flex-direction: row;";
-  } else if (node.layoutMode === "VERTICAL") {
-    flexStyles += "flex-direction: column;";
-  }
-  if (node.primaryAxisAlignItems) {
-    switch (node.primaryAxisAlignItems) {
-      case "MIN":
-        flexStyles += "justify-content: flex-start;";
-        break;
-      case "CENTER":
-        flexStyles += "justify-content: center;";
-        break;
-      case "MAX":
-        flexStyles += "justify-content: flex-end;";
-        break;
-      case "SPACE_BETWEEN":
-        flexStyles += "justify-content: space-between;";
-        break;
-    }
-  }
-  if (node.counterAxisAlignItems) {
-    switch (node.counterAxisAlignItems) {
-      case "MIN":
-        flexStyles += "align-items: flex-start;";
-        break;
-      case "CENTER":
-        flexStyles += "align-items: center;";
-        break;
-      case "MAX":
-        flexStyles += "align-items: flex-end;";
-        break;
-    }
-  }
-  if (typeof node.itemSpacing === "number") {
-    flexStyles += `gap: ${node.itemSpacing}px;`;
-  }
-  if (typeof node.paddingLeft === "number")
-    flexStyles += `padding-left: ${node.paddingLeft}px;`;
-  if (typeof node.paddingRight === "number")
-    flexStyles += `padding-right: ${node.paddingRight}px;`;
-  if (typeof node.paddingTop === "number")
-    flexStyles += `padding-top: ${node.paddingTop}px;`;
-  if (typeof node.paddingBottom === "number")
-    flexStyles += `padding-bottom: ${node.paddingBottom}px;`;
-  return flexStyles;
-}
-function getOverflowStyles(node) {
-  let overflowStyles = "";
-  const shouldClip = node.clipsContent;
-  const overflowDirection = node.overflowDirection || "NONE";
-  switch (overflowDirection) {
-    case "HORIZONTAL":
-      overflowStyles += shouldClip ? "overflow-x: auto; overflow-y: hidden;" : "overflow-x: auto; overflow-y: visible;";
-      break;
-    case "VERTICAL":
-      overflowStyles += shouldClip ? "overflow-x: hidden; overflow-y: auto;" : "overflow-x: visible; overflow-y: auto;";
-      break;
-    case "BOTH":
-      overflowStyles += "overflow: auto;";
-      break;
-    case "NONE":
-    default:
-      overflowStyles += shouldClip ? "overflow: hidden;" : "overflow: visible;";
-      break;
-  }
-  if (overflowDirection !== "NONE") {
-    overflowStyles += "scrollbar-width: thin; scrollbar-color: rgba(0, 0, 0, 0.3) transparent;";
-  }
-  return overflowStyles;
-}
-function getBackgroundFillsStyle(node) {
-  if (!node.fills || !Array.isArray(node.fills) || node.fills.length === 0) {
-    return "background: transparent;";
-  }
-  const backgrounds = [];
-  const backgroundSizes = [];
-  const backgroundPositions = [];
-  const backgroundRepeats = [];
-  for (const fill of [...node.fills].reverse()) {
-    if (fill.visible === false)
-      continue;
-    if (fill.type === "SOLID" && fill.color) {
-      const { r, g, b } = fill.color;
-      const opacity = fill.opacity !== void 0 ? fill.opacity : 1;
-      backgrounds.push(
-        `linear-gradient(rgba(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)}, ${opacity}), rgba(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)}, ${opacity}))`
-      );
-      backgroundSizes.push("100% 100%");
-      backgroundPositions.push("center");
-      backgroundRepeats.push("no-repeat");
-    } else if (fill.type === "IMAGE") {
-      console.warn("Image fills are not yet supported in vendor conversion");
-    }
-  }
-  if (backgrounds.length === 0) {
-    return "background: transparent;";
-  }
-  let style = `background-image: ${backgrounds.join(", ")};`;
-  style += `background-size: ${backgroundSizes.join(", ")};`;
-  style += `background-position: ${backgroundPositions.join(", ")};`;
-  style += `background-repeat: ${backgroundRepeats.join(", ")};`;
-  return style;
-}
-function getStrokeStyles(node) {
-  if (!node.strokes || node.strokes.length === 0) {
-    return "";
-  }
-  const visibleStrokes = node.strokes.filter((s2) => s2.visible !== false);
-  if (visibleStrokes.length === 0) {
-    return "";
-  }
-  const stroke = visibleStrokes[0];
-  let cssProps = [];
-  if (stroke.type === "SOLID" && stroke.color) {
-    const r = Math.round(stroke.color.r * 255);
-    const g = Math.round(stroke.color.g * 255);
-    const b = Math.round(stroke.color.b * 255);
-    const a = stroke.opacity !== void 0 ? stroke.opacity : 1;
-    if (a < 1) {
-      cssProps.push(`border-color: rgba(${r}, ${g}, ${b}, ${a.toFixed(2)});`);
-    } else {
-      cssProps.push(`border-color: rgb(${r}, ${g}, ${b});`);
-    }
-  } else {
-    return "";
-  }
-  const top = typeof node.strokeTopWeight === "number" ? node.strokeTopWeight : typeof node.strokeWeight === "number" ? node.strokeWeight : 0;
-  const right = typeof node.strokeRightWeight === "number" ? node.strokeRightWeight : typeof node.strokeWeight === "number" ? node.strokeWeight : 0;
-  const bottom = typeof node.strokeBottomWeight === "number" ? node.strokeBottomWeight : typeof node.strokeWeight === "number" ? node.strokeWeight : 0;
-  const left = typeof node.strokeLeftWeight === "number" ? node.strokeLeftWeight : typeof node.strokeWeight === "number" ? node.strokeWeight : 0;
-  if (top !== 0 || right !== 0 || bottom !== 0 || left !== 0) {
-    if (top === right && right === bottom && bottom === left) {
-      cssProps.push(`border-width: ${top}px;`);
-    } else {
-      cssProps.push(`border-width: ${top}px ${right}px ${bottom}px ${left}px;`);
-    }
-    if (node.dashPattern && node.dashPattern.length > 0) {
-      cssProps.push("border-style: dashed;");
-    } else {
-      cssProps.push("border-style: solid;");
-    }
-  }
-  return cssProps.join(" ");
-}
-function getFrameSizeStyles(node) {
-  const isTopLevel = node.parentType === "SECTION";
-  if (isTopLevel) {
-    const height2 = node.height !== void 0 ? node.height : 0;
-    return `width: 100%;height: ${height2}px;`;
-  }
-  if (node.layoutMode === "NONE" || !node.layoutMode) {
-    const width2 = node.width !== void 0 ? node.width : 0;
-    const height2 = node.height !== void 0 ? node.height : 0;
-    return `width: ${width2}px;height: ${height2}px;`;
-  }
-  let sizeStyles = "";
-  const width = node.width !== void 0 ? node.width : 0;
-  const height = node.height !== void 0 ? node.height : 0;
-  if (node.layoutSizingHorizontal) {
-    switch (node.layoutSizingHorizontal) {
-      case "FIXED":
-        sizeStyles += `width: ${width}px;`;
-        break;
-      case "HUG":
-        sizeStyles += "width: fit-content;";
-        break;
-      case "FILL":
-        sizeStyles += "width: 100%;";
-        break;
-    }
-  } else {
-    sizeStyles += `width: ${width}px;`;
-  }
-  if (node.layoutSizingVertical) {
-    switch (node.layoutSizingVertical) {
-      case "FIXED":
-        sizeStyles += `height: ${height}px;`;
-        break;
-      case "HUG":
-        sizeStyles += "height: fit-content;";
-        break;
-      case "FILL":
-        sizeStyles += "height: 100%;";
-        break;
-    }
-  } else {
-    sizeStyles += `height: ${height}px;`;
-  }
-  if (node.layoutWrap === "WRAP") {
-    sizeStyles += `max-width: ${width}px;`;
-  }
-  return sizeStyles;
-}
-function escapeHtmlContent(text) {
-  const map = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;"
-  };
-  return text.replace(/[&<>"']/g, (char) => map[char]);
-}
-function convertTextNodeToHtml(node, indent, dynamicContent, refAttr, attributesHtml) {
-  const {
-    name,
-    id,
-    characters,
-    fontName,
-    fontSize,
-    fontWeight,
-    fills,
-    textAlignHorizontal,
-    textAlignVertical,
-    letterSpacing,
-    lineHeight,
-    textDecoration,
-    textCase,
-    textTruncation,
-    maxLines,
-    maxWidth,
-    textAutoResize,
-    hasMissingFont,
-    hyperlinks
-  } = node;
-  if (hasMissingFont || !characters) {
-    if (hasMissingFont) {
-      return `${indent}<!-- Text node "${name}" has missing fonts -->
-`;
-    }
-    return "";
-  }
-  let fontFamilyStyle = "font-family: sans-serif;";
-  if (fontName && typeof fontName === "object" && fontName.family) {
-    fontFamilyStyle = `font-family: '${fontName.family}', sans-serif;`;
-  }
-  const fontSizeValue = typeof fontSize === "number" ? fontSize : 16;
-  const fontSizeStyle = `font-size: ${fontSizeValue}px;`;
-  const fontWeightValue = typeof fontWeight === "number" ? fontWeight : 400;
-  const fontWeightStyle = `font-weight: ${fontWeightValue};`;
-  let textColor = "#000000";
-  if (fills && Array.isArray(fills) && fills.length > 0 && fills[0].type === "SOLID" && fills[0].color) {
-    textColor = rgbToHex(fills[0].color);
-  }
-  const colorStyle = `color: ${textColor};`;
-  const textAlign = textAlignHorizontal ? textAlignHorizontal.toLowerCase() : "left";
-  const textAlignStyle = `text-align: ${textAlign};`;
-  let verticalAlignWrapperStyle = "";
-  if (textAlignVertical) {
-    verticalAlignWrapperStyle = "display: flex; flex-direction: column;";
-    switch (textAlignVertical) {
-      case "TOP":
-        verticalAlignWrapperStyle += "justify-content: flex-start;";
-        break;
-      case "CENTER":
-        verticalAlignWrapperStyle += "justify-content: center;";
-        break;
-      case "BOTTOM":
-        verticalAlignWrapperStyle += "justify-content: flex-end;";
-        break;
-    }
-  }
-  let letterSpacingStyle = "";
-  if (letterSpacing && letterSpacing.value !== 0) {
-    const unit = letterSpacing.unit === "PIXELS" ? "px" : "%";
-    letterSpacingStyle = `letter-spacing: ${letterSpacing.value}${unit};`;
-  }
-  let lineHeightStyle = "";
-  if (lineHeight) {
-    if (lineHeight.unit === "AUTO") {
-      lineHeightStyle = "line-height: normal;";
-    } else {
-      const unit = lineHeight.unit === "PIXELS" ? "px" : "%";
-      lineHeightStyle = `line-height: ${lineHeight.value}${unit};`;
-    }
-  }
-  let textDecorationStyle = "";
-  if (textDecoration === "UNDERLINE") {
-    textDecorationStyle = "text-decoration: underline;";
-  } else if (textDecoration === "STRIKETHROUGH") {
-    textDecorationStyle = "text-decoration: line-through;";
-  }
-  let textTransformStyle = "";
-  if (textCase && textCase !== "ORIGINAL") {
-    switch (textCase) {
-      case "UPPER":
-        textTransformStyle = "text-transform: uppercase;";
-        break;
-      case "LOWER":
-        textTransformStyle = "text-transform: lowercase;";
-        break;
-      case "TITLE":
-        textTransformStyle = "text-transform: capitalize;";
-        break;
-    }
-  }
-  let truncationStyle = "";
-  if (textTruncation === "ENDING") {
-    if (maxLines && maxLines > 1) {
-      truncationStyle = `display: -webkit-box; -webkit-line-clamp: ${maxLines}; -webkit-box-orient: vertical; overflow: hidden;`;
-    } else {
-      truncationStyle = "white-space: nowrap; overflow: hidden; text-overflow: ellipsis;";
-    }
-  }
-  if (maxWidth && maxWidth > 0) {
-    truncationStyle += `max-width: ${maxWidth}px;`;
-  }
-  const positionStyle = getPositionStyle(node);
-  let sizeStyles = getNodeSizeStyles(node);
-  const commonStyles = getCommonStyles(node);
-  if (textAutoResize === "HEIGHT") {
-    sizeStyles = sizeStyles.replace(/height: [^;]+;/, "height: auto;");
-  }
-  const textStyles = `${fontFamilyStyle}${fontSizeStyle}${fontWeightStyle}${colorStyle}${textAlignStyle}${letterSpacingStyle}${lineHeightStyle}${textDecorationStyle}${textTransformStyle}${truncationStyle}`;
-  let htmlContent = "";
-  if (dynamicContent) {
-    htmlContent = dynamicContent;
-  } else if (hyperlinks && hyperlinks.length > 0) {
-    let lastEnd = 0;
-    for (const link of hyperlinks) {
-      if (link.start > lastEnd) {
-        const beforeText = characters.substring(lastEnd, link.start);
-        htmlContent += escapeHtmlContent(beforeText).replace(/\n/g, "<br>");
-      }
-      const linkText = characters.substring(link.start, link.end + 1);
-      htmlContent += `<a href="${escapeHtmlContent(link.url)}" style="color: inherit;">${escapeHtmlContent(linkText).replace(/\n/g, "<br>")}</a>`;
-      lastEnd = link.end + 1;
-    }
-    if (lastEnd < characters.length) {
-      const afterText = characters.substring(lastEnd);
-      htmlContent += escapeHtmlContent(afterText).replace(/\n/g, "<br>");
-    }
-  } else {
-    htmlContent = escapeHtmlContent(characters).replace(/\n/g, "<br>");
-  }
-  const childIndent = indent + "  ";
-  const innerIndent = indent + "    ";
-  const styleAttr = `${positionStyle}${sizeStyles}${commonStyles}${textStyles}`;
-  const refString = refAttr || "";
-  const attrsString = attributesHtml || "";
-  if (verticalAlignWrapperStyle) {
-    return `${indent}<div data-figma-id="${id}"${refString}${attrsString} style="${styleAttr}${verticalAlignWrapperStyle}">
-${childIndent}<div style="${textStyles}">
-${innerIndent}${htmlContent}
-${childIndent}</div>
-${indent}</div>
-`;
-  } else {
-    return `${indent}<div data-figma-id="${id}"${refString}${attrsString} style="${styleAttr}">${htmlContent}</div>
-`;
-  }
-}
-function convertImageNodeToHtml(node, indent, srcBinding, altBinding, refAttr, staticImageUrl) {
-  const { name, id } = node;
-  const positionStyle = getPositionStyle(node);
-  const commonStyles = getCommonStyles(node);
-  const borderRadius = getBorderRadius(node);
-  const sizeStyles = getNodeSizeStyles(node);
-  const styles = `${positionStyle}${sizeStyles}${borderRadius}${commonStyles}`.trim();
-  let src = "";
-  if (srcBinding) {
-    src = srcBinding;
-  } else if (staticImageUrl) {
-    src = staticImageUrl;
-  } else {
-    src = "/placeholder-image.png";
-    console.warn(`Image node "${name}" (${id}) has no src binding or static image`);
-  }
-  const alt = altBinding || name;
-  const refAttribute = refAttr || "";
-  const styleAttribute = styles ? ` style="${styles}"` : "";
-  const dataAttribute = ` data-figma-id="${id}"`;
-  return `${indent}<img${dataAttribute}${refAttribute} src="${src}" alt="${alt}"${styleAttribute} />
-`;
-}
-function extractStaticImageUrl(node) {
-  if (!node.fills || !Array.isArray(node.fills)) {
-    return void 0;
-  }
-  for (const fill of node.fills) {
-    if (fill.visible !== false && fill.type === "IMAGE") {
-      if (fill.imageUrl) {
-        return fill.imageUrl;
-      }
-      if (fill.imageHash) {
-        console.warn(
-          `Image fill with hash "${fill.imageHash}" found on node "${node.name}" (${node.id}) but no imageUrl in serialized data. Update plugin serialization to export and save images.`
-        );
-      }
-      return void 0;
-    }
-  }
-  return void 0;
-}
-function convertRectangleToHtml(node, indent) {
-  const { id } = node;
-  const positionStyle = getPositionStyle(node);
-  const sizeStyles = getNodeSizeStyles(node);
-  const commonStyles = getCommonStyles(node);
-  const backgroundStyle = getBackgroundFillsStyle(node);
-  const borderRadius = getBorderRadius(node);
-  const strokeStyles = getStrokeStyles(node);
-  const allStyles = `${positionStyle}${sizeStyles}${backgroundStyle}${strokeStyles}${borderRadius}${commonStyles}box-sizing: border-box;`;
-  return `${indent}<div data-figma-id="${id}" style="${allStyles}"></div>
-`;
-}
-function convertEllipseToHtml(node, indent) {
-  const { id } = node;
-  const positionStyle = getPositionStyle(node);
-  const sizeStyles = getNodeSizeStyles(node);
-  const commonStyles = getCommonStyles(node);
-  const backgroundStyle = getBackgroundFillsStyle(node);
-  const strokeStyles = getStrokeStyles(node);
-  const borderRadius = "border-radius: 50%;";
-  const allStyles = `${positionStyle}${sizeStyles}${backgroundStyle}${strokeStyles}${borderRadius}${commonStyles}box-sizing: border-box;`;
-  return `${indent}<div data-figma-id="${id}" style="${allStyles}"></div>
-`;
-}
-function convertVectorToHtml(node, indent) {
-  const { id, name, svgContent, svgExportFailed, width, height } = node;
-  const positionStyle = getPositionStyle(node);
-  const sizeStyles = getNodeSizeStyles(node);
-  const commonStyles = getCommonStyles(node);
-  let finalSvgContent;
-  if (svgExportFailed || !svgContent) {
-    finalSvgContent = `<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg"><rect width="${width}" height="${height}" fill="none" stroke="#ccc" stroke-width="1" stroke-dasharray="5,5"/><text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" font-size="10" fill="#999">Vector: ${name}</text></svg>`;
-  } else {
-    finalSvgContent = svgContent;
-  }
-  const allStyles = `${positionStyle}${sizeStyles}${commonStyles}box-sizing: border-box;`;
-  const childIndent = indent + "  ";
-  return `${indent}<div data-figma-id="${id}" data-figma-type="vector" style="${allStyles}">
-${childIndent}${finalSvgContent}
-${indent}</div>
-`;
-}
-function getComponentVariantValues(node, propertyBindings) {
-  const values = /* @__PURE__ */ new Map();
-  const filterPseudoVariants = (variantValues) => {
-    return variantValues.filter((value) => !value.includes(":"));
-  };
-  if (node.componentPropertyDefinitions) {
-    for (const binding of propertyBindings) {
-      const propDef = node.componentPropertyDefinitions[binding.property];
-      if (propDef && propDef.type === "VARIANT" && propDef.variantOptions) {
-        const filtered = filterPseudoVariants(propDef.variantOptions);
-        if (filtered.length > 0) {
-          values.set(binding.property, filtered);
-        }
-      }
-    }
-  }
-  if (values.size === 0 && node.variants && node.variants.length > 0) {
-    const propertyValuesMap = /* @__PURE__ */ new Map();
-    for (const variant of node.variants) {
-      if (variant.variantProperties) {
-        for (const binding of propertyBindings) {
-          const propValue = variant.variantProperties[binding.property];
-          if (propValue && !propValue.includes(":")) {
-            if (!propertyValuesMap.has(binding.property)) {
-              propertyValuesMap.set(binding.property, /* @__PURE__ */ new Set());
-            }
-            propertyValuesMap.get(binding.property).add(propValue);
-          }
-        }
-      }
-    }
-    for (const [prop, valueSet] of propertyValuesMap) {
-      if (valueSet.size > 0) {
-        values.set(prop, Array.from(valueSet));
-      }
-    }
-  }
-  return values;
-}
-function isBooleanVariant(values, contractTag) {
-  if (contractTag.dataType !== "boolean") {
-    return false;
-  }
-  if (values.length !== 2) {
-    return false;
-  }
-  const sortedValues = [...values].sort();
-  return sortedValues[0] === "false" && sortedValues[1] === "true";
-}
-function generatePermutations(propertyValues, bindings) {
-  const properties = Array.from(propertyValues.entries());
-  if (properties.length === 0) {
-    return [];
-  }
-  const permutations = [];
-  function generate(index, current) {
-    if (index === properties.length) {
-      permutations.push([...current]);
-      return;
-    }
-    const [propName, propValues] = properties[index];
-    const binding = bindings.find((b) => b.property === propName);
-    if (!binding)
-      return;
-    const isBoolean = isBooleanVariant(propValues, binding.contractTag);
-    for (const value of propValues) {
-      current.push({ property: propName, tagPath: binding.tagPath, value, isBoolean });
-      generate(index + 1, current);
-      current.pop();
-    }
-  }
-  generate(0, []);
-  return permutations;
-}
-function findComponentVariant(node, permutation) {
-  if (!node.variants || node.variants.length === 0) {
-    throw new Error(
-      `Node "${node.name}" has no variants array - cannot find variant component`
-    );
-  }
-  const targetProps = /* @__PURE__ */ new Map();
-  for (const { property, value } of permutation) {
-    targetProps.set(property, value);
-  }
-  const matchingVariant = node.variants.find((variant) => {
-    if (!variant.variantProperties) {
-      return false;
-    }
-    for (const [prop, value] of targetProps) {
-      if (variant.variantProperties[prop] !== value) {
-        return false;
-      }
-    }
-    for (const [prop, value] of Object.entries(variant.variantProperties)) {
-      if (targetProps.has(prop) && targetProps.get(prop) !== value) {
-        return false;
-      }
-    }
-    return true;
-  });
-  if (!matchingVariant) {
-    console.log(
-      `No matching variant found for "${node.name}" with properties:`,
-      Object.fromEntries(targetProps),
-      "\nAvailable variants:",
-      node.variants.map((v) => v.variantProperties),
-      "\nUsing first variant as fallback"
-    );
-    return node.variants[0] || node;
-  }
-  return matchingVariant;
-}
-function buildVariantCondition(permutation) {
-  const conditions = permutation.map(({ tagPath, value, isBoolean }) => {
-    if (isBoolean) {
-      if (value === "true") {
-        return tagPath;
-      } else {
-        return `!${tagPath}`;
-      }
-    } else {
-      return `${tagPath} == ${value}`;
-    }
-  });
-  return conditions.join(" && ");
-}
-function convertVariantNode(node, analysis, context, convertNodeToJayHtml2) {
-  const indent = "  ".repeat(context.indentLevel);
-  const innerIndent = "  ".repeat(context.indentLevel + 1);
-  const propertyValues = getComponentVariantValues(node, analysis.propertyBindings);
-  const permutations = generatePermutations(propertyValues, analysis.propertyBindings);
-  if (permutations.length === 0) {
-    throw new Error(
-      `No permutations generated for variant node "${node.name}" - check property definitions`
-    );
-  }
-  let variantHtml = "";
-  for (const permutation of permutations) {
-    const conditions = buildVariantCondition(permutation);
-    const variantNode = findComponentVariant(node, permutation);
-    variantHtml += `${innerIndent}<div if="${conditions}">
-`;
-    const variantContext = {
-      ...context,
-      indentLevel: context.indentLevel + 2
-      // +2 because we're inside wrapper and if div
-    };
-    if (variantNode.children && variantNode.children.length > 0) {
-      for (const child of variantNode.children) {
-        variantHtml += convertNodeToJayHtml2(child, variantContext);
-      }
-    }
-    variantHtml += `${innerIndent}</div>
-`;
-  }
-  const positionStyle = getPositionStyle(node);
-  const frameSizeStyles = getFrameSizeStyles(node);
-  const backgroundStyle = getBackgroundFillsStyle(node);
-  const borderRadius = getBorderRadius(node);
-  const strokeStyles = getStrokeStyles(node);
-  const flexStyles = getAutoLayoutStyles(node);
-  const overflowStyles = getOverflowStyles(node);
-  const commonStyles = getCommonStyles(node);
-  const wrapperStyleAttr = `${positionStyle}${frameSizeStyles}${backgroundStyle}${strokeStyles}${borderRadius}${overflowStyles}${commonStyles}${flexStyles}box-sizing: border-box;`;
-  let refAttr = "";
-  if (analysis.refPath) {
-    refAttr = ` ref="${analysis.refPath}"`;
-  } else if (analysis.dualPath) {
-    refAttr = ` ref="${analysis.dualPath}"`;
-  } else if (analysis.interactiveVariantPath) {
-    refAttr = ` ref="${analysis.interactiveVariantPath}"`;
-  }
-  return `${indent}<div id="${node.id}" data-figma-id="${node.id}" data-figma-type="variant-container"${refAttr} style="${wrapperStyleAttr}">
-` + variantHtml + `${indent}</div>
-`;
-}
-function convertRepeaterNode(node, analysis, context, convertNodeToJayHtml2) {
-  const { repeaterPath, trackByKey } = analysis;
-  const indent = "  ".repeat(context.indentLevel);
-  const innerIndent = "  ".repeat(context.indentLevel + 1);
-  if (node.type !== "FRAME") {
-    throw new Error(`Repeater node "${node.name}" must be a FRAME (got: ${node.type})`);
-  }
-  if (!node.layoutMode || node.layoutMode === "NONE") {
-    throw new Error(
-      `Repeater node "${node.name}" must have auto-layout (HORIZONTAL or VERTICAL)`
-    );
-  }
-  const positionStyle = getPositionStyle(node);
-  const frameSizeStyles = getFrameSizeStyles(node);
-  const backgroundStyle = getBackgroundFillsStyle(node);
-  const borderRadius = getBorderRadius(node);
-  const strokeStyles = getStrokeStyles(node);
-  const flexStyles = getAutoLayoutStyles(node);
-  const overflowStyles = getOverflowStyles(node);
-  const commonStyles = getCommonStyles(node);
-  const outerStyleAttr = `${positionStyle}${frameSizeStyles}${backgroundStyle}${strokeStyles}${borderRadius}${overflowStyles}${commonStyles}${flexStyles}box-sizing: border-box;`;
-  let innerDivSizeStyles = "";
-  if (node.layoutWrap === "WRAP") {
-    innerDivSizeStyles = "width: fit-content; height: fit-content;";
-  } else if (node.layoutMode === "HORIZONTAL") {
-    innerDivSizeStyles = "height: 100%;";
-  } else if (node.layoutMode === "VERTICAL") {
-    innerDivSizeStyles = "width: 100%;";
-  }
-  let html = `${indent}<div id="${node.id}" data-figma-id="${node.id}" data-figma-type="frame-repeater" style="${outerStyleAttr}">
-`;
-  html += `${innerIndent}<div style="position: relative; ${innerDivSizeStyles}" forEach="${repeaterPath}" trackBy="${trackByKey}">
-`;
-  const newContext = {
-    ...context,
-    repeaterPathStack: [...context.repeaterPathStack, repeaterPath.split(".")],
-    indentLevel: context.indentLevel + 2
-    // +2 because we're inside both divs
-  };
-  if (node.children && node.children.length > 0) {
-    html += convertNodeToJayHtml2(node.children[0], newContext);
-  } else {
-    throw new Error(
-      `Repeater node "${node.name}" has no children - repeater template is required`
-    );
-  }
-  html += `${innerIndent}</div>
-`;
-  html += `${indent}</div>
-`;
-  return html;
-}
-function convertGroupNode(node, analysis, context, convertNodeToJayHtml2) {
-  const indent = "  ".repeat(context.indentLevel);
-  const positionStyle = getPositionStyle(node);
-  const sizeStyles = getNodeSizeStyles(node);
-  const commonStyles = getCommonStyles(node);
-  const styleAttr = `${positionStyle}${sizeStyles}${commonStyles}box-sizing: border-box;`;
-  let refAttr = "";
-  if (analysis.refPath) {
-    refAttr = ` ref="${analysis.refPath}"`;
-  } else if (analysis.dualPath) {
-    refAttr = ` ref="${analysis.dualPath}"`;
-  }
-  let htmlAttrs = `id="${node.id}" data-figma-id="${node.id}" data-figma-type="group"${refAttr} style="${styleAttr}"`;
-  for (const [attr, tagPath] of analysis.attributes) {
-    htmlAttrs += ` ${attr}="{${tagPath}}"`;
-  }
-  let html = `${indent}<div ${htmlAttrs}>
-`;
-  const childContext = {
-    ...context,
-    indentLevel: context.indentLevel + 1
-  };
-  if (node.children && node.children.length > 0) {
-    for (const child of node.children) {
-      html += convertNodeToJayHtml2(child, childContext);
-    }
-  }
-  html += `${indent}</div>
-`;
-  return html;
-}
-function findContractTag(tags, tagPath) {
-  if (tagPath.length === 0) {
-    return void 0;
-  }
-  const tag = tags.find((t) => t.tag === tagPath[0]);
-  if (!tag) {
-    return void 0;
-  }
-  if (tagPath.length === 1) {
-    return tag;
-  }
-  if (!tag.tags || tag.tags.length === 0) {
-    return void 0;
-  }
-  return findContractTag(tag.tags, tagPath.slice(1));
-}
-function findPlugin(plugins, pluginName) {
-  return plugins.find((p) => p.name === pluginName);
-}
-function findPluginContract(plugin, componentName) {
-  const contract = plugin.contracts.find((c) => c.name === componentName);
-  return contract ? { tags: contract.tags } : void 0;
-}
-function findPageContract(projectPage) {
-  return projectPage.contract ? { tags: projectPage.contract.tags } : void 0;
-}
-function isDataTag(contractTag) {
-  if (Array.isArray(contractTag.type)) {
-    return contractTag.type.includes("data");
-  }
-  return contractTag.type === "data";
-}
-function isInteractiveTag(contractTag) {
-  if (Array.isArray(contractTag.type)) {
-    return contractTag.type.includes("interactive");
-  }
-  return contractTag.type === "interactive";
-}
-function isDualTag(contractTag) {
-  if (Array.isArray(contractTag.type)) {
-    return contractTag.type.includes("data") && contractTag.type.includes("interactive");
-  }
-  return false;
-}
-function isRepeaterTag(contractTag) {
-  return contractTag.type === "subContract" && contractTag.repeated === true;
-}
-function applyRepeaterContext(path2, repeaterStack) {
-  for (const repeaterPath of repeaterStack) {
-    const prefix = repeaterPath.join(".") + ".";
-    if (path2.startsWith(prefix)) {
-      path2 = path2.substring(prefix.length);
-    }
-  }
-  return path2;
-}
-function resolveBinding(binding, context) {
-  let contract;
-  let key;
-  let tagPathWithoutKey;
-  if (binding.pageContractPath.pluginName && binding.pageContractPath.componentName) {
-    const plugin = findPlugin(context.plugins, binding.pageContractPath.pluginName);
-    if (!plugin) {
-      throw new Error(`Plugin not found: ${binding.pageContractPath.pluginName}`);
-    }
-    contract = findPluginContract(plugin, binding.pageContractPath.componentName);
-    if (!contract) {
-      throw new Error(
-        `Contract not found in plugin ${binding.pageContractPath.pluginName}: ${binding.pageContractPath.componentName}`
-      );
-    }
-    const usedComponent = context.projectPage.usedComponents?.find(
-      (c) => c.componentName === binding.pageContractPath.componentName
-    );
-    if (!usedComponent) {
-      throw new Error(
-        `Used component not found in page: ${binding.pageContractPath.componentName}`
-      );
-    }
-    key = usedComponent.key;
-    tagPathWithoutKey = binding.tagPath.slice(1);
-  } else {
-    contract = findPageContract(context.projectPage);
-    if (!contract) {
-      throw new Error(`Page contract not found for page ${context.projectPage.url}`);
-    }
-    tagPathWithoutKey = binding.tagPath;
-  }
-  const contractTag = findContractTag(contract.tags, tagPathWithoutKey);
-  if (!contractTag) {
-    throw new Error(`Contract tag not found: ${tagPathWithoutKey.join(".")} in contract`);
-  }
-  let fullPath;
-  if (key) {
-    fullPath = [key, ...tagPathWithoutKey].join(".");
-  } else {
-    fullPath = binding.tagPath.join(".");
-  }
-  fullPath = applyRepeaterContext(fullPath, context.repeaterPathStack);
-  return { fullPath, contractTag };
-}
-function getBindingsData(node) {
-  const bindingsDataRaw = node.pluginData?.["jay-layer-bindings"];
-  if (bindingsDataRaw) {
-    try {
-      return JSON.parse(bindingsDataRaw);
-    } catch (error) {
-      console.warn(`Failed to parse bindings data for node ${node.name}:`, error);
-      return [];
-    }
-  }
-  return [];
-}
-function analyzeBindings(bindings, context) {
-  const analysis = {
-    type: "none",
-    attributes: /* @__PURE__ */ new Map(),
-    propertyBindings: [],
-    isRepeater: false
-  };
-  if (bindings.length === 0) {
-    return analysis;
-  }
-  const resolved = bindings.map((b) => ({
-    binding: b,
-    ...resolveBinding(b, context)
-  })).filter((r) => r.fullPath && r.contractTag);
-  if (resolved.length === 0) {
-    return analysis;
-  }
-  const repeaterBinding = resolved.find((r) => isRepeaterTag(r.contractTag));
-  if (repeaterBinding) {
-    analysis.type = "repeater";
-    analysis.isRepeater = true;
-    analysis.repeaterPath = repeaterBinding.fullPath;
-    analysis.repeaterTag = repeaterBinding.contractTag;
-    analysis.trackByKey = repeaterBinding.contractTag.trackBy || "id";
-    return analysis;
-  }
-  const propertyBindings = resolved.filter((r) => r.binding.property);
-  if (propertyBindings.length > 0) {
-    if (propertyBindings.length !== resolved.length) {
-      throw new Error(`Node has mixed property and non-property bindings - this is invalid`);
-    }
-    analysis.type = "property-variant";
-    analysis.propertyBindings = propertyBindings.map((r) => ({
-      property: r.binding.property,
-      tagPath: r.fullPath,
-      contractTag: r.contractTag
-    }));
-    for (const r of propertyBindings) {
-      if (isInteractiveTag(r.contractTag)) {
-        analysis.interactiveVariantPath = r.fullPath;
-        break;
-      }
-    }
-    return analysis;
-  }
-  const attributeBindings = resolved.filter((r) => r.binding.attribute);
-  if (attributeBindings.length > 0) {
-    analysis.type = "attribute";
-    for (const r of attributeBindings) {
-      analysis.attributes.set(r.binding.attribute, r.fullPath);
-    }
-  }
-  const contentBindings = resolved.filter((r) => !r.binding.attribute && !r.binding.property);
-  if (contentBindings.length > 0) {
-    const binding = contentBindings[0];
-    if (isDualTag(binding.contractTag)) {
-      analysis.type = "dual";
-      analysis.dualPath = binding.fullPath;
-    } else if (isInteractiveTag(binding.contractTag)) {
-      analysis.type = "interactive";
-      analysis.refPath = binding.fullPath;
-    } else if (isDataTag(binding.contractTag)) {
-      if (analysis.type === "attribute") {
-        analysis.dynamicContentPath = binding.fullPath;
-        analysis.dynamicContentTag = binding.contractTag;
-      } else {
-        analysis.type = "dynamic-content";
-        analysis.dynamicContentPath = binding.fullPath;
-        analysis.dynamicContentTag = binding.contractTag;
-      }
-    }
-  }
-  return analysis;
-}
-function validateBindings(analysis, node) {
-  if (analysis.type === "property-variant" && analysis.attributes.size > 0) {
-    throw new Error(
-      `Node "${node.name}" has both property and attribute bindings - this is invalid`
-    );
-  }
-  if (analysis.type === "interactive" && analysis.attributes.size > 0) {
-    throw new Error(
-      `Node "${node.name}" has interactive binding with attributes - this is invalid`
-    );
-  }
-}
-function convertRegularNode(node, analysis, context) {
-  const indent = "  ".repeat(context.indentLevel);
-  const { type, children, pluginData } = node;
-  const semanticHtml = pluginData?.["semanticHtml"];
-  if (type === "TEXT") {
-    const dynamicContent = analysis.dynamicContentPath ? `{${analysis.dynamicContentPath}}` : "";
-    const refAttr = analysis.refPath ? ` ref="${analysis.refPath}"` : "";
-    const dualContent = analysis.dualPath ? `{${analysis.dualPath}}` : "";
-    const dualRef = analysis.dualPath ? ` ref="${analysis.dualPath}"` : "";
-    let attributesHtml = "";
-    for (const [attr, tagPath] of analysis.attributes) {
-      attributesHtml += ` ${attr}="{${tagPath}}"`;
-    }
-    return convertTextNodeToHtml(
-      node,
-      indent,
-      dynamicContent || dualContent,
-      refAttr || dualRef,
-      attributesHtml
-    );
-  }
-  if (semanticHtml === "img") {
-    let srcBinding;
-    let altBinding;
-    for (const [attr, tagPath] of analysis.attributes) {
-      if (attr === "src") {
-        srcBinding = `{${tagPath}}`;
-      } else if (attr === "alt") {
-        altBinding = `{${tagPath}}`;
-      }
-    }
-    let staticImageUrl;
-    if (!srcBinding) {
-      staticImageUrl = extractStaticImageUrl(node);
-    }
-    const refAttr = analysis.refPath ? ` ref="${analysis.refPath}"` : analysis.dualPath ? ` ref="${analysis.dualPath}"` : "";
-    return convertImageNodeToHtml(
-      node,
-      indent,
-      srcBinding,
-      altBinding,
-      refAttr,
-      staticImageUrl
-    );
-  }
-  const positionStyle = getPositionStyle(node);
-  const sizeStyles = getNodeSizeStyles(node);
-  const commonStyles = getCommonStyles(node);
-  let styleAttr = "";
-  if (type === "FRAME") {
-    const backgroundStyle = getBackgroundFillsStyle(node);
-    const borderRadius = getBorderRadius(node);
-    const strokeStyles = getStrokeStyles(node);
-    const flexStyles = getAutoLayoutStyles(node);
-    const overflowStyles = getOverflowStyles(node);
-    const frameSizeStyles = getFrameSizeStyles(node);
-    styleAttr = `${positionStyle}${frameSizeStyles}${backgroundStyle}${strokeStyles}${borderRadius}${overflowStyles}${commonStyles}${flexStyles}box-sizing: border-box;`;
-  } else {
-    styleAttr = `${positionStyle}${sizeStyles}${commonStyles}`;
-  }
-  const tag = semanticHtml || "div";
-  let htmlAttrs = `data-figma-id="${node.id}" data-figma-type="${type.toLowerCase()}" style="${styleAttr}"`;
-  if (analysis.refPath) {
-    htmlAttrs += ` ref="${analysis.refPath}"`;
-  } else if (analysis.dualPath) {
-    htmlAttrs += ` ref="${analysis.dualPath}"`;
-  }
-  for (const [attr, tagPath] of analysis.attributes) {
-    htmlAttrs += ` ${attr}="{${tagPath}}"`;
-  }
-  if (type === "RECTANGLE") {
-    return convertRectangleToHtml(node, indent);
-  } else if (type === "ELLIPSE") {
-    return convertEllipseToHtml(node, indent);
-  } else if (type === "GROUP") {
-    return convertGroupNode(node, analysis, context, convertNodeToJayHtml);
-  } else if (type === "VECTOR" || type === "STAR" || type === "POLYGON" || type === "LINE" || type === "BOOLEAN_OPERATION") {
-    return convertVectorToHtml(node, indent);
-  } else if (children && children.length > 0) {
-    let html = `${indent}<${tag} ${htmlAttrs}>
-`;
-    html += `${indent}  <!-- ${node.name} -->
-`;
-    const childContext = {
-      ...context,
-      indentLevel: context.indentLevel + 1
-    };
-    for (const child of children) {
-      html += convertNodeToJayHtml(child, childContext);
-    }
-    html += `${indent}</${tag}>
-`;
-    return html;
-  } else {
-    return `${indent}<!-- ${node.name} (${type}) -->
-`;
-  }
-}
-function convertNodeToJayHtml(node, context) {
-  const { name, type, children, pluginData } = node;
-  const isJPage = pluginData?.["jpage"] === "true";
-  const urlRoute = pluginData?.["urlRoute"];
-  if (type === "TEXT" && node.fontName) {
-    if (typeof node.fontName === "object" && node.fontName.family) {
-      context.fontFamilies.add(node.fontName.family);
-    }
-  }
-  const indent = "  ".repeat(context.indentLevel);
-  if (type === "SECTION" && isJPage) {
-    let html = `${indent}<section data-figma-id="${node.id}" data-page-url="${urlRoute || ""}">
-`;
-    html += `${indent}  <!-- Jay Page: ${name} -->
-`;
-    if (children && children.length > 0) {
-      const childContext = {
-        ...context,
-        indentLevel: context.indentLevel + 1
-      };
-      for (const child of children) {
-        html += convertNodeToJayHtml(child, childContext);
-      }
-    }
-    html += `${indent}</section>
-`;
-    return html;
-  }
-  const bindings = getBindingsData(node);
-  const analysis = analyzeBindings(bindings, context);
-  validateBindings(analysis, node);
-  if (analysis.isRepeater) {
-    return convertRepeaterNode(node, analysis, context, convertNodeToJayHtml);
-  }
-  if (analysis.type === "property-variant") {
-    return convertVariantNode(node, analysis, context, convertNodeToJayHtml);
-  }
-  return convertRegularNode(node, analysis, context);
-}
-function findContentFrame(section) {
-  if (!section.children || section.children.length === 0) {
-    return {
-      frame: null,
-      error: `Jay Page section "${section.name}" has no children`
-    };
-  }
-  const frameNodes = section.children.filter((child) => child.type === "FRAME");
-  if (frameNodes.length === 0) {
-    return {
-      frame: null,
-      error: `Jay Page section "${section.name}" has no FrameNode children. Found: ${section.children.map((c) => c.type).join(", ")}`
-    };
-  }
-  if (frameNodes.length > 1) {
-    return {
-      frame: frameNodes[0],
-      warning: `Jay Page section "${section.name}" has ${frameNodes.length} FrameNodes, using the first one`
-    };
-  }
-  return { frame: frameNodes[0] };
-}
-const figmaVendor = {
-  vendorId: "figma",
-  async convertToBodyHtml(vendorDoc, pageUrl, projectPage, plugins) {
-    console.log(`🎨 Converting Figma document for page: ${pageUrl}`);
-    console.log(`   Document type: ${vendorDoc.type}, name: ${vendorDoc.name}`);
-    const isJPage = vendorDoc.pluginData?.["jpage"] === "true";
-    if (!isJPage) {
-      throw new Error(
-        `Document "${vendorDoc.name}" is not marked as a Jay Page (missing jpage='true' in pluginData)`
-      );
-    }
-    const { frame, error, warning } = findContentFrame(vendorDoc);
-    if (error) {
-      throw new Error(`Cannot convert to Jay HTML: ${error}`);
-    }
-    if (warning) {
-      console.warn(`⚠️  ${warning}`);
-    }
-    if (!frame) {
-      throw new Error(`Cannot convert to Jay HTML: No content frame found`);
-    }
-    console.log(`   Converting content frame: ${frame.name} (${frame.type})`);
-    const fontFamilies = /* @__PURE__ */ new Set();
-    const context = {
-      repeaterPathStack: [],
-      indentLevel: 1,
-      // Start at 1 for body content
-      fontFamilies,
-      projectPage,
-      plugins
-    };
-    const bodyHtml = convertNodeToJayHtml(frame, context);
-    if (fontFamilies.size > 0) {
-      console.log(
-        `   Found ${fontFamilies.size} font families: ${Array.from(fontFamilies).join(", ")}`
-      );
-    }
-    return {
-      bodyHtml,
-      fontFamilies,
-      // No contract data for now - Figma vendor doesn't generate contracts yet
-      contractData: void 0
-    };
-  }
-};
-const vendorRegistry = /* @__PURE__ */ new Map([
-  [figmaVendor.vendorId, figmaVendor]
-  // Add more vendors here as they are contributed
-]);
-function getVendor(vendorId) {
-  return vendorRegistry.get(vendorId);
-}
-function hasVendor(vendorId) {
-  return vendorRegistry.has(vendorId);
-}
-function getRegisteredVendors() {
-  return Array.from(vendorRegistry.keys());
-}
-function escapeHtml(text) {
-  if (!text)
-    return "";
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function generateGoogleFontsLinks(fontFamilies) {
-  if (fontFamilies.size === 0) {
-    return "";
-  }
-  const families = Array.from(fontFamilies);
-  const googleFontsUrl = `https://fonts.googleapis.com/css2?${families.map((family) => {
-    const encodedFamily = encodeURIComponent(family).replace(/%20/g, "+");
-    return `family=${encodedFamily}:wght@100;200;300;400;500;600;700;800;900`;
-  }).join("&")}&display=swap`;
-  return `  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-  <link href="${googleFontsUrl}" rel="stylesheet">`;
-}
-function generateHeadlessComponentScripts(components) {
-  if (components.length === 0) {
-    return "";
-  }
-  const scriptTags = components.map(
-    (comp) => `  <script
-    type="application/jay-headless"
-    plugin="${comp.plugin}"
-    contract="${comp.contract}"
-    key="${comp.key}"
-  ><\/script>`
-  );
-  return "\n" + scriptTags.join("\n");
-}
-function generateJayDataScript(contractData) {
-  if (contractData) {
-    return `  <script type="application/jay-data">
-    data:
-${contractData.tagsYaml}
-  <\/script>`;
-  }
-  return `  <script type="application/jay-data">
-    data:
-  <\/script>`;
-}
-function buildJayHtml(options) {
-  const {
-    bodyHtml,
-    fontFamilies,
-    contractData,
-    headlessComponents = [],
-    title = "Page"
-  } = options;
-  const fontLinks = generateGoogleFontsLinks(fontFamilies);
-  const headlessScripts = generateHeadlessComponentScripts(headlessComponents);
-  const jayDataScript = generateJayDataScript(contractData);
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-${fontLinks}${headlessScripts}
-${jayDataScript}
-  <title>${escapeHtml(title)}</title>
-  <style>
-    /* Basic reset */
-    body { margin: 0; font-family: sans-serif; }
-    a { color: inherit; text-decoration: none; }
-    a:hover { text-decoration: underline; }
-    div { box-sizing: border-box; }
-    
-    /* Scrollbar styling for Webkit browsers */
-    ::-webkit-scrollbar {
-      width: 8px;
-      height: 8px;
-    }
-    
-    ::-webkit-scrollbar-track {
-      background: transparent;
-    }
-    
-    ::-webkit-scrollbar-thumb {
-      background: rgba(0, 0, 0, 0.3);
-      border-radius: 4px;
-    }
-    
-    ::-webkit-scrollbar-thumb:hover {
-      background: rgba(0, 0, 0, 0.5);
-    }
-    
-    /* Smooth scrolling */
-    * {
-      scroll-behavior: smooth;
-    }
-  </style>
-</head>
-<body>
-${bodyHtml}
-</body>
-</html>`;
-}
-async function buildJayHtmlFromVendorResult(conversionResult, pageDirectory, pageTitle) {
-  const pageConfigPath = path.join(pageDirectory, "page.conf.yaml");
-  const headlessComponents = [];
-  if (fs.existsSync(pageConfigPath)) {
-    try {
-      const configContent = await fs.promises.readFile(pageConfigPath, "utf-8");
-      const pageConfig = YAML.parse(configContent);
-      if (pageConfig.used_components && Array.isArray(pageConfig.used_components)) {
-        for (const comp of pageConfig.used_components) {
-          if (comp.plugin && comp.contract && comp.key) {
-            headlessComponents.push({
-              plugin: comp.plugin,
-              contract: comp.contract,
-              key: comp.key
-            });
-          }
-        }
-      }
-    } catch (configError) {
-      console.warn(`Failed to read page config ${pageConfigPath}:`, configError);
-    }
-  }
-  const title = pageTitle || path.basename(pageDirectory);
-  return buildJayHtml({
-    bodyHtml: conversionResult.bodyHtml,
-    fontFamilies: conversionResult.fontFamilies,
-    contractData: conversionResult.contractData,
-    headlessComponents,
-    title
-  });
-}
-const PAGE_FILENAME = `page${JAY_EXTENSION}`;
-const PAGE_CONTRACT_FILENAME = `page${JAY_CONTRACT_EXTENSION}`;
-const PAGE_CONFIG_FILENAME = "page.conf.yaml";
-function pageUrlToDirectoryPath(pageUrl, pagesBasePath) {
-  const routePath = pageUrl === "/" ? "" : pageUrl;
-  const fsPath = routePath.replace(/:([^/]+)/g, "[$1]");
-  return path.join(pagesBasePath, fsPath);
-}
-function jayTypeToString(jayType) {
-  if (!jayType)
-    return void 0;
-  if (jayType instanceof JayAtomicType) {
-    return jayType.name;
-  } else if (jayType instanceof JayEnumType) {
-    return `enum (${jayType.values.join(" | ")})`;
-  } else {
-    return jayType.name || "unknown";
-  }
-}
-function convertContractTagToProtocol(tag) {
-  const typeArray = Array.isArray(tag.type) ? tag.type : [tag.type];
-  const typeStrings = typeArray.map((t) => ContractTagType[t]);
-  return {
-    tag: tag.tag,
-    type: typeStrings.length === 1 ? typeStrings[0] : typeStrings,
-    dataType: tag.dataType ? jayTypeToString(tag.dataType) : void 0,
-    elementType: tag.elementType ? tag.elementType.join(" | ") : void 0,
-    required: tag.required,
-    repeated: tag.repeated,
-    trackBy: tag.trackBy,
-    async: tag.async,
-    phase: tag.phase,
-    link: tag.link,
-    tags: tag.tags ? tag.tags.map(convertContractTagToProtocol) : void 0
-  };
-}
-function convertContractToProtocol(contract) {
-  return {
-    name: contract.name,
-    tags: contract.tags.map(convertContractTagToProtocol)
-  };
-}
-async function isPageDirectory(dirPath) {
-  const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
-  const hasPageHtml = entries.some((e2) => e2.name === PAGE_FILENAME);
-  const hasPageContract = entries.some((e2) => e2.name === PAGE_CONTRACT_FILENAME);
-  const hasPageConfig = entries.some((e2) => e2.name === PAGE_CONFIG_FILENAME);
-  const isPage = hasPageHtml || hasPageContract || hasPageConfig;
-  return { isPage, hasPageHtml, hasPageContract, hasPageConfig };
-}
-async function scanPageDirectories(pagesBasePath, onPageFound) {
-  async function scanDirectory(dirPath, urlPath = "") {
-    try {
-      const { isPage, hasPageHtml, hasPageContract, hasPageConfig } = await isPageDirectory(dirPath);
-      if (isPage) {
-        const pageUrl = urlPath || "/";
-        const pageName = dirPath === pagesBasePath ? "Home" : path.basename(dirPath);
-        await onPageFound({
-          dirPath,
-          pageUrl,
-          pageName,
-          hasPageHtml,
-          hasPageContract,
-          hasPageConfig
-        });
-      }
-      const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-          const isParam = entry.name.startsWith("[") && entry.name.endsWith("]");
-          const segmentUrl = isParam ? `:${entry.name.slice(1, -1)}` : entry.name;
-          const newUrlPath = urlPath + "/" + segmentUrl;
-          await scanDirectory(fullPath, newUrlPath);
-        }
-      }
-    } catch (error) {
-      getLogger().warn(`Failed to scan directory ${dirPath}:`, error);
-    }
-  }
-  await scanDirectory(pagesBasePath);
-}
-function expandContractTags(tags, baseDir) {
-  const resolvedTags = [];
-  for (const tag of tags) {
-    if (tag.link) {
-      try {
-        const linkWithExtension = tag.link.endsWith(JAY_CONTRACT_EXTENSION) ? tag.link : tag.link + JAY_CONTRACT_EXTENSION;
-        const linkedPath = JAY_IMPORT_RESOLVER.resolveLink(baseDir, linkWithExtension);
-        const loadResult = JAY_IMPORT_RESOLVER.loadContract(linkedPath);
-        if (loadResult.val) {
-          const expandedSubTags = expandContractTags(
-            loadResult.val.tags,
-            path.dirname(linkedPath)
-          );
-          const resolvedTag = {
-            tag: tag.tag,
-            type: tag.type,
-            // Keep the original enum type
-            tags: expandedSubTags,
-            required: tag.required,
-            repeated: tag.repeated,
-            trackBy: tag.trackBy,
-            async: tag.async,
-            phase: tag.phase,
-            link: tag.link
-          };
-          resolvedTags.push(resolvedTag);
-        } else {
-          getLogger().warn(`Failed to load linked contract: ${tag.link} from ${baseDir}`);
-          resolvedTags.push(tag);
-        }
-      } catch (error) {
-        getLogger().warn(`Error resolving linked contract ${tag.link}:`, error);
-        resolvedTags.push(tag);
-      }
-    } else if (tag.tags) {
-      const resolvedSubTags = expandContractTags(tag.tags, baseDir);
-      const resolvedTag = {
-        ...tag,
-        tags: resolvedSubTags
-      };
-      resolvedTags.push(resolvedTag);
-    } else {
-      resolvedTags.push(tag);
-    }
-  }
-  return resolvedTags;
-}
-function loadAndExpandContract(contractFilePath) {
-  try {
-    const loadResult = JAY_IMPORT_RESOLVER.loadContract(contractFilePath);
-    if (loadResult.validations.length > 0) {
-      getLogger().warn(
-        `Contract validation errors in ${contractFilePath}:`,
-        loadResult.validations
-      );
-    }
-    if (loadResult.val) {
-      const resolvedTags = expandContractTags(
-        loadResult.val.tags,
-        path.dirname(contractFilePath)
-      );
-      return convertContractToProtocol({
-        name: loadResult.val.name,
-        tags: resolvedTags
-      });
-    }
-  } catch (error) {
-    getLogger().warn(`Failed to parse contract file ${contractFilePath}:`, error);
-  }
-  return null;
-}
-async function extractHeadlessComponentsFromJayHtml(jayHtmlContent, pageFilePath, projectRootPath) {
-  try {
-    const parsedJayHtml = await parseJayFile(
-      jayHtmlContent,
-      path.basename(pageFilePath),
-      path.dirname(pageFilePath),
-      { relativePath: "" },
-      // We don't need TypeScript config for headless extraction
-      JAY_IMPORT_RESOLVER,
-      projectRootPath
-    );
-    if (parsedJayHtml.validations.length > 0) {
-      getLogger().warn(
-        `Jay-HTML parsing warnings for ${pageFilePath}:`,
-        parsedJayHtml.validations
-      );
-    }
-    if (!parsedJayHtml.val) {
-      getLogger().warn(`Failed to parse jay-html file: ${pageFilePath}`);
-      return [];
-    }
-    const resolvedComponents = [];
-    for (const headlessImport of parsedJayHtml.val.headlessImports) {
-      if (headlessImport.codeLink) {
-        let pluginName = headlessImport.codeLink.module;
-        const nodeModulesMatch = pluginName.match(/node_modules\/([^/]+)/);
-        if (nodeModulesMatch) {
-          pluginName = nodeModulesMatch[1];
-        }
-        const componentName = headlessImport.contract?.name || "unknown";
-        resolvedComponents.push({
-          appName: pluginName,
-          componentName,
-          key: headlessImport.key
-        });
-      }
-    }
-    return resolvedComponents;
-  } catch (error) {
-    getLogger().warn(`Failed to parse jay-html content for ${pageFilePath}:`, error);
-    return [];
-  }
-}
-async function scanProjectComponents(componentsBasePath) {
-  const components = [];
-  try {
-    const entries = await fs.promises.readdir(componentsBasePath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith(JAY_EXTENSION)) {
-        const componentName = path.basename(entry.name, JAY_EXTENSION);
-        const componentPath = path.join(componentsBasePath, entry.name);
-        const contractPath = path.join(
-          componentsBasePath,
-          `${componentName}${JAY_CONTRACT_EXTENSION}`
-        );
-        const hasContract = fs.existsSync(contractPath);
-        components.push({
-          name: componentName,
-          filePath: componentPath,
-          contractPath: hasContract ? contractPath : void 0
-        });
-      }
-    }
-  } catch (error) {
-    getLogger().warn(`Failed to scan components directory ${componentsBasePath}:`, error);
-  }
-  return components;
-}
-async function getProjectName(configBasePath) {
-  const projectConfigPath = path.join(configBasePath, "project.conf.yaml");
-  try {
-    if (fs.existsSync(projectConfigPath)) {
-      const configContent = await fs.promises.readFile(projectConfigPath, "utf-8");
-      const projectConfig = YAML.parse(configContent);
-      return projectConfig.name || "Unnamed Project";
-    }
-  } catch (error) {
-    getLogger().warn(`Failed to read project config ${projectConfigPath}:`, error);
-  }
-  return "Unnamed Project";
-}
-async function scanLocalPluginNames(projectRoot) {
-  const plugins = [];
-  const localPluginsDir = path.join(projectRoot, LOCAL_PLUGIN_PATH);
-  if (!fs.existsSync(localPluginsDir)) {
-    return plugins;
-  }
-  try {
-    const entries = await fs.promises.readdir(localPluginsDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const pluginDir = path.join(localPluginsDir, entry.name);
-        const pluginYamlPath = path.join(pluginDir, "plugin.yaml");
-        if (fs.existsSync(pluginYamlPath)) {
-          plugins.push(entry.name);
-        }
-      }
-    }
-  } catch (error) {
-    getLogger().warn(`Failed to scan local plugins directory ${localPluginsDir}:`, error);
-  }
-  return plugins;
-}
-async function findPluginNamesFromPackageJson(projectRootPath) {
-  const pluginNames = [];
-  try {
-    const packageJsonPath = path.join(projectRootPath, "package.json");
-    if (!fs.existsSync(packageJsonPath)) {
-      getLogger().warn("package.json not found");
-      return pluginNames;
-    }
-    const packageJsonContent = await fs.promises.readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    const workspaceDependencies = /* @__PURE__ */ new Set();
-    const regularDependencies = /* @__PURE__ */ new Set();
-    for (const [depName, version] of Object.entries({
-      ...packageJson.dependencies
-    })) {
-      if (typeof version === "string" && version.startsWith("workspace:")) {
-        workspaceDependencies.add(depName);
-      } else {
-        regularDependencies.add(depName);
-      }
-    }
-    const nodeModulesPath = path.join(projectRootPath, "node_modules");
-    for (const depName of regularDependencies) {
-      if (await checkPackageForPlugin(nodeModulesPath, depName)) {
-        pluginNames.push(depName);
-      }
-    }
-    if (workspaceDependencies.size > 0) {
-      const workspaceNodeModules = await findWorkspaceNodeModulesPath(
-        projectRootPath,
-        Array.from(workspaceDependencies)
-      );
-      if (workspaceNodeModules) {
-        for (const depName of workspaceDependencies) {
-          if (await checkPackageForPlugin(workspaceNodeModules, depName)) {
-            pluginNames.push(depName);
-          }
-        }
-      }
-    }
-  } catch (error) {
-    getLogger().error("Error finding plugins from package.json:", error);
-  }
-  return pluginNames;
-}
-async function checkPackageForPlugin(nodeModulesDir, packageName) {
-  try {
-    const packageDir = path.join(nodeModulesDir, packageName);
-    const pluginYamlPath = path.join(packageDir, "plugin.yaml");
-    return fs.existsSync(pluginYamlPath);
-  } catch (error) {
-    return false;
-  }
-}
-async function findWorkspaceNodeModulesPath(startPath, workspaceDeps) {
-  let currentPath = startPath;
-  while (currentPath !== path.dirname(currentPath)) {
-    const nodeModulesPath = path.join(currentPath, "node_modules");
-    if (fs.existsSync(nodeModulesPath)) {
-      for (const depName of workspaceDeps) {
-        const depPath = path.join(nodeModulesPath, depName);
-        if (fs.existsSync(depPath)) {
-          return nodeModulesPath;
-        }
-      }
-    }
-    currentPath = path.dirname(currentPath);
-  }
-  return null;
-}
-async function scanPlugins(projectRootPath) {
-  const plugins = [];
-  try {
-    const [localPluginNames, dependencyPluginNames] = await Promise.all([
-      scanLocalPluginNames(projectRootPath),
-      findPluginNamesFromPackageJson(projectRootPath)
-    ]);
-    const allPluginNames = [.../* @__PURE__ */ new Set([...localPluginNames, ...dependencyPluginNames])];
-    getLogger().info(`Found ${allPluginNames.length} plugins: ${allPluginNames.join(", ")}`);
-    for (const pluginName of allPluginNames) {
-      const manifest = resolvePluginManifest(projectRootPath, pluginName);
-      if (manifest.validations.length > 0) {
-        getLogger().warn(
-          `Failed to resolve plugin manifest for ${pluginName}:`,
-          manifest.validations
-        );
-        continue;
-      }
-      if (!manifest.val) {
-        getLogger().warn(
-          `Failed to resolve plugin manifest for ${pluginName}:`,
-          manifest.validations
-        );
-        continue;
-      }
-      const contracts = manifest.val.contracts;
-      plugins.push({
-        name: pluginName,
-        contracts: contracts.map((contract) => {
-          const resolveResult = JAY_IMPORT_RESOLVER.resolvePluginComponent(
-            pluginName,
-            contract.name,
-            projectRootPath
-          );
-          if (resolveResult.validations.length > 0) {
-            getLogger().warn(
-              `Failed to resolve plugin component for ${pluginName}:${contract.name}:`,
-              resolveResult.validations
-            );
-            return null;
-          }
-          if (!resolveResult.val) {
-            getLogger().warn(
-              `Failed to resolve plugin component for ${pluginName}:${contract.name}:`,
-              resolveResult.validations
-            );
-            return null;
-          }
-          const expandedContract = loadAndExpandContract(resolveResult.val.contractPath);
-          if (!expandedContract) {
-            return null;
-          }
-          return expandedContract;
-        })
-      });
-    }
-  } catch (error) {
-    getLogger().error("Error scanning plugins:", error);
-  }
-  return plugins;
-}
-async function loadProjectPage(pageContext, plugins) {
-  const { dirPath, pageUrl, pageName, hasPageHtml, hasPageContract, hasPageConfig } = pageContext;
-  const pageFilePath = path.join(dirPath, PAGE_FILENAME);
-  const pageConfigPath = path.join(dirPath, PAGE_CONFIG_FILENAME);
-  const contractPath = path.join(dirPath, PAGE_CONTRACT_FILENAME);
-  const projectRootPath = process.cwd();
-  let usedComponents = [];
-  let contract;
-  if (hasPageContract) {
-    const parsedContract = loadAndExpandContract(contractPath);
-    if (parsedContract) {
-      contract = parsedContract;
-    }
-  }
-  if (hasPageHtml) {
-    try {
-      const jayHtmlContent = await fs.promises.readFile(pageFilePath, "utf-8");
-      usedComponents = await extractHeadlessComponentsFromJayHtml(
-        jayHtmlContent,
-        pageFilePath,
-        projectRootPath
-      );
-    } catch (error) {
-      getLogger().warn(`Failed to read page file ${pageFilePath}:`, error);
-    }
-  } else if (hasPageConfig) {
-    try {
-      const configContent = await fs.promises.readFile(pageConfigPath, "utf-8");
-      const pageConfig = YAML.parse(configContent);
-      if (pageConfig.used_components && Array.isArray(pageConfig.used_components)) {
-        for (const comp of pageConfig.used_components) {
-          const key = comp.key || "";
-          if (comp.plugin && comp.contract) {
-            const plugin = plugins.find((p) => p.name === comp.plugin);
-            if (plugin && plugin.contracts) {
-              const contract2 = plugin.contracts.find((c) => c.name === comp.contract);
-              if (contract2) {
-                usedComponents.push({
-                  appName: comp.plugin,
-                  componentName: comp.contract,
-                  key
-                });
-                continue;
-              }
-            }
-            usedComponents.push({
-              appName: comp.plugin,
-              componentName: comp.contract,
-              key
-            });
-          } else {
-            getLogger().warn(
-              `Invalid component definition in ${pageConfigPath}: Only plugin/contract syntax is supported for headless components. Found:`,
-              comp
-            );
-          }
-        }
       }
-    } catch (error) {
-      getLogger().warn(`Failed to parse page config ${pageConfigPath}:`, error);
-    }
+    };
+  } catch (error) {
+    getLogger().warn(`Failed to parse .jay YAML config file, using defaults: ${error}`);
+    return DEFAULT_CONFIG;
   }
-  return {
-    name: pageName,
-    url: pageUrl,
-    filePath: pageFilePath,
-    contract,
-    usedComponents
-  };
 }
-async function scanProjectInfo(pagesBasePath, componentsBasePath, configBasePath, projectRootPath) {
-  const [projectName, components, plugins] = await Promise.all([
-    getProjectName(configBasePath),
-    scanProjectComponents(componentsBasePath),
-    scanPlugins(projectRootPath)
-  ]);
-  const pages = [];
-  await scanPageDirectories(pagesBasePath, async (context) => {
-    const page = await loadProjectPage(context, plugins);
-    pages.push(page);
-  });
+function getConfigWithDefaults(config) {
   return {
-    name: projectName,
-    localPath: projectRootPath,
-    pages,
-    components,
-    plugins
+    devServer: {
+      portRange: config.devServer?.portRange || DEFAULT_CONFIG.devServer.portRange,
+      pagesBase: config.devServer?.pagesBase || DEFAULT_CONFIG.devServer.pagesBase,
+      componentsBase: config.devServer?.componentsBase || DEFAULT_CONFIG.devServer.componentsBase,
+      publicFolder: config.devServer?.publicFolder || DEFAULT_CONFIG.devServer.publicFolder,
+      configBase: config.devServer?.configBase || DEFAULT_CONFIG.devServer.configBase
+    }
   };
 }
-async function handlePagePublish(resolvedConfig, page) {
-  try {
-    const pagesBasePath = path.resolve(resolvedConfig.devServer.pagesBase);
-    const dirname = pageUrlToDirectoryPath(page.route, pagesBasePath);
-    const fullPath = path.join(dirname, PAGE_FILENAME);
-    await fs.promises.mkdir(dirname, { recursive: true });
-    await fs.promises.writeFile(fullPath, page.jayHtml, "utf-8");
-    let contractPath;
-    if (page.contract) {
-      contractPath = path.join(dirname, `page${JAY_CONTRACT_EXTENSION}`);
-      await fs.promises.writeFile(contractPath, page.contract, "utf-8");
-      getLogger().info(`📄 Published page contract: ${contractPath}`);
-    }
-    const createdJayHtml = {
-      jayHtml: page.jayHtml,
-      filename: PAGE_FILENAME,
-      dirname,
-      fullPath
-    };
-    getLogger().info(`📝 Published page: ${fullPath}`);
-    return [
-      {
-        success: true,
-        filePath: fullPath,
-        contractPath
-      },
-      createdJayHtml
-    ];
-  } catch (error) {
-    getLogger().error(`Failed to publish page ${page.route}:`, error);
-    return [
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      void 0
-    ];
-  }
-}
-async function handleComponentPublish(resolvedConfig, component) {
+function updateConfig(updates) {
+  const configPath = path.resolve(".jay");
   try {
-    const dirname = path.resolve(resolvedConfig.devServer.componentsBase);
-    const filename = `${component.name}${JAY_EXTENSION}`;
-    const fullPath = path.join(dirname, filename);
-    await fs.promises.mkdir(dirname, { recursive: true });
-    await fs.promises.writeFile(fullPath, component.jayHtml, "utf-8");
-    let contractPath;
-    if (component.contract) {
-      contractPath = path.join(dirname, `${component.name}${JAY_CONTRACT_EXTENSION}`);
-      await fs.promises.writeFile(contractPath, component.contract, "utf-8");
-    }
-    const createdJayHtml = {
-      jayHtml: component.jayHtml,
-      filename,
-      dirname,
-      fullPath
+    const existingConfig = loadConfig();
+    const updatedConfig = {
+      ...existingConfig,
+      ...updates,
+      devServer: {
+        ...existingConfig.devServer,
+        ...updates.devServer
+      }
     };
-    getLogger().info(`🧩 Published component: ${fullPath}`);
-    return [
-      {
-        success: true,
-        filePath: fullPath,
-        contractPath
-      },
-      createdJayHtml
-    ];
+    const yamlContent = YAML.stringify(updatedConfig, { indent: 2 });
+    fs.writeFileSync(configPath, yamlContent);
   } catch (error) {
-    getLogger().error(`Failed to publish component ${component.name}:`, error);
-    return [
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      void 0
-    ];
+    getLogger().warn(`Failed to update .jay config file: ${error}`);
   }
 }
-async function loadPageContracts(dirPath, pageUrl, projectRootPath) {
-  const { hasPageHtml, hasPageContract, hasPageConfig } = await isPageDirectory(dirPath);
-  const plugins = await scanPlugins(projectRootPath);
-  const pageInfo = await loadProjectPage(
-    {
-      dirPath,
-      pageUrl,
-      pageName: path.basename(dirPath),
-      hasPageHtml,
-      hasPageContract,
-      hasPageConfig
-    },
-    plugins
-  );
-  return { projectPage: pageInfo, plugins };
-}
-function createEditorHandlers(config, tsConfigPath, projectRoot) {
-  const onPublish = async (params) => {
-    const status = [];
-    const createdJayHtmls = [];
-    if (params.pages) {
-      for (const page of params.pages) {
-        const [pageStatus, createdJayHtml] = await handlePagePublish(config, page);
-        status.push(pageStatus);
-        if (pageStatus.success)
-          createdJayHtmls.push(createdJayHtml);
-      }
-    }
-    if (params.components) {
-      for (const component of params.components) {
-        const [compStatus, createdJayHtml] = await handleComponentPublish(
-          config,
-          component
-        );
-        status.push(compStatus);
-        if (compStatus.success)
-          createdJayHtmls.push(createdJayHtml);
-      }
-    }
-    for (const { jayHtml, dirname, filename, fullPath } of createdJayHtmls) {
-      const parsedJayHtml = await parseJayFile(
-        jayHtml,
-        filename,
-        dirname,
-        { relativePath: tsConfigPath },
-        JAY_IMPORT_RESOLVER,
-        projectRoot
-      );
-      const definitionFile = generateElementDefinitionFile(parsedJayHtml);
-      if (definitionFile.validations.length > 0)
-        getLogger().info(
-          `failed to generate .d.ts for ${fullPath} with validation errors: ${definitionFile.validations.join("\n")}`
-        );
-      else
-        await fs.promises.writeFile(fullPath + ".d.ts", definitionFile.val, "utf-8");
-    }
-    return {
-      type: "publish",
-      success: status.every((s2) => s2.success),
-      status
-    };
-  };
-  const onSaveImage = async (params) => {
-    try {
-      const imagesDir = path.join(path.resolve(config.devServer.publicFolder), "images");
-      await fs.promises.mkdir(imagesDir, { recursive: true });
-      const filename = `${params.imageId}.png`;
-      const imagePath = path.join(imagesDir, filename);
-      await fs.promises.writeFile(imagePath, Buffer.from(params.imageData, "base64"));
-      getLogger().info(`🖼️  Saved image: ${imagePath}`);
-      return {
-        type: "saveImage",
-        success: true,
-        imageUrl: `/images/${filename}`
-      };
-    } catch (error) {
-      getLogger().error("Failed to save image:", error);
-      return {
-        type: "saveImage",
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  };
-  const onHasImage = async (params) => {
-    try {
-      const filename = `${params.imageId}.png`;
-      const imagePath = path.join(
-        path.resolve(config.devServer.publicFolder),
-        "images",
-        filename
-      );
-      const exists = fs.existsSync(imagePath);
-      return {
-        type: "hasImage",
-        success: true,
-        exists,
-        imageUrl: exists ? `/images/${filename}` : void 0
-      };
-    } catch (error) {
-      getLogger().error("Failed to check image:", error);
-      return {
-        type: "hasImage",
-        success: false,
-        exists: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  };
-  const onGetProjectInfo = async (params) => {
-    try {
-      const pagesBasePath = path.resolve(config.devServer.pagesBase);
-      const componentsBasePath = path.resolve(config.devServer.componentsBase);
-      const configBasePath = path.resolve(config.devServer.configBase);
-      const info = await scanProjectInfo(
-        pagesBasePath,
-        componentsBasePath,
-        configBasePath,
-        projectRoot
-      );
-      getLogger().info(`📋 Retrieved project info: ${info.name}`);
-      getLogger().info(`   Pages: ${info.pages.length}`);
-      getLogger().info(`   Components: ${info.components.length}`);
-      getLogger().info(`   plugins: ${info.plugins.length}`);
-      return {
-        type: "getProjectInfo",
-        success: true,
-        info
-      };
-    } catch (error) {
-      getLogger().error("Failed to get project info:", error);
-      return {
-        type: "getProjectInfo",
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error",
-        info: {
-          name: "Error",
-          localPath: process.cwd(),
-          pages: [],
-          components: [],
-          plugins: []
-        }
-      };
-    }
-  };
-  const onExport = async (params) => {
-    try {
-      const pagesBasePath = path.resolve(config.devServer.pagesBase);
-      const { vendorId, pageUrl, vendorDoc } = params;
-      const dirname = pageUrlToDirectoryPath(pageUrl, pagesBasePath);
-      const vendorFilename = `page.${vendorId}.json`;
-      const vendorFilePath = path.join(dirname, vendorFilename);
-      await fs.promises.mkdir(dirname, { recursive: true });
-      await fs.promises.writeFile(
-        vendorFilePath,
-        JSON.stringify(vendorDoc, null, 2),
-        "utf-8"
-      );
-      getLogger().info(`📦 Exported ${vendorId} document to: ${vendorFilePath}`);
-      if (hasVendor(vendorId)) {
-        getLogger().info(`🔄 Converting ${vendorId} document to Jay HTML...`);
-        const vendor = getVendor(vendorId);
-        try {
-          const { projectPage, plugins } = await loadPageContracts(
-            dirname,
-            pageUrl,
-            projectRoot
-          );
-          const conversionResult = await vendor.convertToBodyHtml(
-            vendorDoc,
-            pageUrl,
-            projectPage,
-            plugins
-          );
-          const fullJayHtml = await buildJayHtmlFromVendorResult(
-            conversionResult,
-            dirname,
-            path.basename(dirname)
-          );
-          const jayHtmlPath = path.join(dirname, "page.jay-html");
-          await fs.promises.writeFile(jayHtmlPath, fullJayHtml, "utf-8");
-          getLogger().info(`✅ Successfully converted to Jay HTML: ${jayHtmlPath}`);
-          return {
-            type: "export",
-            success: true,
-            vendorSourcePath: vendorFilePath,
-            jayHtmlPath
-          };
-        } catch (conversionError) {
-          getLogger().error(`❌ Vendor conversion threw an error:`, conversionError);
-          return {
-            type: "export",
-            success: false,
-            vendorSourcePath: vendorFilePath,
-            error: conversionError instanceof Error ? conversionError.message : "Unknown conversion error"
-          };
-        }
-      } else {
-        getLogger().info(`ℹ️  No vendor found for '${vendorId}'. Skipping conversion.`);
-      }
-      return {
-        type: "export",
-        success: true,
-        vendorSourcePath: vendorFilePath
-      };
-    } catch (error) {
-      getLogger().error("Failed to export vendor document:", error);
-      return {
-        type: "export",
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  };
-  const onImport = async (params) => {
-    try {
-      const pagesBasePath = path.resolve(config.devServer.pagesBase);
-      const { vendorId, pageUrl } = params;
-      const dirname = pageUrlToDirectoryPath(pageUrl, pagesBasePath);
-      const vendorFilename = `page.${vendorId}.json`;
-      const vendorFilePath = path.join(dirname, vendorFilename);
-      if (!fs.existsSync(vendorFilePath)) {
-        return {
-          type: "import",
-          success: false,
-          error: `No ${vendorId} document found at ${pageUrl}. File not found: ${vendorFilePath}`
-        };
-      }
-      const fileContent = await fs.promises.readFile(vendorFilePath, "utf-8");
-      const vendorDoc = JSON.parse(fileContent);
-      getLogger().info(`📥 Imported ${vendorId} document from: ${vendorFilePath}`);
-      return {
-        type: "import",
-        success: true,
-        vendorDoc
-      };
-    } catch (error) {
-      getLogger().error("Failed to import vendor document:", error);
-      return {
-        type: "import",
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  };
-  return {
-    onPublish,
-    onSaveImage,
-    onHasImage,
-    onGetProjectInfo,
-    onExport,
-    onImport
-  };
-}
 async function generatePageDefinitionFiles(routes, tsConfigPath, projectRoot) {
   for (const route of routes) {
     const jayHtmlPath = route.fsRoute.jayHtmlPath;
@@ -2415,36 +136,6 @@ async function startDevServer(options = {}) {
   const httpServer = http.createServer(app);
   const devServerPort = await getPort({ port: resolvedConfig.devServer.portRange });
   const log = getLogger();
-  const editorServer = createEditorServer({
-    portRange: resolvedConfig.editorServer.portRange,
-    editorId: resolvedConfig.editorServer.editorId,
-    onEditorId: (editorId2) => {
-      log.info(`Editor connected with ID: ${editorId2}`);
-      updateConfig({
-        editorServer: {
-          editorId: editorId2
-        }
-      });
-    }
-  });
-  const { port: editorPort, editorId } = await editorServer.start();
-  const registeredVendors = getRegisteredVendors();
-  if (registeredVendors.length > 0) {
-    log.info(
-      `📦 Registered ${registeredVendors.length} vendor(s): ${registeredVendors.join(", ")}`
-    );
-  }
-  const handlers = createEditorHandlers(
-    resolvedConfig,
-    jayOptions.tsConfigFilePath,
-    process.cwd()
-  );
-  editorServer.onPublish(handlers.onPublish);
-  editorServer.onSaveImage(handlers.onSaveImage);
-  editorServer.onHasImage(handlers.onHasImage);
-  editorServer.onGetProjectInfo(handlers.onGetProjectInfo);
-  editorServer.onExport(handlers.onExport);
-  editorServer.onImport(handlers.onImport);
   const { server, viteServer, routes, service } = await mkDevServer({
     pagesRootFolder: path.resolve(resolvedConfig.devServer.pagesBase),
     projectRootFolder: process.cwd(),
@@ -2454,73 +145,6 @@ async function startDevServer(options = {}) {
     httpServer
   });
   app.use(server);
-  const { freezeStore } = service;
-  editorServer.onListRoutes(async () => ({
-    type: "listRoutes",
-    success: true,
-    routes: service.listRoutes()
-  }));
-  if (freezeStore) {
-    editorServer.onListFreezes(async (params) => ({
-      type: "listFreezes",
-      success: true,
-      freezes: (await freezeStore.list(params.route)).map(
-        ({ id, name, route, routePattern, createdAt }) => ({
-          id,
-          name,
-          route,
-          routePattern,
-          createdAt
-        })
-      )
-    }));
-    editorServer.onRenameFreeze(async (params) => ({
-      type: "renameFreeze",
-      success: await freezeStore.rename(params.id, params.name)
-    }));
-    editorServer.onDeleteFreeze(async (params) => ({
-      type: "deleteFreeze",
-      success: await freezeStore.delete(params.id)
-    }));
-    viteServer.watcher.on("change", (changedPath) => {
-      if (changedPath.endsWith(".jay-html") || changedPath.endsWith(".css")) {
-        editorServer.emitFreezeChanged();
-      }
-    });
-  }
-  editorServer.onLoadRouteParams(async (params) => {
-    const routePath = params.route;
-    try {
-      (async () => {
-        try {
-          for await (const batch of service.loadRouteParams(routePath)) {
-            editorServer.emitRouteParamsBatch({
-              type: "routeParamsBatch",
-              route: routePath,
-              params: batch,
-              hasMore: true
-            });
-          }
-          editorServer.emitRouteParamsBatch({
-            type: "routeParamsBatch",
-            route: routePath,
-            params: [],
-            hasMore: false
-          });
-        } catch (err) {
-          editorServer.emitRouteParamsBatch({
-            type: "routeParamsBatch",
-            route: routePath,
-            params: [],
-            hasMore: false
-          });
-        }
-      })();
-      return { type: "loadRouteParams", success: true };
-    } catch (err) {
-      return { type: "loadRouteParams", success: false, error: err.message };
-    }
-  });
   const publicPath = path.resolve(resolvedConfig.devServer.publicFolder);
   if (fs.existsSync(publicPath)) {
     app.use(express.static(publicPath));
@@ -2539,7 +163,6 @@ async function startDevServer(options = {}) {
   httpServer.listen(devServerPort, () => {
     log.important(`🚀 Jay Stack dev server started successfully!`);
     log.important(`📱 Dev Server: http://localhost:${devServerPort}`);
-    log.important(`🎨 Editor Server: http://localhost:${editorPort} (ID: ${editorId})`);
     log.important(`📁 Pages directory: ${resolvedConfig.devServer.pagesBase}`);
     if (fs.existsSync(publicPath)) {
       log.important(`📁 Public folder: ${resolvedConfig.devServer.publicFolder}`);
@@ -2557,7 +180,6 @@ async function startDevServer(options = {}) {
   });
   const shutdown = async () => {
     log.important("\n🛑 Shutting down servers...");
-    await editorServer.stop();
     httpServer.closeAllConnections();
     await new Promise((resolve) => httpServer.close(resolve));
     process.exit(0);
@@ -2567,7 +189,6 @@ async function startDevServer(options = {}) {
       res.json({
         status: "ready",
         port: devServerPort,
-        editorPort,
         uptime: process.uptime()
       });
     });
@@ -2588,25 +209,25 @@ async function startDevServer(options = {}) {
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-async function initializeServicesForCli(projectRoot, viteServer) {
+async function initializeServicesForCli(projectRoot, viteServer, quiet = false) {
   const path2 = await import("node:path");
   const fs2 = await import("node:fs");
   const {
-    runInitCallbacks,
+    runInitCallbacks: runInitCallbacks2,
     getServiceRegistry,
-    discoverPluginsWithInit,
-    sortPluginsByDependencies,
-    executePluginServerInits
+    discoverPluginsWithInit: discoverPluginsWithInit2,
+    sortPluginsByDependencies: sortPluginsByDependencies2,
+    executePluginServerInits: executePluginServerInits2
   } = await import("@jay-framework/stack-server-runtime");
   let initErrors = /* @__PURE__ */ new Map();
   try {
-    const discoveredPlugins = await discoverPluginsWithInit({
+    const discoveredPlugins = await discoverPluginsWithInit2({
       projectRoot,
       verbose: false
     });
-    const pluginsWithInit = sortPluginsByDependencies(discoveredPlugins);
+    const pluginsWithInit = sortPluginsByDependencies2(discoveredPlugins);
     try {
-      initErrors = await executePluginServerInits(pluginsWithInit, viteServer, false);
+      initErrors = await executePluginServerInits2(pluginsWithInit, viteServer, false, quiet);
     } catch (error) {
       getLogger().warn(chalk.yellow(`⚠️  Plugin initialization skipped: ${error.message}`));
     }
@@ -2621,7 +242,7 @@ async function initializeServicesForCli(projectRoot, viteServer) {
     if (initModule?.init?._serverInit) {
       await initModule.init._serverInit();
     }
-    await runInitCallbacks();
+    await runInitCallbacks2();
   } catch (error) {
     getLogger().warn(chalk.yellow(`⚠️  Service initialization failed: ${error.message}`));
     getLogger().warn(chalk.gray("   Static contracts will still be listed."));
@@ -3029,7 +650,7 @@ const FOLDER_PATH_MAX_SEGMENTS = 32;
 const BLOCKED_TAGS = /<\s*(script|iframe|object|embed)\b[^>]*>[\s\S]*?<\/\s*\1\s*>|<\s*(script|iframe|object|embed)\b[^>]*\/?>/gi;
 const EVENT_HANDLER_ATTR = /\s+on[a-z]+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi;
 const JAVASCRIPT_URL = /\b(href|src|xlink:href)\s*=\s*("|')\s*javascript:/gi;
-function isRecord(value) {
+function isRecord$1(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function byteLengthUtf8(value) {
@@ -3099,7 +720,7 @@ function optionalString(obj, field) {
 function validateInteraction(raw, itemPath, errors) {
   if (raw === void 0)
     return void 0;
-  if (!isRecord(raw)) {
+  if (!isRecord$1(raw)) {
     errors.push({
       path: itemPath,
       message: "interaction must be an object",
@@ -3124,7 +745,7 @@ function validateInteraction(raw, itemPath, errors) {
 function validatePresentation(raw, itemPath, errors) {
   if (raw === void 0)
     return void 0;
-  if (!isRecord(raw)) {
+  if (!isRecord$1(raw)) {
     errors.push({
       path: itemPath,
       message: "presentation must be an object",
@@ -3197,7 +818,7 @@ const BROWSE_SIZES = /* @__PURE__ */ new Set(["large", "medium", "small"]);
 function validateBrowse(raw, itemPath, errors) {
   if (raw === void 0)
     return void 0;
-  if (!isRecord(raw)) {
+  if (!isRecord$1(raw)) {
     errors.push({
       path: itemPath,
       message: "browse must be an object",
@@ -3280,7 +901,7 @@ function validateFolderPath(raw, itemPath, errors) {
 }
 function validateAddMenuItem(raw, itemPath) {
   const errors = [];
-  if (!isRecord(raw)) {
+  if (!isRecord$1(raw)) {
     return {
       item: null,
       errors: [
@@ -3331,7 +952,7 @@ function validateAddMenuItem(raw, itemPath) {
 }
 function validateAddMenuCatalogFile(raw, sourcePath) {
   const errors = [];
-  if (!isRecord(raw)) {
+  if (!isRecord$1(raw)) {
     return {
       file: null,
       errors: [
@@ -3690,7 +1311,7 @@ function suggestionForCode(code) {
     return `See ${CONTRIBUTOR_GUIDE} for schema and validation rules`;
   return ADD_MENU_VALIDATION_SUGGESTIONS[code] ?? `See ${CONTRIBUTOR_GUIDE} for schema and validation rules`;
 }
-function mapSchemaError(error, catalogPath) {
+function mapSchemaError$1(error, catalogPath) {
   const code = error.code ?? "catalog-validation-error";
   return {
     type: "add-menu-catalog",
@@ -3764,7 +1385,7 @@ async function validateAddMenuCatalogFileAtPath(catalogPath, relPath, result) {
     return;
   }
   const validated = validateAddMenuCatalogFile(parsed, relPath);
-  result.errors.push(...validated.errors.map((error) => mapSchemaError(error, relPath)));
+  result.errors.push(...validated.errors.map((error) => mapSchemaError$1(error, relPath)));
   if (!validated.file?.items.length) {
     return;
   }
@@ -3785,6 +1406,173 @@ async function validateAddMenuCatalog(context, result) {
     await validateAddMenuCatalogFileAtPath(catalogPath, relPath, result);
   }
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRequires(raw, filePath) {
+  const errors = [];
+  if (raw === void 0) {
+    return { requires: [], errors };
+  }
+  if (!Array.isArray(raw)) {
+    errors.push({
+      path: `${filePath}.requires`,
+      message: "requires must be an array",
+      code: "settings-requires-type"
+    });
+    return { requires: [], errors };
+  }
+  const requires = [];
+  raw.forEach((entry, index) => {
+    if (!isRecord(entry)) {
+      errors.push({
+        path: `${filePath}.requires[${index}]`,
+        message: "require entry must be an object",
+        code: "settings-require-shape"
+      });
+      return;
+    }
+    if (typeof entry.plugin !== "string" || !entry.plugin.trim()) {
+      errors.push({
+        path: `${filePath}.requires[${index}].plugin`,
+        message: "plugin is required",
+        code: "settings-require-plugin"
+      });
+      return;
+    }
+    if (entry.status !== "configured") {
+      errors.push({
+        path: `${filePath}.requires[${index}].status`,
+        message: 'status must be "configured"',
+        code: "settings-require-status"
+      });
+      return;
+    }
+    requires.push({ plugin: entry.plugin.trim(), status: "configured" });
+  });
+  return { requires, errors };
+}
+function validateAiditorSettingsFile(raw, sourcePath) {
+  const errors = [];
+  if (!isRecord(raw)) {
+    return {
+      errors: [
+        {
+          path: sourcePath,
+          message: "settings file must be a YAML object",
+          code: "settings-root-type"
+        }
+      ]
+    };
+  }
+  if (typeof raw.label !== "string" || !raw.label.trim()) {
+    errors.push({
+      path: `${sourcePath}.label`,
+      message: "label is required",
+      code: "settings-label"
+    });
+  }
+  if (typeof raw.route !== "string" || !raw.route.trim()) {
+    errors.push({
+      path: `${sourcePath}.route`,
+      message: "route is required",
+      code: "settings-route"
+    });
+  } else if (!raw.route.startsWith("/")) {
+    errors.push({
+      path: `${sourcePath}.route`,
+      message: "route must start with /",
+      code: "settings-route-format"
+    });
+  }
+  if (raw.pluginName !== void 0 && typeof raw.pluginName !== "string") {
+    errors.push({
+      path: `${sourcePath}.pluginName`,
+      message: "pluginName must be a string",
+      code: "settings-plugin-name-type"
+    });
+  }
+  const { requires, errors: requireErrors } = parseRequires(raw.requires, sourcePath);
+  errors.push(...requireErrors);
+  if (errors.length > 0) {
+    return { errors };
+  }
+  return {
+    file: {
+      label: raw.label.trim(),
+      route: raw.route.trim(),
+      ...typeof raw.pluginName === "string" && raw.pluginName.trim() ? { pluginName: raw.pluginName.trim() } : {},
+      ...requires.length > 0 ? { requires } : {}
+    },
+    errors: []
+  };
+}
+const AIDITOR_SETTINGS_TEMPLATE_REL_PATH = "agent-kit/aiditor/settings.template.yaml";
+function mapSchemaError(error, relPath) {
+  return {
+    type: "schema",
+    message: error.message,
+    location: error.path || relPath,
+    code: error.code
+  };
+}
+function validateSettingsTemplateAtPath(catalogPath, relPath, result, manifest) {
+  let parsed;
+  try {
+    parsed = YAML.parse(fs.readFileSync(catalogPath, "utf-8"));
+  } catch (err) {
+    result.errors.push({
+      type: "schema",
+      message: `Invalid YAML in ${relPath}: ${err instanceof Error ? err.message : String(err)}`,
+      location: relPath
+    });
+    return;
+  }
+  const validated = validateAiditorSettingsFile(parsed, relPath);
+  result.errors.push(...validated.errors.map((error) => mapSchemaError(error, relPath)));
+  if (!validated.file) {
+    return;
+  }
+  const routeEntry = manifest.routes?.find((route) => route.path === validated.file.route);
+  if (!routeEntry) {
+    result.warnings.push({
+      type: "schema",
+      message: `settings route "${validated.file.route}" is not declared in plugin.yaml routes[]`,
+      location: relPath,
+      code: "settings-route-missing",
+      suggestion: "Add a matching routes[] entry or fix the route in settings.template.yaml"
+    });
+  } else if (routeEntry.devOnly !== true) {
+    result.warnings.push({
+      type: "schema",
+      message: `settings route "${validated.file.route}" should declare devOnly: true on routes[]`,
+      location: "plugin.yaml routes",
+      code: "settings-route-dev-only",
+      suggestion: "Add devOnly: true when the settings page is dev-server tooling (see Design Log #171)"
+    });
+  }
+}
+async function validateAiditorSettings(context, result) {
+  const templatePath = path.join(context.pluginPath, AIDITOR_SETTINGS_TEMPLATE_REL_PATH);
+  if (!fs.existsSync(templatePath)) {
+    return;
+  }
+  validateSettingsTemplateAtPath(
+    templatePath,
+    AIDITOR_SETTINGS_TEMPLATE_REL_PATH,
+    result,
+    context.manifest
+  );
+  if (!context.manifest.agentkit) {
+    result.warnings.push({
+      type: "schema",
+      message: "Plugin ships agent-kit/aiditor/settings.template.yaml but has no agentkit handler",
+      location: "plugin.yaml",
+      code: "settings-missing-agentkit-handler",
+      suggestion: "Declare agentkit in plugin.yaml and materialize to agent-kit/aiditor/settings/<plugin>.yaml on jay-stack agent-kit — see agent-kit/plugin/aiditor-settings-guide.md"
+    });
+  }
+}
 async function validatePlugin(options = {}) {
   const pluginPath = options.pluginPath || process.cwd();
   if (options.local) {
@@ -3852,6 +1640,7 @@ async function validatePluginPackage(pluginPath, options) {
     await validateDynamicContracts(context, result);
   }
   await validateAddMenuCatalog(context, result);
+  await validateAiditorSettings(context, result);
   result.valid = result.errors.length === 0;
   return result;
 }
@@ -4161,6 +1950,13 @@ async function validateSchema(context, result) {
         if (route.css) {
           validateDocFile(route.css, `route "${route.path}" css`, context, result);
         }
+        if (route.devOnly !== void 0 && typeof route.devOnly !== "boolean") {
+          result.errors.push({
+            type: "schema",
+            message: `Route "${route.path}" devOnly must be a boolean`,
+            location: "plugin.yaml"
+          });
+        }
       });
     }
   }
@@ -5230,7 +3026,7 @@ function resolveContractLinks(contract, contractPath) {
   return { ...contract, tags: resolveLinkedTags(contract.tags, contractDir) };
 }
 async function runPluginValidators(projectRoot, parsedFiles, errors, warnings) {
-  const scannedPlugins = await scanPlugins$1({ projectRoot, includeDevDeps: true });
+  const scannedPlugins = await scanPlugins({ projectRoot, includeDevDeps: true });
   const loadedValidators = [];
   for (const [, plugin] of scannedPlugins) {
     if (!plugin.manifest.validators)
@@ -5354,12 +3150,18 @@ async function validateJayFiles(options = {}) {
   const resolvedConfig = getConfigWithDefaults(config);
   const projectRoot = options.projectRoot ?? process.cwd();
   const scanDir = options.path ? path.resolve(options.path) : path.resolve(resolvedConfig.devServer.pagesBase);
+  const componentsDir = path.resolve(resolvedConfig.devServer.componentsBase);
   const errors = [];
   const warnings = [];
   const coverage = [];
   const parsedFiles = [];
-  const jayHtmlFiles = await findJayFiles(scanDir);
-  const contractFiles = await findContractFiles(scanDir);
+  const pageJayHtmlFiles = await findJayFiles(scanDir);
+  const componentJayHtmlFiles = await findJayFiles(componentsDir).catch(() => []);
+  const jayHtmlFiles = [...pageJayHtmlFiles, ...componentJayHtmlFiles];
+  const contractFiles = [
+    ...await findContractFiles(scanDir),
+    ...await findContractFiles(componentsDir).catch(() => [])
+  ];
   if (options.verbose) {
     getLogger().info(chalk.gray(`Scanning directory: ${scanDir}`));
     getLogger().info(chalk.gray(`Found ${jayHtmlFiles.length} .jay-html files`));
@@ -5607,6 +3409,14 @@ function printJayValidationResult(result, options) {
   } else {
     logger.important(chalk.red(`Validation failed — ${result.errors.length} error(s).`));
   }
+  const totalIssues = result.errors.length + result.warnings.length + result.coverage.length;
+  if (totalIssues > 0) {
+    logger.important(
+      chalk.gray(
+        "\nSee: agent-kit/designer/validation-guide.md for how to interpret and suppress warnings."
+      )
+    );
+  }
 }
 async function runValidate(scanPath, options) {
   const result = await validateJayFiles({
@@ -5819,7 +3629,7 @@ async function copyDirRecursive(src, dest) {
   }
 }
 async function mergePluginAgentKitGuides(projectRoot, mode) {
-  const plugins = await scanPlugins$1({ projectRoot, includeDevDeps: true });
+  const plugins = await scanPlugins({ projectRoot, includeDevDeps: true });
   const agentKitDir = path$1.join(projectRoot, "agent-kit");
   const roles = mode && ALL_ROLES.includes(mode) ? [mode] : ALL_ROLES;
   const copiedPerRole = /* @__PURE__ */ new Map();
@@ -6170,19 +3980,17 @@ function createDefaultPrompt(pluginName) {
     }
   };
 }
-async function runSetup(pluginFilter, options, projectRoot, initializeServices) {
+async function runSetup(pluginFilter, options, projectRoot) {
   let viteServer;
   try {
     const logger = getLogger();
-    const path2 = await import("node:path");
     const jayConfig = loadConfig();
-    const configDir = path2.resolve(projectRoot, jayConfig.devServer?.configBase || "./config");
+    const configDir = path$1.resolve(projectRoot, jayConfig.devServer?.configBase || "./config");
     logger.important(chalk.bold("\n🔧 Setting up plugins...\n"));
     if (options.verbose) {
       logger.info("Starting Vite for TypeScript support...");
     }
     viteServer = await createViteForCli({ projectRoot });
-    const { discoverPluginsWithSetup, executePluginSetup } = await import("@jay-framework/stack-server-runtime");
     const pluginsWithSetup = await discoverPluginsWithSetup({
       projectRoot,
       verbose: options.verbose,
@@ -6203,12 +4011,9 @@ async function runSetup(pluginFilter, options, projectRoot, initializeServices)
         `Found ${pluginsWithSetup.length} plugin(s) with setup: ${pluginsWithSetup.map((p) => p.name).join(", ")}`
       );
     }
-    const { initErrors } = await initializeServices(projectRoot, viteServer);
-    if (initErrors.size > 0 && options.verbose) {
-      for (const [name, err] of initErrors) {
-        logger.info(chalk.yellow(`⚠️  ${name} init error: ${err.message}`));
-      }
-    }
+    const allPluginsWithInit = sortPluginsByDependencies(
+      await discoverPluginsWithInit({ projectRoot, verbose: options.verbose })
+    );
     const interactive = options.interactive === true;
     let answersMap;
     if (options.answers) {
@@ -6230,14 +4035,13 @@ async function runSetup(pluginFilter, options, projectRoot, initializeServices)
           force: options.force ?? false,
           interactive,
           prompt,
-          initError: initErrors.get(plugin.name),
+          initError: void 0,
           viteServer,
           verbose: options.verbose
         });
         switch (result.status) {
           case "configured":
             configured++;
-            logger.important(chalk.green("   ✅ Services verified"));
             if (result.configCreated?.length) {
               for (const cfg of result.configCreated) {
                 logger.important(chalk.green(`   ✅ Created ${cfg}`));
@@ -6246,6 +4050,7 @@ async function runSetup(pluginFilter, options, projectRoot, initializeServices)
             if (result.message) {
               logger.important(chalk.gray(`   ${result.message}`));
             }
+            await initPlugin(plugin.name, allPluginsWithInit, viteServer, logger);
             break;
           case "needs-config":
             needsConfig++;
@@ -6304,6 +4109,7 @@ async function runSetup(pluginFilter, options, projectRoot, initializeServices)
       }
       logger.important("");
     }
+    await runProjectInit(projectRoot, viteServer);
     const parts = [];
     if (configured > 0)
       parts.push(`${configured} configured`);
@@ -6327,6 +4133,36 @@ async function runSetup(pluginFilter, options, projectRoot, initializeServices)
     }
   }
 }
+async function initPlugin(pluginName, allPluginsWithInit, viteServer, logger) {
+  const pluginInit = allPluginsWithInit.filter((p) => p.name === pluginName);
+  if (pluginInit.length === 0)
+    return;
+  const initErrors = await executePluginServerInits(pluginInit, viteServer, false, true);
+  if (initErrors.size > 0) {
+    for (const [, err] of initErrors) {
+      logger.important(chalk.yellow(`   ⚠️  Init after setup: ${err.message}`));
+    }
+  } else {
+    logger.important(chalk.green(`   ✅ Services initialized`));
+  }
+}
+async function runProjectInit(projectRoot, viteServer) {
+  try {
+    const initPathTs = path$1.join(projectRoot, "src", "init.ts");
+    const initPathJs = path$1.join(projectRoot, "src", "init.js");
+    let initModule;
+    if (fsSync.existsSync(initPathTs) && viteServer) {
+      initModule = await viteServer.ssrLoadModule(initPathTs);
+    } else if (fsSync.existsSync(initPathJs)) {
+      initModule = await import(initPathJs);
+    }
+    if (initModule?.init?._serverInit) {
+      await initModule.init._serverInit();
+    }
+    await runInitCallbacks();
+  } catch {
+  }
+}
 async function runCommand(commandRef, rawArgs, options, projectRoot, initializeServices) {
   let viteServer;
   try {
@@ -6556,7 +4392,7 @@ program.command("validate-plugin").description("Validate a Jay Stack plugin pack
   }
 });
 program.command("setup [plugin]").description("Run plugin setup: config templates, credential validation, reference data").option("--force", "Force re-run (overwrite config templates and regenerate references)").option("--interactive", "Prompt for input via terminal (for humans)").option("--answers <file>", "Read answers from YAML file (for agents)").option("-v, --verbose", "Show detailed output").action(async (plugin, options) => {
-  await runSetup(plugin, options, process.cwd(), initializeServicesForCli);
+  await runSetup(plugin, options, process.cwd());
 });
 program.command("agent-kit").description("Prepare agent kit: materialize contracts, generate references, write docs").option("-o, --output <dir>", "Output directory (default: agent-kit/materialized-contracts)").option("--yaml", "Output contract index as YAML to stdout").option("--list", "List contracts without writing files").option("--plugin <name>", "Filter to specific plugin").option("--dynamic-only", "Only process dynamic contracts").option("--force", "Force re-materialization").option("--no-references", "Skip reference data generation").option(
   "-m, --mode <role>",
@@ -6582,11 +4418,7 @@ if (!process.argv.slice(2).length) {
   program.outputHelp();
 }
 export {
-  createEditorHandlers,
   getConfigWithDefaults,
-  getRegisteredVendors,
-  getVendor,
-  hasVendor,
   listContracts2 as listContracts,
   loadConfig,
   materializeContracts2 as materializeContracts,