coderio 0.1.0-alpha.9 → 1.0.0

package/dist/index.js

@@ -11,10 +11,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
 var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
 var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
@@ -25,7 +21,7 @@ var __runInitializers = (array, flags, self, value) => {
   return value;
 };
 var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var fn, it, done, ctx, access2, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
   var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
   var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
   var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
@@ -37,9 +33,9 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   for (var i = decorators.length - 1; i >= 0; i--) {
     ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
     if (k) {
-      ctx.static = s, ctx.private = p, access2 = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
-      if (k ^ 3) access2.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
-      if (k > 2) access2.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
     }
     it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
     if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
@@ -54,74 +50,7 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// src/utils/logger.ts
-import chalk from "chalk";
-function getTimestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  const hours = String(now.getHours()).padStart(2, "0");
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const seconds = String(now.getSeconds()).padStart(2, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-}
-var logger;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    logger = {
-      /**
-       * Print standard log (alias for info logs).
-       *
-       * Many subsystems (e.g. validation) use `printLog()` as the default logging method.
-       */
-      printLog(message) {
-        console.log(message);
-      },
-      /**
-       * Print info log in blue
-       */
-      printInfoLog(message) {
-        console.log(chalk.blue(`[${getTimestamp()}] [INFO] ${message}`));
-      },
-      /**
-       * Print warning log in yellow
-       */
-      printWarnLog(message) {
-        console.warn(chalk.yellow(`[${getTimestamp()}] [WARNING] ${message}`));
-      },
-      /**
-       * Print error log in red
-       */
-      printErrorLog(message) {
-        console.error(chalk.red(`[${getTimestamp()}] [ERROR] \u2716 ${message}`));
-      },
-      /**
-       * Print test/debug log in gray
-       * Only logs in development/test environments
-       */
-      printTestLog(message) {
-        if (process.env.NODE_ENV === "development") {
-          console.log(chalk.gray(`[${getTimestamp()}] [DEBUG] ${message}`));
-        }
-      },
-      /**
-       * Print success log in green
-       */
-      printSuccessLog(message) {
-        console.log(chalk.green(`[${getTimestamp()}] [SUCCESS] \u2714 ${message}`));
-      }
-    };
-  }
-});
-
 // src/nodes/process/structure/prompt.ts
-var prompt_exports = {};
-__export(prompt_exports, {
-  extractDataListPrompt: () => extractDataListPrompt,
-  generateStructurePrompt: () => generateStructurePrompt
-});
 var generateStructurePrompt, extractDataListPrompt;
 var init_prompt = __esm({
   "src/nodes/process/structure/prompt.ts"() {
@@ -426,47 +355,6 @@ Example Output JSON Structure (for reference only):
   }
 });
 
-// src/tools/position-tool/utils/fetch-thumbnail-dimensions.ts
-var fetch_thumbnail_dimensions_exports = {};
-__export(fetch_thumbnail_dimensions_exports, {
-  fetchThumbnailDimensions: () => fetchThumbnailDimensions
-});
-import axios3 from "axios";
-import sharp4 from "sharp";
-async function fetchThumbnailDimensions(figmaThumbnailUrl) {
-  if (!figmaThumbnailUrl) {
-    return void 0;
-  }
-  try {
-    const response = await axios3.get(figmaThumbnailUrl, {
-      responseType: "arraybuffer",
-      timeout: 3e4
-    });
-    const imageBuffer = Buffer.from(response.data);
-    const metadata = await sharp4(imageBuffer).metadata();
-    if (!metadata.width || !metadata.height) {
-      return void 0;
-    }
-    return {
-      width: metadata.width,
-      height: metadata.height
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.printWarnLog(`Failed to fetch Figma thumbnail: ${errorMsg}`);
-    return void 0;
-  }
-}
-var init_fetch_thumbnail_dimensions = __esm({
-  "src/tools/position-tool/utils/fetch-thumbnail-dimensions.ts"() {
-    "use strict";
-    init_logger();
-  }
-});
-
-// src/graph.ts
-import { StateGraph, START, END } from "@langchain/langgraph";
-
 // src/types/graph-types.ts
 var GraphNode = /* @__PURE__ */ ((GraphNode2) => {
   GraphNode2["INITIAL"] = "initial";
@@ -476,20 +364,23 @@ var GraphNode = /* @__PURE__ */ ((GraphNode2) => {
   GraphNode2["CODE"] = "code";
   return GraphNode2;
 })(GraphNode || {});
-
-// src/state.ts
-import { Annotation, MessagesAnnotation } from "@langchain/langgraph";
-var GraphStateAnnotation = Annotation.Root({
-  ...MessagesAnnotation.spec,
-  urlInfo: Annotation(),
-  workspace: Annotation(),
-  figmaInfo: Annotation(),
-  protocol: Annotation(),
-  config: Annotation()
-});
-
-// src/agents/initial-agent/index.ts
-import { Agent } from "evoltagent";
+var ValidationMode = /* @__PURE__ */ ((ValidationMode2) => {
+  ValidationMode2["CodeOnly"] = "codeOnly";
+  ValidationMode2["ReportOnly"] = "reportOnly";
+  ValidationMode2["Full"] = "full";
+  return ValidationMode2;
+})(ValidationMode || {});
+
+// src/types/figma-types.ts
+var FigmaImageFormat = /* @__PURE__ */ ((FigmaImageFormat2) => {
+  FigmaImageFormat2["PNG"] = "png";
+  FigmaImageFormat2["JPG"] = "jpg";
+  FigmaImageFormat2["SVG"] = "svg";
+  FigmaImageFormat2["PDF"] = "pdf";
+  FigmaImageFormat2["EPS"] = "eps";
+  FigmaImageFormat2["WEBP"] = "webp";
+  return FigmaImageFormat2;
+})(FigmaImageFormat || {});
 
 // src/agents/initial-agent/prompt.ts
 var INITIAL_AGENT_SYSTEM_PROMPT = `
@@ -522,6 +413,7 @@ var INITIAL_AGENT_SYSTEM_PROMPT = `
           - "dev": "pnpm exec vite"
           - "build": "pnpm exec tsc && pnpm exec vite build"
           - "preview": "pnpm exec vite preview"
+        * IMPORTANT: Do NOT add "coderio" as a dependency - it's only a build tool, not a runtime dependency.
       - \`vite.config.ts\`: Configure React and TailwindCSS V4 plugins. MUST include path alias configuration:
         * Add \`resolve.alias\` with \`@\` pointing to \`path.resolve(__dirname, './src')\`
         * Import \`path\` from 'node:path'
@@ -548,23 +440,46 @@ var INITIAL_AGENT_SYSTEM_PROMPT = `
 </system_instructions>
 `.trim();
 
-// src/agents/initial-agent/index.ts
-function createInitialAgent(modelConfig) {
-  const systemTools = ["ThinkTool.execute", "FileEditor.read", "FileEditor.write"];
-  return new Agent({
-    name: "InitialAgent",
-    profile: "Expert Frontend Engineer specialized in project scaffolding with React, TypeScript, and Tailwind CSS V4.",
-    system: INITIAL_AGENT_SYSTEM_PROMPT,
-    tools: systemTools,
-    modelConfig,
-    verbose: true
-  });
+// src/agents/initial-agent/instruction.ts
+function initialAgentInstruction(params) {
+  return `
+appPath: ${params.appPath}
+appName: ${params.appName}
+
+TASK:
+Scaffold a clean React V18 + TS + Vite + TailwindCSS V4 + Less project.
+`.trim();
 }
 
-// src/nodes/initial/index.ts
-init_logger();
-import fs from "fs";
-import path from "path";
+// src/utils/url-parser.ts
+var parseFigmaUrl = (url) => {
+  let fileId = null;
+  let name = "untitled";
+  let nodeId = null;
+  try {
+    const urlObj = new URL(decodeURIComponent(url));
+    const pathParts = urlObj.pathname.split("/").filter(Boolean);
+    if (pathParts.length >= 3) {
+      fileId = pathParts[pathParts.length - 2] || null;
+      const fileName = pathParts[pathParts.length - 1];
+      name = fileName ? encodeURI(fileName).toLowerCase() : "untitled";
+      name = name.length > 20 ? name.substring(0, 20) : name;
+    }
+    nodeId = urlObj.searchParams.get("node-id") || null;
+    nodeId = nodeId ? nodeId.replace(/-/g, ":") : null;
+  } catch {
+  }
+  if (!fileId || !nodeId) {
+    throw new Error("Invalid Figma URL");
+  }
+  return { fileId, name, nodeId, projectName: `${name}_${nodeId}` };
+};
+
+// src/tools/figma-tool/index.ts
+import { tools as tools2 } from "evoltagent";
+
+// src/utils/axios.ts
+import axios from "axios";
 
 // src/utils/config.ts
 import { readFileSync, existsSync } from "fs";
@@ -597,13 +512,6 @@ Please create the configuration file.`);
     throw error;
   }
 }
-function getModelConfig() {
-  const config = loadConfig();
-  if (!config.model) {
-    throw new Error("Model configuration not found in config.yaml");
-  }
-  return config.model;
-}
 function getFigmaConfig() {
   const config = loadConfig();
   if (!config.figma) {
@@ -616,71 +524,80 @@ function getDebugConfig() {
   return config.debug || { enabled: false };
 }
 
-// src/constants/index.ts
-var MAX_OUTPUT_TOKENS = 20480;
-var AGENT_CONTEXT_WINDOW_TOKENS = 128e3;
-
-// src/agents/initial-agent/instruction.ts
-function initialAgentInstruction(params) {
-  return `
-appPath: ${params.appPath}
-appName: ${params.appName}
+// src/utils/file.ts
+import fs from "fs";
+import path from "path";
 
-TASK:
-Scaffold a clean React V18 + TS + Vite + TailwindCSS V4 + Less project.
-`.trim();
+// src/utils/logger.ts
+import chalk from "chalk";
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
 }
-
-// src/nodes/initial/index.ts
-var initialProject = async (state) => {
-  logger.printInfoLog("Initializing project...");
-  const envConfig = getModelConfig();
-  const modelConfig = {
-    ...envConfig,
-    contextWindowTokens: AGENT_CONTEXT_WINDOW_TOKENS,
-    maxOutputTokens: MAX_OUTPUT_TOKENS
-  };
-  const appPath = state.workspace.app;
-  const appName = state.urlInfo.name || "";
-  if (!appPath) {
-    throw new Error("Workspace application path is not defined.");
-  }
-  const initialAgent = createInitialAgent(modelConfig);
-  const result = await initialAgent.run(initialAgentInstruction({ appPath, appName }));
-  const essentialFiles = ["package.json", "src", "vite.config.ts", "tsconfig.json", "index.html", "src/main.tsx", "src/App.tsx"];
-  for (const file of essentialFiles) {
-    const fullPath = path.join(appPath, file);
-    if (!fs.existsSync(fullPath)) {
-      throw new Error(`Critical file/directory missing: "${file}". The project scaffolding may have failed.`);
+var logger = {
+  /**
+   * Print standard log (alias for info logs).
+   *
+   * Many subsystems (e.g. validation) use `printLog()` as the default logging method.
+   */
+  printLog(message) {
+    console.log(message);
+  },
+  /**
+   * Print info log in blue
+   */
+  printInfoLog(message) {
+    console.log(chalk.blue(`[${getTimestamp()}] [INFO] ${message}`));
+  },
+  /**
+   * Print warning log in yellow
+   */
+  printWarnLog(message) {
+    console.warn(chalk.yellow(`[${getTimestamp()}] [WARNING] ${message}`));
+  },
+  /**
+   * Print error log in red
+   */
+  printErrorLog(message) {
+    console.error(chalk.red(`[${getTimestamp()}] [ERROR] \u2716 ${message}`));
+  },
+  /**
+   * Print test/debug log in gray
+   * Only logs in development/test environments
+   */
+  printTestLog(message) {
+    if (process.env.NODE_ENV === "development") {
+      console.log(chalk.gray(`[${getTimestamp()}] [DEBUG] ${message}`));
     }
+  },
+  /**
+   * Print success log in green
+   */
+  printSuccessLog(message) {
+    console.log(chalk.green(`[${getTimestamp()}] [SUCCESS] \u2714 ${message}`));
   }
-  logger.printSuccessLog(result);
-  return {};
 };
 
-// src/tools/figma-tool/index.ts
-import { tools as tools2 } from "evoltagent";
-
-// src/utils/axios.ts
-import axios from "axios";
-
 // src/utils/file.ts
-init_logger();
-import fs2 from "fs";
-import path2 from "path";
 var writeFile = (folderPath, filePath, content) => {
   if (!folderPath || !filePath || !content) {
     return;
   }
-  if (!fs2.existsSync(folderPath)) {
-    fs2.mkdirSync(folderPath, { recursive: true });
+  if (!fs.existsSync(folderPath)) {
+    fs.mkdirSync(folderPath, { recursive: true });
   }
-  fs2.writeFileSync(path2.join(folderPath, filePath), content);
+  fs.writeFileSync(path.join(folderPath, filePath), content);
 };
 function createFiles({ files, filePath }) {
   try {
     for (const file of files) {
-      const dirPath = path2.dirname(filePath);
+      const dirPath = path.dirname(filePath);
       writeFile(dirPath, file.filename, file.content);
     }
   } catch (error) {
@@ -690,9 +607,8 @@ function createFiles({ files, filePath }) {
 }
 
 // src/utils/workspace.ts
-init_logger();
-import path3 from "path";
-import fs3 from "fs";
+import path2 from "path";
+import fs2 from "fs";
 var Workspace = class {
   path = null;
   initWorkspace(subPath, rootPath, appName) {
@@ -700,21 +616,21 @@ var Workspace = class {
       return this.path;
     }
     const root = rootPath || (process.env.CODERIO_CLI_USER_CWD ?? process.cwd());
-    const coderioRoot = path3.join(root, "coderio");
-    const finalRoot = path3.resolve(coderioRoot, subPath);
+    const coderioRoot = path2.join(root, "coderio");
+    const finalRoot = path2.resolve(coderioRoot, subPath);
     const app = appName || "my-app";
-    const absoluteRoot = path3.resolve(finalRoot);
-    const processDir = path3.join(absoluteRoot, "process");
-    const checkpointDir = path3.join(absoluteRoot, "checkpoint");
-    const debugDir = path3.join(absoluteRoot, "debug");
+    const absoluteRoot = path2.resolve(finalRoot);
+    const processDir = path2.join(absoluteRoot, "process");
+    const checkpointDir = path2.join(absoluteRoot, "checkpoint");
+    const debugDir = path2.join(absoluteRoot, "debug");
     this.path = {
       root: absoluteRoot,
-      app: path3.join(absoluteRoot, app),
+      app: path2.join(absoluteRoot, app),
       process: processDir,
       debug: debugDir,
-      reports: path3.join(absoluteRoot, "reports.html"),
-      db: path3.join(checkpointDir, "coderio-cli.db"),
-      checkpoint: path3.join(checkpointDir, "checkpoint.json")
+      reports: path2.join(absoluteRoot, "reports.html"),
+      db: path2.join(checkpointDir, "coderio-cli.db"),
+      checkpoint: path2.join(checkpointDir, "checkpoint.json")
     };
     return this.path;
   }
@@ -723,11 +639,11 @@ var Workspace = class {
    */
   deleteWorkspace(workspace) {
     try {
-      if (fs3.existsSync(workspace.root)) {
-        const entries = fs3.readdirSync(workspace.root);
+      if (fs2.existsSync(workspace.root)) {
+        const entries = fs2.readdirSync(workspace.root);
         for (const entry of entries) {
-          const fullPath = path3.join(workspace.root, entry);
-          fs3.rmSync(fullPath, { recursive: true, force: true });
+          const fullPath = path2.join(workspace.root, entry);
+          fs2.rmSync(fullPath, { recursive: true, force: true });
         }
       }
     } catch (error) {
@@ -742,7 +658,7 @@ var Workspace = class {
    * @returns The absolute path to the source code directory
    */
   resolveAppSrc(paths, srcSubPath) {
-    return path3.join(paths.app, "src", srcSubPath);
+    return path2.join(paths.app, "src", srcSubPath);
   }
   /**
    * Resolve component alias path to absolute filesystem path.
@@ -797,7 +713,6 @@ async function get(url, config) {
 }
 
 // src/tools/figma-tool/figma.ts
-init_logger();
 var fetchFigmaNode = async (fileId, nodeId, token) => {
   const url = `https://api.figma.com/v1/files/${fileId}/nodes?ids=${nodeId}`;
   try {
@@ -851,8 +766,8 @@ var checkBorder = (node) => {
 };
 
 // src/tools/figma-tool/images.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import axios2 from "axios";
 
 // src/utils/promise-pool.ts
@@ -894,7 +809,6 @@ var BASE_RETRY_DELAY_MS = 1e3;
 var DEFAULT_DOWNLOAD_CONCURRENCY = 5;
 
 // src/tools/figma-tool/images.ts
-init_logger();
 var fetchImages = async (nodes, fileId, token) => {
   if (!fileId || !nodes?.length) {
     return [];
@@ -1072,11 +986,11 @@ async function downloadImage(url, filename, imageDir, base64) {
         if (!imageDir || !filename) {
           return "";
         }
-        if (!fs4.existsSync(imageDir)) {
-          fs4.mkdirSync(imageDir, { recursive: true });
+        if (!fs3.existsSync(imageDir)) {
+          fs3.mkdirSync(imageDir, { recursive: true });
         }
-        const filepath = path4.join(imageDir, filename);
-        fs4.writeFileSync(filepath, Buffer.from(response.data));
+        const filepath = path3.join(imageDir, filename);
+        fs3.writeFileSync(filepath, Buffer.from(response.data));
         return filepath;
       }
     } catch (error) {
@@ -1535,21 +1449,21 @@ var FigmaTool = class {
     if (!fileId || !nodeId || !token) {
       return void 0;
     }
-    const document2 = await fetchFigmaNode(fileId, nodeId, token);
-    if (!document2 || !document2?.children?.length) {
+    const document = await fetchFigmaNode(fileId, nodeId, token);
+    if (!document || !document?.children?.length) {
       return void 0;
     }
     const images = await fetchFigmaImages(fileId, nodeId, token);
     const thumbnail = images?.[nodeId] || "";
-    document2.thumbnailUrl = thumbnail;
-    const cleanedDocument = cleanFigma(document2);
+    document.thumbnailUrl = thumbnail;
+    const cleanedDocument = cleanFigma(document);
     return cleanedDocument;
   }
-  async downloadImages(fileId, token, imageDir, document2) {
+  async downloadImages(fileId, token, imageDir, document) {
     if (!fileId) {
       return { successCount: 0, failCount: 0, imageNodesMap: /* @__PURE__ */ new Map() };
     }
-    const imageNodes = findImageNodes(document2?.children || [], document2?.absoluteBoundingBox);
+    const imageNodes = findImageNodes(document?.children || [], document?.absoluteBoundingBox);
     const fetchedImages = await fetchImages(imageNodes, fileId, token);
     if (!fetchedImages.length) {
       return { successCount: 0, failCount: 0, imageNodesMap: /* @__PURE__ */ new Map() };
@@ -1596,101 +1510,17 @@ FigmaTool = __decorateElement(_init2, 0, "FigmaTool", _FigmaTool_decorators, Fig
 __runInitializers(_init2, 1, FigmaTool);
 var figmaTool = new FigmaTool();
 
-// src/nodes/process/index.ts
-init_logger();
-
 // src/utils/call-model.ts
-init_logger();
 import { HumanMessage } from "@langchain/core/messages";
 import { ChatOpenAI } from "@langchain/openai";
-function validateModelConfig(config) {
-  if (!config || !config.provider || !config.model || !config.baseUrl || !config.apiKey) {
-    throw new Error(
-      `Invalid model configuration. Required fields: provider, model, baseUrl, apiKey. Please check your config.yaml file.`
-    );
-  }
-}
-async function callModel(options) {
-  const { question, imageUrls, streaming = false, responseFormat, maxTokens } = options;
-  if (!question || !question.trim()) {
-    throw new Error("Question must be a non-empty string");
-  }
-  let config;
-  try {
-    config = getModelConfig();
-    validateModelConfig(config);
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.printErrorLog(`Configuration error: ${error.message}`);
-    }
-    throw error;
-  }
-  try {
-    const requestConfig = {
-      modelName: config.model,
-      apiKey: config.apiKey,
-      configuration: {
-        baseURL: config.baseUrl
-      },
-      ...maxTokens && { maxTokens },
-      temperature: 0.1,
-      streaming,
-      ...streaming && {
-        streamingOptions: {
-          includeUsage: true
-        }
-      },
-      ...!streaming && { streamUsage: true },
-      ...responseFormat && { modelKwargs: { response_format: responseFormat } }
-    };
-    const agentModel = new ChatOpenAI(requestConfig);
-    const contentParts = [];
-    contentParts.push({ type: "text", text: question });
-    if (imageUrls) {
-      const urls = Array.isArray(imageUrls) ? imageUrls : [imageUrls];
-      for (const url of urls) {
-        if (url && typeof url === "string" && url.trim()) {
-          contentParts.push({ type: "image_url", image_url: { url: url.trim() } });
-        }
-      }
-    }
-    const userMessage = new HumanMessage({
-      content: contentParts.length > 1 ? contentParts : question
-    });
-    const message = await agentModel.invoke([userMessage]);
-    if (!message.text) {
-      throw new Error("Model returned empty response");
-    }
-    const debugConfig = getDebugConfig();
-    const isDebugEnabled = debugConfig.enabled;
-    if (isDebugEnabled) {
-      const debugContent = [
-        "------------config------------",
-        JSON.stringify(requestConfig, null, 2),
-        "------------request------------",
-        JSON.stringify(contentParts, null, 2),
-        "------------response------------",
-        JSON.stringify(message.text, null, 2)
-      ].join("\n");
-      writeFile(workspaceManager.path?.debug ?? "", `model_${(/* @__PURE__ */ new Date()).toISOString()}.md`, debugContent);
-    }
-    return message.text;
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.printErrorLog(`[${config.model}] Error details: ${error.message}`);
-      if (error.stack) {
-        logger.printTestLog(`[${config.model}] Stack trace: ${error.stack}`);
-      }
-    }
-    throw new Error(`${config.model} model request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
 
 // src/nodes/process/structure/index.ts
-init_logger();
 init_prompt();
 
 // src/utils/naming.ts
+function toPascalCase(str) {
+  return str.replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
 function toKebabCase(str) {
   return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").toLowerCase().replace(/^-+|-+$/g, "");
 }
@@ -1732,7 +1562,6 @@ function extractFiles(content) {
 }
 
 // src/nodes/process/structure/utils.ts
-init_logger();
 function simplifyFigmaNodeForContent(node) {
   const simple = {
     id: node.id,
@@ -1825,7 +1654,7 @@ function extractHierarchicalNodesByIds(tree, idList, options) {
     }
     return false;
   };
-  const processNode2 = (node) => {
+  const processNode = (node) => {
     if (!hasDescendantInList(node)) {
       return [];
     }
@@ -1835,7 +1664,7 @@ function extractHierarchicalNodesByIds(tree, idList, options) {
         const filteredChildren = [];
         for (const child of node.children) {
           if (typeof child === "object" && child !== null && "id" in child) {
-            const processedChildren = processNode2(child);
+            const processedChildren = processNode(child);
             filteredChildren.push(...processedChildren);
           }
         }
@@ -1849,7 +1678,7 @@ function extractHierarchicalNodesByIds(tree, idList, options) {
       if (node.children && Array.isArray(node.children)) {
         for (const child of node.children) {
           if (typeof child === "object" && child !== null && "id" in child) {
-            const processedChildren = processNode2(child);
+            const processedChildren = processNode(child);
             matchingDescendants.push(...processedChildren);
           }
         }
@@ -1859,7 +1688,7 @@ function extractHierarchicalNodesByIds(tree, idList, options) {
   };
   const nodeArray = Array.isArray(tree) ? tree : [tree];
   for (const node of nodeArray) {
-    const processedNodes = processNode2(node);
+    const processedNodes = processNode(node);
     result.push(...processedNodes);
   }
   return result;
@@ -1929,8 +1758,8 @@ function postProcessStructure(structure, frames) {
     traverse(node, void 0, 0);
   });
 }
-async function populateComponentProps(node, frames, thumbnailUrl) {
-  if (!node || !node.children || node.children.length === 0) return;
+function extractComponentGroups(node) {
+  if (!node || !node.children || node.children.length === 0) return /* @__PURE__ */ new Map();
   const componentGroups = /* @__PURE__ */ new Map();
   const validChildren = node.children.filter((c) => c && c.data);
   validChildren.forEach((child) => {
@@ -1942,132 +1771,47 @@ async function populateComponentProps(node, frames, thumbnailUrl) {
       componentGroups.get(name).push(child);
     }
   });
-  for (const [compName, group] of componentGroups) {
-    if (group.length === 0) continue;
-    const isList = group.length > 1;
-    const allElements = group.flatMap((g) => g.data.elements || []);
-    const simplifiedNodes = allElements.filter((n) => typeof n === "object" && n !== null).map((n) => simplifyFigmaNodeForContent(n));
-    const figmaDataJson = JSON.stringify(simplifiedNodes);
-    const containerName = node.data.name || "Container";
-    try {
-      const { extractDataListPrompt: extractDataListPrompt2 } = await Promise.resolve().then(() => (init_prompt(), prompt_exports));
-      const prompt = extractDataListPrompt2({
-        containerName,
-        childComponentName: compName,
-        figmaData: figmaDataJson
-      });
-      const result = await callModel({
-        question: prompt,
-        imageUrls: thumbnailUrl,
-        responseFormat: { type: "json_object" }
+  return componentGroups;
+}
+function applyPropsAndStateToProtocol(parsed, node, compName, group, isList) {
+  if (parsed && parsed.state && Array.isArray(parsed.state)) {
+    if (isList) {
+      if (!node.data.states) {
+        node.data.states = [];
+      }
+      node.data.states.push({
+        state: parsed.state,
+        componentName: compName,
+        componentPath: group[0]?.data.componentPath || ""
       });
-      const json = extractJSON(result);
-      const parsed = JSON.parse(json);
-      if (parsed && parsed.state && Array.isArray(parsed.state)) {
-        if (isList) {
-          if (!node.data.states) {
-            node.data.states = [];
-          }
-          node.data.states.push({
-            state: parsed.state,
-            componentName: compName,
-            componentPath: group[0]?.data.componentPath || ""
-          });
-          const originalChildren = node.children || [];
-          const newChildren = [];
-          const processedComponentNames = /* @__PURE__ */ new Set();
-          for (const child of originalChildren) {
-            const childName = child.data.componentName;
-            if (childName === compName) {
-              if (!processedComponentNames.has(childName)) {
-                child.data.name = childName;
-                child.id = childName;
-                const cleanKebabName = toKebabCase(childName);
-                child.data.kebabName = cleanKebabName;
-                delete child.data.path;
-                if (parsed.props && Array.isArray(parsed.props)) {
-                  child.data.props = parsed.props;
-                }
-                newChildren.push(child);
-                processedComponentNames.add(childName);
-              }
-            } else {
-              newChildren.push(child);
+      const originalChildren = node.children || [];
+      const newChildren = [];
+      const processedComponentNames = /* @__PURE__ */ new Set();
+      for (const child of originalChildren) {
+        const childName = child.data.componentName;
+        if (childName === compName) {
+          if (!processedComponentNames.has(childName)) {
+            child.data.name = childName;
+            child.id = childName;
+            const cleanKebabName = toKebabCase(childName);
+            child.data.kebabName = cleanKebabName;
+            delete child.data.path;
+            if (parsed.props && Array.isArray(parsed.props)) {
+              child.data.props = parsed.props;
             }
+            newChildren.push(child);
+            processedComponentNames.add(childName);
           }
-          node.children = newChildren;
+        } else {
+          newChildren.push(child);
         }
       }
-    } catch (e) {
-      logger.printErrorLog(
-        `Failed to extract data list for ${compName} in ${containerName}: ${e instanceof Error ? e.message : String(e)}`
-      );
+      node.children = newChildren;
     }
   }
-  for (const child of node.children) {
-    await populateComponentProps(child, frames, thumbnailUrl);
-  }
 }
 
-// src/nodes/process/structure/index.ts
-var generateStructure = async (figma) => {
-  const frames = figma.frames || figma.children;
-  const imageWidth = figma.absoluteBoundingBox?.width;
-  const thumbnailUrl = figma.thumbnailUrl;
-  if (!frames || frames.length === 0) {
-    logger.printErrorLog("No processed frames found in state");
-    throw new Error("No processed frames found");
-  }
-  logger.printInfoLog("Starting structure analysis...");
-  try {
-    const positions = extractNodePositionsHierarchical(frames);
-    const positionsJson = JSON.stringify(positions);
-    const prompt = generateStructurePrompt({
-      positions: positionsJson,
-      width: imageWidth ? String(imageWidth) : "1440"
-    });
-    logger.printInfoLog("Calling AI model to generate component structure...");
-    const structureResult = await callModel({
-      question: prompt,
-      imageUrls: thumbnailUrl,
-      responseFormat: { type: "json_object" },
-      maxTokens: 20240
-    });
-    const jsonContent = extractJSON(structureResult);
-    const parsedStructure = JSON.parse(jsonContent);
-    logger.printInfoLog("Processing structure tree...");
-    postProcessStructure(parsedStructure, frames);
-    const protocol = Array.isArray(parsedStructure) ? parsedStructure[0] : parsedStructure;
-    if (frames && protocol) {
-      logger.printInfoLog("Extracting component properties and states...");
-      await populateComponentProps(protocol, frames, thumbnailUrl);
-    }
-    logger.printSuccessLog("Component structure generated successfully");
-    return protocol;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.printErrorLog(`Error generating component structure: ${errorMessage}`);
-    throw new Error(`Failed to parse component structure: ${errorMessage}`);
-  }
-};
-
 // src/nodes/process/index.ts
-var generateProtocol = async (state) => {
-  const assetsDir = workspaceManager.resolveAppSrc(state.workspace, "assets");
-  const processDir = state.workspace.process;
-  const { document: document2, imageNodesMap } = await executeFigmaAndImagesActions(state.urlInfo, assetsDir, processDir);
-  const simplifiedDocument = figmaTool.simplifyImageNodes(document2, imageNodesMap);
-  const processedStyleDocument = figmaTool.processedStyle(simplifiedDocument);
-  const protocol = await generateStructure(processedStyleDocument);
-  writeFile(state.workspace.process, "protocol.json", JSON.stringify(protocol, null, 2));
-  logger.printInfoLog(`Please check the output in the workspace: ${state.workspace.process}`);
-  return {
-    protocol,
-    figmaInfo: {
-      thumbnail: processedStyleDocument?.thumbnailUrl || document2?.thumbnailUrl || ""
-    }
-  };
-};
 var executeFigmaAndImagesActions = async (urlInfo, assetsDir, processDir) => {
   const { fileId, nodeId } = urlInfo;
   if (!fileId || !nodeId) {
@@ -2077,13 +1821,13 @@ var executeFigmaAndImagesActions = async (urlInfo, assetsDir, processDir) => {
   if (!token) {
     throw new Error("Figma API token is required");
   }
-  const document2 = await figmaTool.fetchAndClean(fileId, nodeId, token);
-  if (!document2) {
+  const document = await figmaTool.fetchAndClean(fileId, nodeId, token);
+  if (!document) {
     throw new Error("Failed to fetch and clean Figma document");
   }
-  writeFile(processDir, "figma.json", JSON.stringify(document2, null, 2));
+  writeFile(processDir, "figma.json", JSON.stringify(document, null, 2));
   logger.printSuccessLog(`Figma document fetched and cleaned successfully`);
-  const downloadResult = await figmaTool.downloadImages(fileId, token, assetsDir, document2);
+  const downloadResult = await figmaTool.downloadImages(fileId, token, assetsDir, document);
   const { successCount, failCount, imageNodesMap } = downloadResult;
   if (successCount) {
     logger.printSuccessLog(`Downloaded ${successCount} images`);
@@ -2094,3525 +1838,65 @@ var executeFigmaAndImagesActions = async (urlInfo, assetsDir, processDir) => {
   const resultsArray = Array.from(imageNodesMap.values());
   writeFile(processDir, "images.json", JSON.stringify(resultsArray, null, 2));
   return {
-    document: document2,
+    document,
     imageNodesMap
   };
 };
 
-// src/nodes/validation/index.ts
-import fs8 from "fs";
-import path11 from "path";
-
-// src/nodes/validation/constants.ts
-var TARGET_MAE = 3;
-var POSITION_THRESHOLD = 1;
-var DEFAULT_TIMEOUT = 3e4;
-var METRIC_DECIMAL_PLACES = 2;
-var DEFAULT_VIEWPORT = { width: 1440, height: 900 };
-var MAX_ITERATIONS = 3;
-var HEADLESS = true;
-var SELECTOR_WAIT_TIMEOUT = 5e3;
-var DEFAULT_VALIDATION_LOOP_CONFIG = {
-  maxIterations: MAX_ITERATIONS,
-  targetMae: TARGET_MAE,
-  positionThreshold: POSITION_THRESHOLD,
-  browserTimeout: DEFAULT_TIMEOUT,
-  defaultViewportWidth: DEFAULT_VIEWPORT.width,
-  defaultViewportHeight: DEFAULT_VIEWPORT.height,
-  headless: HEADLESS
-};
-var DEFAULT_PORT = 5173;
-function buildDevServerUrl(port) {
-  return `http://localhost:${port}`;
-}
-
-// src/nodes/validation/index.ts
-init_logger();
-
-// src/nodes/validation/core/validation-loop.ts
-import * as fs7 from "fs";
-import * as path10 from "path";
-init_logger();
-
-// src/agents/commit-agent/index.ts
-import { Agent as Agent2 } from "evoltagent";
+// src/skill-api.ts
+init_prompt();
 
-// src/agents/commit-agent/prompt.ts
-var COMMIT_AGENT_SYSTEM_PROMPT = `You are a Git automation agent for CodeRio validation workflow.
+// src/nodes/code/prompt.ts
+var STYLING_GUIDELINES = `
+      - **Style Consistency**: Implement styles using the technical stack and libraries listed in <styling>.
+      - **Strict Restriction**: Absolutely ONLY use the technical stack and libraries listed in <styling>. Do NOT use any other styling methods, libraries, or frameworks (e.g., if clsx is not listed, do not use clsx).
+      - **Default Styling**: If <styling> is empty or does not contain specific libraries, DEFAULT to standard vanilla CSS.
+      
+      - **Tailwind CSS + CSS Modules (CRITICAL)**:
+        - If the stack includes BOTH Tailwind and CSS Modules (Less/SCSS), use them correctly:
+          1. **Tailwind utilities**: Use DIRECTLY in JSX className (e.g., \`className="flex items-center gap-4"\`)
+          2. **CSS Modules**: Use ONLY for complex styles that can't be expressed with Tailwind utilities (e.g., gradients, animations, pseudo-elements)
+          3. **NEVER use \`@apply\` in CSS Module files** - it's a Tailwind-specific directive that doesn't work in Less/SCSS
+          4. Example correct usage:
+             TSX: \`<div className={\`flex \${styles.customGradient}\`}>\`
+             Less: \`.customGradient { background: linear-gradient(...); }\`
+      
+      - **CSS Modules Only**: If the tech stack specifies CSS Modules without Tailwind:
+        1. Create a corresponding style file (e.g., \`index.module.less\`, \`index.module.scss\`, or \`index.module.css\`)
+        2. Import it as \`import styles from './index.module.[ext]';\` in the TSX
+        3. Define all styles in the style file using standard CSS/Less/SCSS syntax
+        4. Use \`styles.className\` in JSX`;
+var ASSETS_HANDLING = `
+      - **CRITICAL**: For any image URL starting with \`@/assets\`, you MUST import it at the top of the file.
+      - **Asset Name Matching**: 
+        - Check the \`<available_assets>\` list for actual filenames in the project.
+        - Asset filenames follow the pattern: \`kebab-case-name-id1-id2.ext\` (e.g., "Star 2.svg" \u2192 "star-2-1-2861.svg")
+        - Match the base name (ignoring spaces, case, and ID suffix): "@/assets/arXiv.svg" \u2192 look for "arxiv-*.svg" in the list
+        - Use the EXACT filename from the available assets list in your import.
+      - Example: If available_assets contains "arxiv-1-2956.svg", use:
+        \`import ArXivIcon from '@/assets/arxiv-1-2956.svg';\`
+      - **Usage**: \`<img src={ArXivIcon} />\`, do not use backgroundImage property.
+      - **NEVER** use the string path directly in JSX or styles.`;
+var DOM_IDS_REQUIREMENT = `
+      - Assign \`id\` attributes to the main container and any internal elements, matching \`frame_details\`.`;
+var REACT_IMPORT_RULE = `
+      - Do **NOT** include \`import React from 'react';\` at the top of the file.`;
+var FILE_NAMING_CONVENTION = `
+      - ALWAYS name the main component file \`index.tsx\`.
+      - ALWAYS name the style file (if applicable) \`index.module.[css|less|scss]\`.
+      - NEVER use PascalCase or other names for filenames (e.g., DO NOT use \`MainFrame.tsx\` or \`Button.tsx\`).`;
+var OUTPUT_FORMAT = `
+  <output_format>
+    If only one file (TSX) is needed:
+    \`\`\`tsx
+    // code...
+    \`\`\`
 
-Input format:
-- appPath: /absolute/path/to/app
-- iteration: number (optional; undefined means initial commit)
-
-<workflow>
-1. Validate repository:
-   - Run GitTool.status(cwd=appPath)
-   - If not a git repository, run GitTool.init(cwd=appPath), then re-run status
-
-2. Check for changes:
-   - Run GitTool.diff(cwd=appPath) to see unstaged changes
-   - If working tree is clean (no changes):
-     * Stop and return: "No changes to commit"
-     * DO NOT create an empty commit
-
-3. Stage all changes:
-   - Run GitTool.add(files=".", cwd=appPath)
-
-4. Analyze changes and generate commit message:
-   Run GitTool.diff(cwd=appPath) after staging to analyze what changed.
-
-   Generate a conventional commit message following these rules:
-
-   **Message format:**
-   - If iteration is undefined: "feat: [Initial] first commit"
-   - If iteration is defined: "fix: [Iteration N] <description>"
-
-   **Description guidelines:**
-   Analyze the diff to determine what type of changes were made:
-
-   a) Component layout/style fixes:
-      - Look for changes in component files (src/components/*.tsx, etc.)
-      - Extract component names from file paths (e.g., src/components/Header.tsx \u2192 Header)
-      - Format: "fix misaligned components ComponentA, ComponentB"
-      - List up to 3 components, use "and N more" if more than 3
-      - Example: "fix: [Iteration 1] fix misaligned components Header, Footer, and 2 more"
-
-   b) Build/compilation error fixes:
-      - Look for package.json changes \u2192 "resolve dependency issues"
-      - Look for import/export errors \u2192 "resolve import errors"
-      - Look for TypeScript errors \u2192 "resolve type errors"
-      - Example: "fix: [Iteration 2] resolve build error"
-
-   c) Mixed changes (both component fixes AND build fixes):
-      - Prioritize component fixes in the message
-      - Example: "fix: [Iteration 1] fix misaligned components xxx and resolve yyy error"
-
-5. Create commit:
-   - Use temporary identity (do NOT modify global git config):
-     * user.name = "CodeRio"
-     * user.email = ""
-   - Run GitTool.commit(message, cwd=appPath, config={...})
-</workflow>
-
-<example>
-Example tool call format:
-
-GitTool.commit({
-  "message": "feat: [Initial] generate webpage",
-  "cwd": "/absolute/path/to/app",
-  "config": {"user.name": "CodeRio", "user.email": ""}
-})
-
-IMPORTANT: The config parameter must be a JSON object with keys like "user.name" and "user.email".
-DO NOT use XML-style tags like <user.name>CodeRio</user.name>.
-</example>
-
-<output>
-Respond with a short summary in <TaskCompletion> tags.
-Include whether a commit was created and the final commit message.
-</output>`;
-
-// src/agents/commit-agent/index.ts
-function createCommitAgent() {
-  const modelConfig = {
-    ...getModelConfig(),
-    contextWindowTokens: AGENT_CONTEXT_WINDOW_TOKENS,
-    maxOutputTokens: MAX_OUTPUT_TOKENS
-  };
-  return new Agent2({
-    name: "CommitAgent",
-    profile: "A helpful assistant that commits local changes in a repository.",
-    system: COMMIT_AGENT_SYSTEM_PROMPT,
-    tools: ["GitTool.init", "GitTool.status", "GitTool.add", "GitTool.diff", "GitTool.commit"],
-    modelConfig,
-    verbose: 1,
-    toolcallManagerPoolSize: 1
-  });
-}
-
-// src/agents/commit-agent/instruction.ts
-function formatGitCommitInstruction(params) {
-  const { appPath, iteration } = params;
-  return `appPath: ${appPath}
-iteration: ${iteration ?? "undefined"}
-
-TASK:
-Check for changes and commit if there are any modifications in the app directory.`;
-}
-
-// src/nodes/validation/commit/index.ts
-init_logger();
-import path5 from "path";
-async function commit(options) {
-  try {
-    if (!options?.appPath) {
-      throw new Error("commit() requires options.appPath");
-    }
-    const appPath = path5.resolve(options.appPath);
-    const agent = createCommitAgent();
-    const instruction = formatGitCommitInstruction({
-      appPath,
-      iteration: options.iteration
-    });
-    await agent.run(instruction);
-    logger.printSuccessLog("Commit completed!");
-    return {
-      success: true,
-      message: "Commit workflow completed"
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.printErrorLog(`Commit failed: ${errorMessage}`);
-    return {
-      success: false,
-      message: errorMessage
-    };
-  }
-}
-
-// src/agents/judger-agent/index.ts
-import { Agent as Agent3 } from "evoltagent";
-
-// src/tools/history-tool/index.ts
-import { tools as tools3 } from "evoltagent";
-var _HistoryTool_decorators, _init3;
-_HistoryTool_decorators = [tools3({
-  getComponentHistory: {
-    description: "Get position and fix history for a component. Shows how the component's position and error evolved across iterations, and what fixes were applied. Helps identify if previous fixes helped or hurt",
-    params: [{ name: "componentId", type: "string", description: "Component ID to get history for" }],
-    returns: { type: "string", description: "Formatted string with complete history of positions, errors, and fixes" },
-    examples: [
-      `<HistoryTool.getComponentHistory>
-<componentId>HeroSection</componentId>
-</HistoryTool.getComponentHistory>`
-    ]
-  },
-  getIterationSummary: {
-    description: "Get summary of what was changed in a specific iteration. Shows all components that were fixed in that iteration and what fixes were applied. Useful for understanding what went wrong in a previous iteration",
-    params: [{ name: "iteration", type: "number", description: "Iteration number (1-indexed)" }],
-    returns: { type: "string", description: "Formatted string with summary of changes in that iteration" },
-    examples: [
-      `<HistoryTool.getIterationSummary>
-<iteration>2</iteration>
-</HistoryTool.getIterationSummary>`
-    ]
-  }
-})];
-var HistoryTool = class {
-  _history = {};
-  /**
-   * Initialize with component history from previous iterations.
-   *
-   * @param history - Dict mapping component_id to list of iteration records
-   */
-  setContext(history) {
-    this._history = history;
-  }
-  /**
-   * Get position and fix history for a component.
-   *
-   * Shows how the component's position and error evolved across iterations,
-   * and what fixes were applied. Helps identify if previous fixes helped or hurt.
-   *
-   * @param componentId - Component ID to get history for
-   * @returns Formatted string with complete history of positions, errors, and fixes
-   */
-  getComponentHistory(componentId) {
-    if (!this._history || Object.keys(this._history).length === 0) {
-      return "No history available (this is iteration 1)";
-    }
-    if (!(componentId in this._history)) {
-      return `No history found for component '${componentId}' (first time misaligned)`;
-    }
-    const historyEntries = this._history[componentId];
-    if (!historyEntries || historyEntries.length === 0) {
-      return `Empty history for component '${componentId}'`;
-    }
-    const lines = [`History for ${componentId}:`, ""];
-    for (let i = 0; i < historyEntries.length; i++) {
-      const entry = historyEntries[i];
-      if (!entry) continue;
-      const iteration = entry.iteration ?? "?";
-      const position = entry.position ?? [0, 0];
-      const error = entry.error ?? [0, 0];
-      const fixApplied = entry.fixApplied ? entry.fixApplied.join("\n    ") : "None";
-      lines.push(`Iteration ${iteration}:`);
-      lines.push(`  Position: (${position[0].toFixed(1)}, ${position[1].toFixed(1)}) px`);
-      lines.push(`  Error: (${error[0].toFixed(1)}, ${error[1].toFixed(1)}) px`);
-      lines.push(`  Fix Applied:
-    ${fixApplied}`);
-      if (i > 0) {
-        const prevEntry = historyEntries[i - 1];
-        if (prevEntry) {
-          const prevErrorMagnitude = prevEntry.error[0] + prevEntry.error[1];
-          const currErrorMagnitude = error[0] + error[1];
-          if (currErrorMagnitude > prevErrorMagnitude) {
-            lines.push(
-              `  Warning: REGRESSION: Error increased from ${prevErrorMagnitude.toFixed(1)}px to ${currErrorMagnitude.toFixed(1)}px`
-            );
-          }
-        }
-      }
-      lines.push("");
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Get summary of what was changed in a specific iteration.
-   *
-   * Shows all components that were fixed in that iteration and what fixes
-   * were applied. Useful for understanding what went wrong in a previous iteration.
-   *
-   * @param iteration - Iteration number (1-indexed)
-   * @returns Formatted string with summary of changes in that iteration
-   */
-  getIterationSummary(iteration) {
-    if (!this._history || Object.keys(this._history).length === 0) {
-      return `No history available (iteration ${iteration} has not completed yet)`;
-    }
-    const changes = [];
-    for (const [componentId, entries] of Object.entries(this._history)) {
-      for (const entry of entries) {
-        if (entry.iteration === iteration) {
-          changes.push({
-            componentId,
-            position: entry.position ?? [0, 0],
-            error: entry.error ?? [0, 0],
-            fixApplied: entry.fixApplied ?? ["None"]
-          });
-          break;
-        }
-      }
-    }
-    if (changes.length === 0) {
-      return `No changes recorded for iteration ${iteration}`;
-    }
-    const lines = [`Iteration ${iteration} Summary:`, `Total components modified: ${changes.length}`, ""];
-    for (const change of changes) {
-      lines.push(`${change.componentId}:`);
-      lines.push(`  Error: (${change.error[0].toFixed(1)}, ${change.error[1].toFixed(1)}) px`);
-      lines.push(`  Fix:
-    ${change.fixApplied.join("\n    ")}`);
-      lines.push("");
-    }
-    return lines.join("\n");
-  }
-};
-_init3 = __decoratorStart(null);
-HistoryTool = __decorateElement(_init3, 0, "HistoryTool", _HistoryTool_decorators, HistoryTool);
-__runInitializers(_init3, 1, HistoryTool);
-
-// src/tools/hierarchy-tool/index.ts
-import { tools as tools4 } from "evoltagent";
-
-// src/nodes/validation/utils/tree/tree-traversal.ts
-function getNodeId(node) {
-  return node?.componentId || node?.id || void 0;
-}
-function findInTree(data, targetId, idKeys = ["id", "componentId"]) {
-  if (data === null || data === void 0) {
-    return void 0;
-  }
-  if (typeof data === "object" && !Array.isArray(data)) {
-    const dict = data;
-    for (const idKey of idKeys) {
-      if (dict[idKey] === targetId) {
-        return dict;
-      }
-    }
-    for (const value of Object.values(dict)) {
-      const result = findInTree(value, targetId, idKeys);
-      if (result) {
-        return result;
-      }
-    }
-  } else if (Array.isArray(data)) {
-    for (const item of data) {
-      const result = findInTree(item, targetId, idKeys);
-      if (result) {
-        return result;
-      }
-    }
-  }
-  return void 0;
-}
-
-// src/tools/hierarchy-tool/index.ts
-var _HierarchyTool_decorators, _init4;
-_HierarchyTool_decorators = [tools4({
-  lookup: {
-    description: "Get file path, parent, siblings, and children for a component. Use this to find the correct file path before reading component files.",
-    params: [{ name: "componentId", type: "string", description: "Component ID to look up" }],
-    returns: { type: "string", description: "Formatted string with file path, parent (with its file path), siblings, and children" },
-    examples: [
-      `<HierarchyTool.lookup>
-<componentId>HeroSection</componentId>
-</HierarchyTool.lookup>`
-    ]
-  },
-  getSharedInstances: {
-    description: "Find all component instances using a specific file path. Useful for identifying which components share the same implementation file (e.g., StartButton and ApiButton both using button/index.tsx). ALWAYS check this before editing a shared file.",
-    params: [{ name: "filePath", type: "string", description: "Filesystem path to search for (can be relative or absolute)" }],
-    returns: { type: "string", description: "Formatted string with all component instances using the file" },
-    examples: [
-      `<HierarchyTool.getSharedInstances>
-<filePath>button/index.tsx</filePath>
-</HierarchyTool.getSharedInstances>`
-    ]
-  }
-})];
-var HierarchyTool = class {
-  _structureTree = {};
-  _componentPaths = {};
-  constructor() {
-    this._structureTree = {};
-    this._componentPaths = {};
-  }
-  /**
-   * Initialize with page structure and path mapping.
-   */
-  setContext(structureTree, componentPaths) {
-    this._structureTree = structureTree;
-    this._componentPaths = componentPaths;
-  }
-  lookup(componentId) {
-    const node = findInTree(this._structureTree, componentId);
-    if (!node) {
-      return `Component '${componentId}' not found in structure tree`;
-    }
-    const parentInfo = this._findParent(this._structureTree, componentId);
-    const parentStr = parentInfo ? `Parent: ${parentInfo.id}` : "Parent: None (root component)";
-    const parentPathStr = parentInfo && this._componentPaths[parentInfo.id] ? `Parent File: ${this._componentPaths[parentInfo.id]}` : "";
-    let siblings = [];
-    if (parentInfo) {
-      const parentNode = findInTree(this._structureTree, parentInfo.id);
-      if (parentNode) {
-        const children2 = parentNode.children || [];
-        siblings = children2.map((child) => getNodeId(child)).filter((id) => id !== void 0 && id !== componentId);
-      }
-    }
-    const siblingsStr = siblings.length > 0 ? `Siblings: ${siblings.join(", ")}` : "Siblings: None";
-    const nodeChildren = node.children || [];
-    const children = nodeChildren.map((child) => getNodeId(child)).filter((id) => id !== void 0);
-    const childrenStr = children.length > 0 ? `Children: ${children.join(", ")}` : "Children: None";
-    const filePath = this._componentPaths[componentId];
-    const fileStr = filePath ? `File: ${filePath}` : "";
-    const lines = [`Component: ${componentId}`, fileStr, parentStr, parentPathStr, siblingsStr, childrenStr].filter(Boolean);
-    return lines.join("\n");
-  }
-  getSharedInstances(filePath) {
-    const instances = [];
-    for (const [compId, compPath] of Object.entries(this._componentPaths)) {
-      if (compPath.includes(filePath) || compPath.endsWith(filePath)) {
-        instances.push(compId);
-      }
-    }
-    if (instances.length === 0) {
-      return `No components found using file: ${filePath}`;
-    }
-    const instancesList = instances.map((inst) => `  - ${inst}`).join("\n");
-    return `Components using ${filePath}:
-${instancesList}
-
-Warning: Changes to this file will affect ALL ${instances.length} instance(s)`;
-  }
-  _findParent(node, targetId, parent = null) {
-    const nodeId = getNodeId(node);
-    if (nodeId === targetId) {
-      if (parent) {
-        const parentId = getNodeId(parent);
-        if (parentId) {
-          return { id: parentId };
-        }
-      }
-      return void 0;
-    }
-    const children = node.children || [];
-    for (const child of children) {
-      const result = this._findParent(child, targetId, node);
-      if (result !== void 0) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-};
-_init4 = __decoratorStart(null);
-HierarchyTool = __decorateElement(_init4, 0, "HierarchyTool", _HierarchyTool_decorators, HierarchyTool);
-__runInitializers(_init4, 1, HierarchyTool);
-
-// src/agents/judger-agent/prompt.ts
-var JUDGER_PROMPT = `You are a React Layout Diagnosis Expert. Analyze position misalignments and provide precise fix instructions.
-
-<workflow>
-1. Check HistoryTool.getComponentHistory - avoid repeating failed fixes
-2. Use HierarchyTool.lookup to get component file path, parent, siblings, and children
-3. Use FileEditor.read to examine code, FileEditor.find to locate patterns
-4. For parent fixes: HierarchyTool.lookup returns parent file path - use it directly
-5. Before editing shared files: Use HierarchyTool.getSharedInstances to check impact
-6. If image provided: previous iteration
-7. Respond with JSON diagnosis wrapped in \`\`\`json\`\`\`
-</workflow>
-
-<error_types>
-- pixel_misalignment: Wrong spacing values (gap-2 vs gap-4, mt-[20px] vs mt-[50px])
-- positioning_strategy: Wrong layout method (absolute vs flex, wrong parent)
-- parent_spacing: Parent gap/padding causes child misalignment
-- sibling_cascade: Sibling margin shifts others (fix topmost only)
-- none: Position already correct
-</error_types>
-
-<rules>
-CRITICAL CONSTRAINTS:
-1. Fix POSITION only (x,y) - validation does NOT measure dimensions
-2. FORBIDDEN: w-*, h-*, max-w-*, max-h-*, min-w-*, min-h-*, aspect-*, flex-row, flex-col
-3. ALLOWED: mt-*, mb-*, ml-*, mr-*, pt-*, pb-*, pl-*, pr-*, gap-*, space-*, top-*, left-*, right-*, bottom-*, translate-*
-
-FLEX LAYOUT (prevents MAE oscillation):
-- Adding mt-[X] to component A shifts ALL siblings below by X pixels (additive effect)
-- For sibling components: Fix ONLY the topmost misaligned one per iteration (topmost = first in DOM order)
-- For other siblings: Set refineInstructions to [] with rootCause: "Fix deferred - waiting for topmost sibling fix to propagate"
-- Prefer parent gap/padding over child margins
-- If component oscillates "too high" \u2194 "too low" \u2192 fix parent or topmost sibling instead
-
-SPECIAL CASES:
-- Already correct: errorType="none", refineInstructions=[]
-- Wrong dimensions/flex-direction: Note in rootCause but do NOT fix
-- Wrong X (x=0 vs x=320): Check parent centering, do NOT change w-full to w-[640px]
-</rules>
-
-<output_format>
-Return JSON with camelCase fields: errorType, rootCause, visualEvidence, codeEvidence, refineInstructions, toolsUsed
-
-refineInstructions format: "In [FULL_PATH] line [N], change '[OLD_CODE]' to '[NEW_CODE]'"
-- Use EXACT code strings from FileEditor.read (copy-paste)
-- OLD_CODE \u2260 NEW_CODE (never "keep unchanged")
-- Check HierarchyTool.getSharedInstances before editing shared files
-
-Wrap output:
-<TaskCompletion>
-\`\`\`json
-{your json here}
-\`\`\`
-</TaskCompletion>
-</output_format>
-
-<example>
-<TaskCompletion>
-\`\`\`json
-{
-  "errorType": "pixel_misalignment",
-  "rootCause": "Gap is 8px but should be 16px",
-  "visualEvidence": "Elements too close in screenshot",
-  "codeEvidence": "Line 23: className='flex gap-2'",
-  "refineInstructions": ["In /path/Card.tsx line 23, change 'gap-2' to 'gap-4'"],
-  "toolsUsed": ["FileEditor.read", "HistoryTool.getComponentHistory"]
-}
-\`\`\`
-</TaskCompletion>
-</example>
-`;
-
-// src/agents/judger-agent/utils.ts
-init_logger();
-import { SystemToolStore, FunctionCallingStore } from "evoltagent";
-function parseJudgerResult(response) {
-  if (!response || response.trim().length === 0) {
-    logger.printInfoLog("Judger agent returned empty response, skipping refinement for this iteration");
-    return Promise.resolve({
-      errorType: "pixel_misalignment",
-      rootCause: "Agent analysis unavailable, do not apply any edits",
-      visualEvidence: "N/A",
-      codeEvidence: "N/A",
-      refineInstructions: [],
-      toolsUsed: []
-    });
-  }
-  const jsonMatch = response.match(/```json\n([\s\S]*?)\n```/);
-  if (!jsonMatch) {
-    logger.printInfoLog("Judger agent response missing JSON block, skipping refinement for this iteration");
-    return Promise.resolve({
-      errorType: "empty_response",
-      rootCause: "Agent analysis unavailable, do not apply any edits",
-      visualEvidence: "N/A",
-      codeEvidence: "N/A",
-      refineInstructions: [],
-      toolsUsed: []
-    });
-  }
-  const jsonStr = jsonMatch[1];
-  if (!jsonStr || jsonStr.trim().length === 0) {
-    logger.printInfoLog("Judger agent response has empty JSON, skipping refinement for this iteration");
-    return Promise.resolve({
-      errorType: "empty_response",
-      rootCause: "Agent analysis unavailable, do not apply any edits",
-      visualEvidence: "N/A",
-      codeEvidence: "N/A",
-      refineInstructions: [],
-      toolsUsed: []
-    });
-  }
-  try {
-    return Promise.resolve(JSON.parse(jsonStr));
-  } catch (error) {
-    logger.printInfoLog(`Judger agent response JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
-    return Promise.resolve({
-      errorType: "empty_response",
-      rootCause: "Agent analysis unavailable",
-      visualEvidence: "N/A",
-      codeEvidence: "N/A",
-      refineInstructions: [],
-      toolsUsed: []
-    });
-  }
-}
-function updateToolContext(toolInstance, toolName, methodNames) {
-  const updatedNames = [];
-  for (const methodName of methodNames) {
-    const raw = toolInstance[methodName];
-    if (!raw) {
-      continue;
-    }
-    const method = raw.bind(toolInstance);
-    const fullName = `${toolName}.${methodName}`;
-    const systemTool = SystemToolStore.getTool(fullName);
-    if (systemTool) {
-      systemTool.execute = method;
-      updatedNames.push(fullName);
-    }
-    const functionCallingName = `${toolName}-${methodName}`;
-    const userTool = FunctionCallingStore.getTool(functionCallingName);
-    if (userTool) {
-      userTool.execute = method;
-    }
-  }
-  return updatedNames;
-}
-
-// src/agents/judger-agent/index.ts
-function createJudgerAgent(options) {
-  const { workspaceDir, structureTree, componentPaths, history } = options;
-  let systemPrompt = JUDGER_PROMPT;
-  if (workspaceDir) {
-    systemPrompt += `
-
-WORKSPACE: ${workspaceDir}
-Only access files within this workspace.`;
-  }
-  const systemTools = ["FileEditor.read", "FileEditor.find"];
-  if (structureTree) {
-    const hierarchyTool = new HierarchyTool();
-    hierarchyTool.setContext(structureTree, componentPaths || {});
-    const hierarchyToolNames = updateToolContext(
-      hierarchyTool,
-      "HierarchyTool",
-      ["lookup", "getSharedInstances"]
-    );
-    systemTools.push(...hierarchyToolNames);
-  }
-  const historyTool = new HistoryTool();
-  historyTool.setContext(history || {});
-  const historyToolNames = updateToolContext(
-    historyTool,
-    "HistoryTool",
-    ["getComponentHistory", "getIterationSummary"]
-  );
-  systemTools.push(...historyToolNames);
-  const modelConfig = {
-    ...getModelConfig(),
-    contextWindowTokens: AGENT_CONTEXT_WINDOW_TOKENS,
-    maxOutputTokens: MAX_OUTPUT_TOKENS,
-    stream: true
-  };
-  return new Agent3({
-    name: "JudgerAgent",
-    profile: "Layout diagnosis specialist",
-    system: systemPrompt,
-    tools: systemTools,
-    modelConfig,
-    postProcessor: parseJudgerResult,
-    verbose: 2
-  });
-}
-
-// src/agents/judger-agent/instruction.ts
-function formatJudgerInstruction(component, figmaMetadata, componentPaths) {
-  const vr = component.validationReport;
-  const validationReportFormatted = `Current Position: (${vr.currentPosition[0].toFixed(1)}, ${vr.currentPosition[1].toFixed(1)}) px
-Target Position: (${vr.targetPosition[0].toFixed(1)}, ${vr.targetPosition[1].toFixed(1)}) px
-Absolute Error: (${vr.absoluteError[0].toFixed(1)}, ${vr.absoluteError[1].toFixed(1)}) px`;
-  const padding = figmaMetadata.padding;
-  const layoutMode = typeof figmaMetadata.layoutMode === "string" ? figmaMetadata.layoutMode : "NONE";
-  const itemSpacing = typeof figmaMetadata.itemSpacing === "number" ? figmaMetadata.itemSpacing : 0;
-  const primaryAxisAlignItems = typeof figmaMetadata.primaryAxisAlignItems === "string" ? figmaMetadata.primaryAxisAlignItems : "N/A";
-  const counterAxisAlignItems = typeof figmaMetadata.counterAxisAlignItems === "string" ? figmaMetadata.counterAxisAlignItems : "N/A";
-  const resolvedPath = componentPaths?.[component.componentId];
-  if (!resolvedPath) {
-    throw new Error(`Component ${component.componentId} not found in componentPaths mapping`);
-  }
-  return `Component ID: ${component.componentId}
-Element IDs: ${JSON.stringify(component.elementIds)}
-File: ${resolvedPath}
-
-Validation Report:
-${validationReportFormatted}
-
-Figma Layout:
-- Mode: ${layoutMode}
-- Item Spacing: ${itemSpacing}px
-- Padding: ${padding?.left ?? 0}px (left) ${padding?.top ?? 0}px (top) ${padding?.right ?? 0}px (right) ${padding?.bottom ?? 0}px (bottom)
-- Primary Axis Alignment: ${primaryAxisAlignItems}
-- Counter Axis Alignment: ${counterAxisAlignItems}
-
-TASK:
-1. Read component file at: ${resolvedPath}
-2. Identify the layout error by comparing code with Figma metadata
-3. Locate exact code patterns with FileEditor.find
-4. Output JSON diagnosis with precise refine_instructions
-
-IMPORTANT:
-- Use FileEditor.read("${resolvedPath}") to read the component code
-- The path is an absolute filesystem path (e.g., /workspace/src/components/button/index.tsx)
-- When using HierarchyTool.lookup or related tools, use the Component ID: ${component.componentId}
-
-Remember: Use exact code strings and line numbers in refine_instructions.
-`;
-}
-
-// src/agents/refiner-agent/index.ts
-import { Agent as Agent4 } from "evoltagent";
-
-// src/agents/refiner-agent/prompt.ts
-var REFINER_PROMPT = `You are a React Code Editor. Apply fixes from judger's diagnosis.
-
-<workflow>
-1. For each refineInstruction, parse format: "In [path] line [N], change '[old]' to '[new]'"
-2. VALIDATE before executing:
-   - Skip if instruction says "keep unchanged", "no change needed", or lacks specific code
-   - Skip if OLD and NEW are identical
-   - Skip if OLD or NEW is empty
-   - Skip if instruction is vague like "apply fix in parent" without specific code
-3. Read file with FileEditor.read to verify the OLD pattern exists
-4. Use FileEditor.findAndReplace(path, pattern=old, replacement=new)
-   - IMPORTANT: Escape special regex chars in pattern: [ ] ( ) . * + ? $ ^ | \\
-   - Example: "mt-[20px]" \u2192 pattern="mt-\\[20px\\]"
-5. Report results
-</workflow>
-
-<validation_rules>
-SKIP instructions that:
-- Contain "keep unchanged" or "no change needed"
-- Don't have both '[old]' and '[new]' quoted strings
-- Have identical old and new values
-- Are vague suggestions without specific code
-
-ALWAYS escape regex special characters in the pattern parameter:
-- Brackets: [ \u2192 \\[, ] \u2192 \\]
-- Parentheses: ( \u2192 \\(, ) \u2192 \\)
-- Other: . * + ? $ ^ | \u2192 prefix with \\
-</validation_rules>
-
-<output>
-After edits, respond with a summary:
-- "Successfully applied: [description]" (per success)
-- "Failed to apply: [description]" (per failure)
-- "Skipped: [description]" (for invalid instructions)
-
-Wrap summary in <TaskCompletion> tags:
-<TaskCompletion>
-[Your summary here]
-</TaskCompletion>
-</output>
-`;
-
-// src/agents/refiner-agent/utils.ts
-function parseRefinerResult(response) {
-  const fullResponse = response.trim();
-  const lines = fullResponse.split("\n");
-  const summaryLines = [];
-  for (const line of lines) {
-    const trimmedLine = line.trim();
-    if (trimmedLine.startsWith("Successfully applied:") || trimmedLine.startsWith("Failed to apply:") || trimmedLine.startsWith("Skipped:")) {
-      summaryLines.push(trimmedLine);
-    }
-  }
-  const summary = summaryLines.length > 0 ? summaryLines : [fullResponse];
-  const summaryText = summary.join(" ").toLowerCase();
-  const successCount = (summaryText.match(/successfully applied:/g) || []).length;
-  const failedCount = (summaryText.match(/failed to apply:/g) || []).length;
-  return Promise.resolve({
-    success: successCount > 0 && failedCount === 0,
-    summary,
-    editsApplied: successCount,
-    error: failedCount > 0 ? `${failedCount} edit(s) failed` : void 0
-  });
-}
-
-// src/agents/refiner-agent/instruction.ts
-function formatRefinerInstruction(component, diagnosis, componentPaths) {
-  const resolvedPath = componentPaths?.[component.componentId];
-  if (!resolvedPath) {
-    throw new Error(`Component ${component.componentId} not found in componentPaths mapping`);
-  }
-  const refineInstructionsList = (diagnosis.refineInstructions || []).map((instr, i) => `${i + 1}. ${instr}`).join("\n");
-  return `Component ID: ${component.componentId}
-Element IDs: ${JSON.stringify(component.elementIds)}
-File: ${resolvedPath}
-
-Diagnosis from judger:
-${JSON.stringify(diagnosis, null, 2)}
-
-TASK:
-Apply each refineInstruction:
-${refineInstructionsList}
-
-For each instruction:
-1. Parse the old_code and new_code
-2. Use FileEditor.findAndReplace to apply the change
-3. Report success or failure
-
-IMPORTANT:
-- The file path is an absolute filesystem path (e.g., /workspace/src/components/button/index.tsx)
-- Use this exact path with FileEditor tools
-`;
-}
-
-// src/agents/refiner-agent/index.ts
-function createRefinerAgent(workspaceDir) {
-  let systemPrompt = REFINER_PROMPT;
-  if (workspaceDir) {
-    systemPrompt += `
-
-WORKSPACE: ${workspaceDir}
-Only modify files within this workspace.`;
-  }
-  const modelConfig = {
-    ...getModelConfig(),
-    contextWindowTokens: AGENT_CONTEXT_WINDOW_TOKENS,
-    maxOutputTokens: MAX_OUTPUT_TOKENS,
-    stream: true
-  };
-  return new Agent4({
-    name: "RefinerAgent",
-    profile: "Code editor specialist",
-    system: systemPrompt,
-    tools: ["FileEditor.read", "FileEditor.find", "FileEditor.findAndReplace"],
-    modelConfig,
-    postProcessor: parseRefinerResult,
-    verbose: 2
-  });
-}
-
-// src/agents/launch-agent/index.ts
-import { Agent as Agent5 } from "evoltagent";
-
-// src/agents/launch-agent/prompt.ts
-var LAUNCH_AGENT_PROMPT = `
-    <task_goal>
-        Prepare project for validation: install dependencies (if needed), build, fix errors, start dev server.
-        Return server metadata for validation loop to use.
-    </task_goal>
-
-    <workflow>
-        Follow steps IN ORDER. Repeat Step 2-3 until build succeeds, then proceed to Step 4.
-
-        Step 1: Install Dependencies (Conditional)
-            - Check instruction for skipInstall directive
-            - If "Skip Step 1" appears in instruction: Skip to Step 2
-            - Otherwise: Execute "pnpm i" in appPath
-            - Parameters: CommandLineTool.execute(command="pnpm i", cwd=appPath, timeoutMs=180000)
-            - Verify exitCode === 0 before proceeding
-            - If installation fails, analyze the error output and fix issues before proceeding
-
-        Step 2: Build Project
-            - Execute: CommandLineTool.execute(command="npm run build", cwd=appPath, timeoutMs=180000)
-            - Captures all compilation errors in output
-
-        Step 3: Fix Compilation Errors (If exitCode !== 0)
-            - Analyze error messages in 'error' and 'output' fields
-            - Use FileEditor.read to examine problematic files
-            - Use FileEditor.write to fix ONLY the specific broken lines
-            - CRITICAL: Do NOT delete or rewrite entire files. Do NOT simplify complex CSS or logic.
-            - Return to Step 2 and rebuild
-
-        Step 4: Start Dev Server & Check Runtime Errors
-            - Only proceed here when build is successful
-            - Execute: LaunchTool.startDevServer(appPath=appPath, runCommand="npm run dev", timeoutMs=60000)
-            - Returns JSON: { success, url, port, serverKey, outputTail }
-            - Parse and check outputTail for runtime error patterns EVEN IF success=true:
-                * "Module not found", "Cannot find module"
-                * "SyntaxError", "TypeError", "ReferenceError"
-                * "Failed to compile", "Unhandled Runtime Error"
-            - If errors found: Fix using FileEditor, then restart Step 2
-                * CRITICAL: Do NOT delete or rewrite entire files. Do NOT simplify complex CSS or logic.
-            - If clean: Store serverKey, url, port and proceed to Step 5
-
-        Step 5: Return Server Metadata
-            - Format final response as:
-              <TaskCompletion>
-              \`\`\`json
-              {
-                "success": true,
-                "serverKey": "launch:...",
-                "url": "http://localhost:PORT",
-                "port": PORT,
-                "message": "Dev server started successfully"
-              }
-              \`\`\`
-              </TaskCompletion>
-            - On failure before server start:
-              <TaskCompletion>
-              \`\`\`json
-              { "success": false, "error": "Description" }
-              \`\`\`
-              </TaskCompletion>
-    </workflow>
-
-    <principles>
-        1. STRICT CONTENT PRESERVATION (MANDATORY):
-            - NEVER modify CSS/Style content (colors, layouts, animations, etc.). If a CSS error exists, only fix the import/path or a specific syntax typo.
-            - NEVER modify or delete Image assets or their references.
-            - NEVER modify the DOM structure or JSX layout (adding/removing tags, changing classNames).
-            - NEVER replace file content with "template" or "placeholder" code.
-        2. ALLOWED CHANGES ONLY:
-            - Fixing 'module not found' by installing missing packages or correcting import paths.
-            - Fixing TypeScript/JavaScript syntax errors that prevent execution.
-            - Fixing configuration issues (e.g., tailwind.config.js, tsconfig.json).
-        3. BUILD FIRST: Dev server must not start until build succeeds (exitCode === 0).
-        4. PORT CONSISTENCY: Always use LaunchTool.startDevServer() (workspace-preferred port, same port across runs).
-        5. RUNTIME VALIDATION: Check outputTail in Step 4 for runtime errors even if success=true.
-    </principles>
-
-    <available_tools>
-        - FileEditor.read: Read file contents for analysis
-        - FileEditor.write: Write file contents to fix errors
-        - CommandLineTool.execute: Execute commands (pnpm i, npm run build only)
-        - LaunchTool.startDevServer: Start dev server (returns JSON with serverKey/url/port/outputTail)
-        - ThinkTool.execute: Think through complex problems
-    </available_tools>
-`;
-
-// src/agents/launch-agent/utils.ts
-init_logger();
-function parseLaunchResult(response) {
-  if (!response || response.trim().length === 0) {
-    logger.printInfoLog("Launch agent returned empty response");
-    return Promise.resolve({
-      success: false,
-      error: "Agent returned empty response"
-    });
-  }
-  const jsonMatch = response.match(/```json\n([\s\S]*?)\n```/);
-  if (!jsonMatch) {
-    logger.printInfoLog("Launch agent response missing JSON block");
-    return Promise.resolve({
-      success: false,
-      error: "No JSON code block found in agent response"
-    });
-  }
-  const jsonStr = jsonMatch[1];
-  if (!jsonStr || jsonStr.trim().length === 0) {
-    logger.printInfoLog("Launch agent response has empty JSON");
-    return Promise.resolve({
-      success: false,
-      error: "Empty JSON content in code block"
-    });
-  }
-  try {
-    const parsed = JSON.parse(jsonStr);
-    if (parsed.success === true && (!parsed.serverKey || !parsed.url || !parsed.port)) {
-      logger.printInfoLog("Launch agent success response missing required fields");
-      return Promise.resolve({
-        success: false,
-        error: "Missing required fields (serverKey, url, or port)"
-      });
-    }
-    return Promise.resolve(parsed);
-  } catch (error) {
-    logger.printInfoLog(`Launch agent response JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
-    return Promise.resolve({
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-
-// src/agents/launch-agent/instruction.ts
-function launchAgentInstruction(params) {
-  const skipNote = params.skipDependencyInstall ? "\n\nNOTE: Skip Step 1 (Install Dependencies). Dependencies already installed." : "";
-  return `appPath: ${params.appPath}${skipNote}
-
-TASK:
-Install dependencies, compile the project, fix any compilation errors, start the development server, and fix any runtime errors. The goal is to have a fully working, error-free project.`;
-}
-
-// src/agents/launch-agent/index.ts
-function createLaunchAgent() {
-  const modelConfig = {
-    ...getModelConfig(),
-    contextWindowTokens: AGENT_CONTEXT_WINDOW_TOKENS,
-    maxOutputTokens: MAX_OUTPUT_TOKENS
-  };
-  return new Agent5({
-    name: "LaunchAgent",
-    profile: "Expert DevOps and Frontend Engineer specialist in launching projects and troubleshooting build/runtime issues.",
-    system: LAUNCH_AGENT_PROMPT,
-    tools: [
-      "CommandLineTool.execute",
-      "CommandLineTool.list",
-      "CommandLineTool.stop",
-      "LaunchTool.startDevServer",
-      "LaunchTool.stopDevServer",
-      "FileEditor.read",
-      "FileEditor.find",
-      "FileEditor.findAndReplace",
-      "FileEditor.write"
-    ],
-    modelConfig,
-    verbose: 2,
-    postProcessor: parseLaunchResult
-  });
-}
-
-// src/nodes/validation/launch/index.ts
-var launch = async (appPath, config) => {
-  if (!appPath) {
-    throw new Error("appPath is required");
-  }
-  try {
-    const agentResult = await createLaunchAgent().run(
-      launchAgentInstruction({
-        appPath,
-        skipDependencyInstall: config?.skipDependencyInstall
-      })
-    );
-    if (agentResult.success === false) {
-      return {
-        success: false,
-        error: agentResult.error ?? "Launch agent failed without error message"
-      };
-    }
-    return {
-      success: true,
-      message: agentResult.message ?? "Launch and quality assurance completed",
-      serverKey: agentResult.serverKey,
-      url: agentResult.url,
-      port: agentResult.port
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-};
-
-// src/nodes/validation/utils/extraction/extract-layout-metadata.ts
-var LAYOUT_SCORES = {
-  FRAME_WITH_LAYOUT: 4,
-  NODE_WITH_LAYOUT: 3,
-  GROUP: 2,
-  DEFAULT: 1
-};
-function hasLayoutMode(element) {
-  return element.layoutMode !== "NONE" && element.layoutMode !== void 0;
-}
-function getLayoutScore(element) {
-  if (element.type === "FRAME" && hasLayoutMode(element)) {
-    return LAYOUT_SCORES.FRAME_WITH_LAYOUT;
-  }
-  if (hasLayoutMode(element)) {
-    return LAYOUT_SCORES.NODE_WITH_LAYOUT;
-  }
-  if (element.type === "GROUP") {
-    return LAYOUT_SCORES.GROUP;
-  }
-  return LAYOUT_SCORES.DEFAULT;
-}
-function findBestLayoutElement(elementIds, context) {
-  let bestElement;
-  let bestScore = -1;
-  for (const elemId of elementIds) {
-    const element = context.elements.get(elemId);
-    if (!element) continue;
-    const score = getLayoutScore(element);
-    if (score > bestScore) {
-      bestScore = score;
-      bestElement = element;
-      if (score === LAYOUT_SCORES.FRAME_WITH_LAYOUT) break;
-    }
-  }
-  return bestElement;
-}
-function extractLayoutFromContext(context, elementIds) {
-  const element = elementIds.length > 0 ? findBestLayoutElement(elementIds, context) : void 0;
-  if (!element) {
-    return {
-      layoutMode: "NONE",
-      primaryAxisAlignItems: "N/A",
-      counterAxisAlignItems: "N/A",
-      itemSpacing: 0,
-      padding: { top: 0, right: 0, bottom: 0, left: 0 },
-      constraints: {},
-      absoluteBoundingBox: {}
-    };
-  }
-  return {
-    layoutMode: element.layoutMode ?? "NONE",
-    primaryAxisAlignItems: element.primaryAxisAlignItems ?? "N/A",
-    counterAxisAlignItems: element.counterAxisAlignItems ?? "N/A",
-    itemSpacing: element.itemSpacing ?? 0,
-    padding: {
-      top: element.paddingTop ?? 0,
-      right: element.paddingRight ?? 0,
-      bottom: element.paddingBottom ?? 0,
-      left: element.paddingLeft ?? 0
-    },
-    constraints: element.constraints ?? {},
-    absoluteBoundingBox: {
-      x: element.position.x,
-      y: element.position.y,
-      width: element.position.w,
-      height: element.position.h
-    }
-  };
-}
-
-// src/nodes/validation/report/index.ts
-init_logger();
-
-// src/tools/report-tool/index.ts
-init_logger();
-import * as fs6 from "fs";
-import * as fsPromises from "fs/promises";
-import * as path8 from "path";
-import { fileURLToPath } from "url";
-import { tools as tools6 } from "evoltagent";
-
-// src/tools/visualization-tool/index.ts
-import { tools as tools5 } from "evoltagent";
-import * as path7 from "path";
-
-// src/tools/visualization-tool/utils/annotation-styles.ts
-var ANNOTATION_COLORS = {
-  RED: "#ef4444",
-  // Tailwind red-500 - for current/render positions
-  GREEN: "#22c55e"
-  // Tailwind green-500 - for target/expected positions
-};
-function createContainerStyle() {
-  return `
-        position: absolute;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        pointer-events: none;
-        z-index: 999999;
-    `;
-}
-function createBoxStyle(x, y, width, height, color) {
-  return `
-        position: absolute;
-        left: ${x}px;
-        top: ${y}px;
-        width: ${width}px;
-        height: ${height}px;
-        border: 4px solid ${color};
-        box-sizing: border-box;
-        pointer-events: none;
-    `;
-}
-function createCircleLabelStyle(x, y, color) {
-  const labelX = Math.max(5, x - 22);
-  const labelY = Math.max(5, y - 22);
-  return `
-        position: absolute;
-        left: ${labelX}px;
-        top: ${labelY}px;
-        background: ${color};
-        color: white;
-        width: 32px;
-        height: 32px;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        font: bold 18px Arial, sans-serif;
-        border-radius: 50%;
-        pointer-events: none;
-        border: 2px solid white;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.3);
-    `;
-}
-function createTextLabelStyle(x, y, height, color) {
-  return `
-        position: absolute;
-        left: ${x}px;
-        top: ${y + height + 4}px;
-        background: ${color};
-        color: white;
-        padding: 4px 8px;
-        font: 12px Arial, sans-serif;
-        border-radius: 4px;
-        pointer-events: none;
-        white-space: nowrap;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.3);
-    `;
-}
-
-// src/tools/visualization-tool/utils/annotate-render.ts
-async function annotateRenderWithPlaywright(page, misalignedData) {
-  await page.evaluate(
-    (data) => {
-      const { items, styles } = data;
-      const container = document.createElement("div");
-      container.id = "validation-annotations";
-      container.style.cssText = styles.container;
-      items.forEach((item) => {
-        const box = document.createElement("div");
-        const boxStyle = styles.boxes[item.index];
-        if (boxStyle) {
-          box.style.cssText = boxStyle;
-        }
-        container.appendChild(box);
-        const label = document.createElement("div");
-        label.textContent = `${item.index}`;
-        const circleLabelStyle = styles.circleLabels[item.index];
-        if (circleLabelStyle) {
-          label.style.cssText = circleLabelStyle;
-        }
-        container.appendChild(label);
-        const textLabel = document.createElement("div");
-        textLabel.textContent = `${item.componentName} (${item.distance.toFixed(1)}px)`;
-        const textLabelStyle = styles.textLabels[item.index];
-        if (textLabelStyle) {
-          textLabel.style.cssText = textLabelStyle;
-        }
-        container.appendChild(textLabel);
-      });
-      document.body.appendChild(container);
-    },
-    {
-      items: misalignedData,
-      styles: {
-        container: createContainerStyle(),
-        boxes: Object.fromEntries(
-          misalignedData.map((item) => [
-            item.index,
-            createBoxStyle(item.currentX, item.currentY, item.currentWidth, item.currentHeight, ANNOTATION_COLORS.RED)
-          ])
-        ),
-        circleLabels: Object.fromEntries(
-          misalignedData.map((item) => [item.index, createCircleLabelStyle(item.currentX, item.currentY, ANNOTATION_COLORS.RED)])
-        ),
-        textLabels: Object.fromEntries(
-          misalignedData.map((item) => [
-            item.index,
-            createTextLabelStyle(item.currentX, item.currentY, item.currentHeight, ANNOTATION_COLORS.RED)
-          ])
-        )
-      }
-    }
-  );
-}
-
-// src/tools/visualization-tool/utils/image-converter.ts
-import sharp from "sharp";
-var SCREENSHOT_WEBP_QUALITY = 88;
-async function captureAsWebP(page, options = {}) {
-  const pngBuffer = await page.screenshot({
-    type: "png",
-    fullPage: options.fullPage ?? false
-  });
-  return await bufferToWebPDataUri(pngBuffer);
-}
-async function bufferToWebPDataUri(buffer) {
-  const webpBuffer = await sharp(buffer).webp({ quality: SCREENSHOT_WEBP_QUALITY }).toBuffer();
-  return `data:image/webp;base64,${webpBuffer.toString("base64")}`;
-}
-
-// src/tools/visualization-tool/utils/annotate-target.ts
-async function annotateTargetWithPlaywright(browser, figmaThumbnailBase64, misalignedData, viewport, designOffset = { x: 0, y: 0 }, isThumbnailCropped = true) {
-  const context = await browser.newContext({ viewport });
-  const page = await context.newPage();
-  try {
-    const dataUri = figmaThumbnailBase64.startsWith("data:") ? figmaThumbnailBase64 : `data:image/png;base64,${figmaThumbnailBase64}`;
-    const html = `
-            <!DOCTYPE html>
-            <html>
-            <head>
-                <style>
-                    * { margin: 0; padding: 0; }
-                    body {
-                        width: ${viewport.width}px;
-                        height: ${viewport.height}px;
-                        background-image: url('${dataUri}');
-                        background-size: 100% 100%;
-                        background-repeat: no-repeat;
-                        background-position: top left;
-                        position: relative;
-                        overflow: hidden;
-                    }
-                </style>
-            </head>
-            <body></body>
-            </html>
-        `;
-    await page.setContent(html);
-    await page.waitForLoadState("domcontentloaded");
-    const offsetX = isThumbnailCropped ? 0 : designOffset.x;
-    const offsetY = isThumbnailCropped ? 0 : designOffset.y;
-    const elementsData = misalignedData.map((item, i) => ({
-      index: i + 1,
-      componentName: item.componentName,
-      targetX: item.targetX + offsetX,
-      targetY: item.targetY + offsetY,
-      width: item.targetWidth,
-      height: item.targetHeight
-    }));
-    const styles = {
-      container: createContainerStyle(),
-      boxes: Object.fromEntries(
-        elementsData.map((item) => [
-          item.index,
-          createBoxStyle(item.targetX, item.targetY, item.width, item.height, ANNOTATION_COLORS.GREEN)
-        ])
-      ),
-      circleLabels: Object.fromEntries(
-        elementsData.map((item) => [item.index, createCircleLabelStyle(item.targetX, item.targetY, ANNOTATION_COLORS.GREEN)])
-      ),
-      textLabels: Object.fromEntries(
-        elementsData.map((item) => [
-          item.index,
-          createTextLabelStyle(item.targetX, item.targetY, item.height, ANNOTATION_COLORS.GREEN)
-        ])
-      )
-    };
-    await page.evaluate(
-      (data) => {
-        const { items, styles: styles2 } = data;
-        const container = document.createElement("div");
-        container.id = "target-annotations";
-        container.style.cssText = styles2.container;
-        items.forEach((item) => {
-          const box = document.createElement("div");
-          const boxStyle = styles2.boxes[item.index];
-          if (boxStyle) {
-            box.style.cssText = boxStyle;
-          }
-          container.appendChild(box);
-          const label = document.createElement("div");
-          label.textContent = `${item.index}`;
-          const circleLabelStyle = styles2.circleLabels[item.index];
-          if (circleLabelStyle) {
-            label.style.cssText = circleLabelStyle;
-          }
-          container.appendChild(label);
-          const textLabel = document.createElement("div");
-          textLabel.textContent = `${item.componentName}`;
-          const textLabelStyle = styles2.textLabels[item.index];
-          if (textLabelStyle) {
-            textLabel.style.cssText = textLabelStyle;
-          }
-          container.appendChild(textLabel);
-        });
-        document.body.appendChild(container);
-      },
-      { items: elementsData, styles }
-    );
-    const screenshotBuffer = await page.screenshot({ type: "png", fullPage: false });
-    return await bufferToWebPDataUri(screenshotBuffer);
-  } finally {
-    await page.close();
-    await context.close();
-  }
-}
-
-// src/nodes/validation/utils/playwright/launcher.ts
-init_logger();
-import { chromium } from "playwright";
-import { spawn } from "child_process";
-import { createRequire } from "module";
-import { dirname, join } from "path";
-var MISSING_EXECUTABLE_MESSAGE = "Executable doesn't exist";
-function getLocalPlaywrightCliPath() {
-  const require2 = createRequire(import.meta.url);
-  const playwrightMain = require2.resolve("playwright");
-  return join(dirname(playwrightMain), "cli.js");
-}
-var installPromise = null;
-var installCompleted = false;
-async function installChromiumBrowsers() {
-  if (installCompleted) return;
-  if (!installPromise) {
-    logger.printInfoLog("Playwright Chromium binaries are missing. Installing them automatically...");
-    installPromise = new Promise((resolve2, reject) => {
-      const cliPath = getLocalPlaywrightCliPath();
-      const child = spawn(process.execPath, [cliPath, "install", "chromium"], {
-        stdio: "inherit",
-        env: process.env
-      });
-      child.on("error", (error) => {
-        installPromise = null;
-        reject(error);
-      });
-      child.on("close", (code) => {
-        installPromise = null;
-        if (code === 0) {
-          installCompleted = true;
-          logger.printSuccessLog("Playwright Chromium installation finished.");
-          resolve2();
-        } else {
-          reject(new Error(`Playwright install exited with code ${code}`));
-        }
-      });
-    });
-  }
-  return installPromise;
-}
-function isMissingExecutableError(error) {
-  return error instanceof Error && error.message.includes(MISSING_EXECUTABLE_MESSAGE);
-}
-async function launchChromiumWithAutoInstall(options = {}) {
-  const launchOptions = { headless: true, ...options };
-  try {
-    return await chromium.launch(launchOptions);
-  } catch (error) {
-    if (isMissingExecutableError(error)) {
-      try {
-        await installChromiumBrowsers();
-      } catch (installError) {
-        throw new Error(
-          `Failed to auto-install Playwright browsers required for validation.
-Please run "npx playwright install chromium" or "pnpm exec playwright install chromium" manually and retry.
-Installer error: ${installError.message}`
-        );
-      }
-      return chromium.launch(launchOptions);
-    }
-    throw error;
-  }
-}
-
-// src/tools/visualization-tool/utils/browser-management.ts
-async function browserManagement(viewport, operation) {
-  let browser = null;
-  let page = null;
-  try {
-    browser = await launchChromiumWithAutoInstall({ headless: true });
-    const context = await browser.newContext({ viewport });
-    page = await context.newPage();
-    return await operation(browser, page);
-  } finally {
-    if (page) await page.close().catch(() => {
-    });
-    if (browser) await browser.close().catch(() => {
-    });
-  }
-}
-
-// src/tools/visualization-tool/utils/combine.ts
-import fs5 from "fs";
-import path6 from "path";
-import sharp2 from "sharp";
-var DEFAULT_OPTIONS = {
-  leftHeader: "RENDER (Current)",
-  rightHeader: "TARGET (Expected)",
-  gapWidth: 40,
-  headerHeight: 60
-};
-async function combineSideBySide(renderBase64, targetBase64, outputPath, options) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  try {
-    const leftBase64 = extractBase64Data(renderBase64);
-    const rightBase64 = extractBase64Data(targetBase64);
-    const leftBuffer = Buffer.from(leftBase64, "base64");
-    const rightBuffer = Buffer.from(rightBase64, "base64");
-    const leftMeta = await sharp2(leftBuffer).metadata();
-    const rightMeta = await sharp2(rightBuffer).metadata();
-    if (!leftMeta.width || !leftMeta.height || !rightMeta.width || !rightMeta.height) {
-      throw new Error("Failed to read image dimensions");
-    }
-    const scale = leftMeta.height / rightMeta.height;
-    const rightResizedWidth = Math.round(rightMeta.width * scale);
-    const rightResized = await sharp2(rightBuffer).resize({ height: leftMeta.height, width: rightResizedWidth, fit: "fill" }).toBuffer();
-    const combinedWidth = leftMeta.width + opts.gapWidth + rightResizedWidth;
-    const combinedHeight = opts.headerHeight + leftMeta.height;
-    const centerX = leftMeta.width + opts.gapWidth / 2;
-    const leftTextX = leftMeta.width / 2;
-    const rightTextX = leftMeta.width + opts.gapWidth + rightResizedWidth / 2;
-    const textY = opts.headerHeight / 2 + 8;
-    const headerSvg = `
-<svg width="${combinedWidth}" height="${opts.headerHeight}">
-  <rect width="${combinedWidth}" height="${opts.headerHeight}" fill="#F0F0F0"/>
-  <line x1="${centerX}" y1="0" x2="${centerX}" y2="${combinedHeight}"
-        stroke="#C8C8C8" stroke-width="2"/>
-  <text x="${leftTextX}" y="${textY}"
-        font-family="Arial" font-size="24" font-weight="bold" fill="#C80000"
-        text-anchor="middle">
-    ${opts.leftHeader}
-  </text>
-  <text x="${rightTextX}" y="${textY}"
-        font-family="Arial" font-size="24" font-weight="bold" fill="#009600"
-        text-anchor="middle">
-    ${opts.rightHeader}
-  </text>
-</svg>
-        `;
-    const headerBuffer = Buffer.from(headerSvg);
-    const outputDir = path6.dirname(outputPath);
-    if (!fs5.existsSync(outputDir)) {
-      fs5.mkdirSync(outputDir, { recursive: true });
-    }
-    await sharp2({
-      create: {
-        width: combinedWidth,
-        height: combinedHeight,
-        channels: 3,
-        background: { r: 255, g: 255, b: 255 }
-      }
-    }).composite([
-      { input: headerBuffer, top: 0, left: 0 },
-      { input: leftBuffer, top: opts.headerHeight, left: 0 },
-      { input: rightResized, top: opts.headerHeight, left: leftMeta.width + opts.gapWidth }
-    ]).webp({ quality: SCREENSHOT_WEBP_QUALITY }).toFile(outputPath);
-  } catch (error) {
-    throw new Error(`Failed to combine side-by-side screenshots: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function extractBase64Data(base64String) {
-  const dataUriMatch = base64String.match(/^data:image\/[a-z]+;base64,(.+)$/);
-  if (dataUriMatch && dataUriMatch[1]) {
-    return dataUriMatch[1];
-  }
-  return base64String;
-}
-
-// src/tools/visualization-tool/utils/pixel-diff-heatmap.ts
-init_logger();
-import sharp3 from "sharp";
-import pixelmatch from "pixelmatch";
-async function generatePixelDiffHeatmap(renderSnap, targetSnap) {
-  const img1Data = await loadImageData(renderSnap);
-  const img2Data = await loadImageData(targetSnap);
-  let { width: width1, height: height1, data: data1 } = img1Data;
-  let { width: width2, height: height2, data: data2 } = img2Data;
-  if (width1 !== width2 || height1 !== height2) {
-    const resized = await sharp3(data2, {
-      raw: { width: width2, height: height2, channels: 4 }
-    }).resize(width1, height1, { fit: "fill" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-    data2 = resized.data;
-    width2 = resized.info.width;
-    height2 = resized.info.height;
-  }
-  const MAX_DIMENSION = 2500;
-  if (height1 > MAX_DIMENSION || width1 > MAX_DIMENSION) {
-    const scale = MAX_DIMENSION / Math.max(height1, width1);
-    const newWidth = Math.floor(width1 * scale);
-    const newHeight = Math.floor(height1 * scale);
-    const downsampled1 = await sharp3(data1, {
-      raw: { width: width1, height: height1, channels: 4 }
-    }).resize(newWidth, newHeight, { kernel: "lanczos3" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-    const downsampled2 = await sharp3(data2, {
-      raw: { width: width2, height: height2, channels: 4 }
-    }).resize(newWidth, newHeight, { kernel: "lanczos3" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-    data1 = downsampled1.data;
-    data2 = downsampled2.data;
-    width1 = downsampled1.info.width;
-    height1 = downsampled1.info.height;
-    width2 = downsampled2.info.width;
-    height2 = downsampled2.info.height;
-  }
-  const diffBuffer = Buffer.alloc(width1 * height1 * 4);
-  const numDiffPixels = pixelmatch(data1, data2, diffBuffer, width1, height1, {
-    threshold: 0.1,
-    includeAA: false,
-    alpha: 0.1,
-    diffColor: [255, 0, 0],
-    diffMask: false
-  });
-  const totalPixels = width1 * height1;
-  const diffPercentage = (numDiffPixels / totalPixels * 100).toFixed(2);
-  logger.printTestLog(`[Pixelmatch] Different pixels: ${numDiffPixels} / ${totalPixels} (${diffPercentage}%)`);
-  const heatmapBuffer = await generateRedGreenOverlay(data1, data2, diffBuffer, width1, height1);
-  return await bufferToWebPDataUri(heatmapBuffer);
-}
-async function generateRedGreenOverlay(data1, data2, diffBuffer, width, height) {
-  const outputData = Buffer.alloc(width * height * 3);
-  const differences = new Float32Array(width * height);
-  let maxDiff = 0;
-  for (let i = 0; i < width * height; i++) {
-    const r1 = data1[i * 4] ?? 0;
-    const g1 = data1[i * 4 + 1] ?? 0;
-    const b1 = data1[i * 4 + 2] ?? 0;
-    const r2 = data2[i * 4] ?? 0;
-    const g2 = data2[i * 4 + 1] ?? 0;
-    const b2 = data2[i * 4 + 2] ?? 0;
-    const diff = Math.sqrt(Math.pow(r1 - r2, 2) * 0.299 + Math.pow(g1 - g2, 2) * 0.587 + Math.pow(b1 - b2, 2) * 0.114);
-    differences[i] = diff;
-    maxDiff = Math.max(maxDiff, diff);
-  }
-  let pixelsWithDifferences = 0;
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const idx = y * width + x;
-      const outIdx = idx * 3;
-      const isDifferent = (diffBuffer[idx * 4] ?? 0) > 0;
-      if (isDifferent) {
-        pixelsWithDifferences++;
-        const normalizedDiff = maxDiff > 0 ? (differences[idx] ?? 0) / maxDiff : 0;
-        const [r, g, b] = getDiffColor(normalizedDiff);
-        outputData[outIdx] = r;
-        outputData[outIdx + 1] = g;
-        outputData[outIdx + 2] = b;
-      } else {
-        outputData[outIdx] = 0;
-        outputData[outIdx + 1] = 0;
-        outputData[outIdx + 2] = 200;
-      }
-    }
-  }
-  logger.printTestLog(
-    `[Heatmap] Pixels with differences: ${pixelsWithDifferences} / ${width * height} (${(pixelsWithDifferences / (width * height) * 100).toFixed(2)}%)`
-  );
-  return sharp3(outputData, { raw: { width, height, channels: 3 } }).png().toBuffer();
-}
-function getDiffColor(normalizedDiff) {
-  normalizedDiff = Math.max(0, Math.min(1, normalizedDiff));
-  if (normalizedDiff < 0.33) {
-    const t = normalizedDiff / 0.33;
-    return [0, Math.round(255 * t), 255];
-  } else if (normalizedDiff < 0.67) {
-    const t = (normalizedDiff - 0.33) / 0.34;
-    return [Math.round(255 * t), 255, Math.round(255 * (1 - t))];
-  } else {
-    const t = (normalizedDiff - 0.67) / 0.33;
-    return [255, Math.round(255 * (1 - t)), 0];
-  }
-}
-async function loadImageData(dataUri) {
-  if (!dataUri.startsWith("data:")) {
-    const axios4 = (await import("axios")).default;
-    const response = await axios4.get(dataUri, { responseType: "arraybuffer", timeout: 3e4 });
-    const base64 = Buffer.from(response.data).toString("base64");
-    dataUri = `data:image/png;base64,${base64}`;
-  }
-  const base64Data = dataUri.split(",")[1];
-  if (!base64Data) {
-    throw new Error("Invalid data URI format: missing base64 data");
-  }
-  const buffer = Buffer.from(base64Data, "base64");
-  const image = sharp3(buffer);
-  const { data, info } = await image.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-  return { width: info.width, height: info.height, data };
-}
-
-// src/tools/visualization-tool/index.ts
-init_logger();
-var _VisualizationTool_decorators, _init5;
-_VisualizationTool_decorators = [tools5({
-  annotateRender: {
-    description: "Navigate to the dev server, capture a clean render screenshot, inject RED annotation boxes for misaligned components, and capture the annotated render screenshot.",
-    params: [
-      { name: "serverUrl", type: "string", description: "Dev server URL (e.g., http://localhost:5173)" },
-      {
-        name: "misalignedData",
-        type: "object",
-        description: "MisalignedComponentData[] used to draw RED boxes on the render."
-      },
-      { name: "viewport", type: "object", description: "Viewport {width,height} to use in Playwright." }
-    ],
-    returns: {
-      type: "object",
-      description: "AnnotateRenderResult containing renderSnap and renderMarked (WebP data URIs)."
-    }
-  },
-  annotateTarget: {
-    description: "Fetch the Figma thumbnail, inject GREEN annotation boxes for misaligned components, and return an annotated target screenshot.",
-    params: [
-      { name: "figmaThumbnailUrl", type: "string", description: "Figma thumbnail CDN URL." },
-      {
-        name: "misalignedData",
-        type: "object",
-        description: "MisalignedComponentData[] used to draw GREEN boxes on the target."
-      },
-      { name: "viewport", type: "object", description: "Viewport {width,height} to match the Figma thumbnail." },
-      {
-        name: "designOffset",
-        type: "object",
-        description: "Design offset {x,y} used when the thumbnail is not cropped (default behavior is cropped).",
-        optional: true
-      }
-    ],
-    returns: { type: "string", description: "Annotated target screenshot as WebP data URI." }
-  },
-  annotateTargetFromBase64: {
-    description: "Annotate target using pre-cached base64 thumbnail data. Use this to avoid redundant Figma thumbnail downloads.",
-    params: [
-      { name: "figmaThumbnailBase64", type: "string", description: "Base64-encoded Figma thumbnail data." },
-      {
-        name: "misalignedData",
-        type: "object",
-        description: "MisalignedComponentData[] used to draw GREEN boxes on the target."
-      },
-      { name: "viewport", type: "object", description: "Viewport {width,height} to match the Figma thumbnail." },
-      {
-        name: "designOffset",
-        type: "object",
-        description: "Design offset {x,y} used when the thumbnail is not cropped (default behavior is cropped).",
-        optional: true
-      }
-    ],
-    returns: { type: "string", description: "Annotated target screenshot as WebP data URI." }
-  },
-  combine: {
-    description: "Combine two base64 screenshots side-by-side with headers and write to outputPath (WebP).",
-    params: [
-      { name: "renderMarked", type: "string", description: "Left image (render, typically annotated) as base64 data URI." },
-      { name: "targetMarked", type: "string", description: "Right image (target, typically annotated) as base64 data URI." },
-      { name: "outputPath", type: "string", description: "Filesystem output path for the combined WebP." },
-      { name: "options", type: "object", description: "Optional CombineOptions", optional: true }
-    ],
-    returns: { type: "string", description: "The outputPath written." }
-  },
-  diffHeatmap: {
-    description: "Generate pixel-diff heatmap between a render screenshot and the target thumbnail.",
-    params: [
-      { name: "renderSnap", type: "string", description: "Render screenshot (WebP data URI)." },
-      { name: "targetSnap", type: "string", description: "Target screenshot (WebP data URI) OR URL." }
-    ],
-    returns: { type: "string", description: "Heatmap image as WebP data URI." }
-  },
-  generateIterationScreenshot: {
-    description: "Generate annotated comparison screenshot for validation iteration. Orchestrates annotate + combine for convenience.",
-    params: [
-      { name: "misalignedComponents", type: "object", description: "MisalignedComponent[] from validation result" },
-      { name: "serverUrl", type: "string", description: "Dev server URL" },
-      { name: "figmaThumbnailUrl", type: "string", description: "Figma thumbnail URL" },
-      { name: "viewport", type: "object", description: "Viewport {width, height}" },
-      { name: "designOffset", type: "object", description: "Design offset {x, y}" },
-      { name: "outputPath", type: "string", description: "Output file path for combined screenshot" },
-      {
-        name: "cachedFigmaThumbnailBase64",
-        type: "string",
-        description: "Optional cached thumbnail base64",
-        optional: true
-      }
-    ],
-    returns: { type: "object", description: "IterationScreenshotResult with renderMarked, targetMarked, and combinedPath" }
-  }
-})];
-var VisualizationTool = class {
-  async annotateRender(serverUrl, misalignedData, viewport) {
-    return await browserManagement(viewport, async (_browser, page) => {
-      await page.goto(serverUrl, { waitUntil: "domcontentloaded", timeout: 3e4 });
-      await new Promise((r) => setTimeout(r, 1e3));
-      const renderSnap = await captureAsWebP(page);
-      await annotateRenderWithPlaywright(page, misalignedData);
-      const renderMarked = await captureAsWebP(page);
-      return { renderSnap, renderMarked };
-    });
-  }
-  async annotateTarget(figmaThumbnailUrl, misalignedData, viewport, designOffset) {
-    const axios4 = (await import("axios")).default;
-    const response = await axios4.get(figmaThumbnailUrl, { responseType: "arraybuffer", timeout: 3e4 });
-    const figmaThumbnailBase64 = Buffer.from(response.data).toString("base64");
-    return await browserManagement(viewport, async (browser) => {
-      return await annotateTargetWithPlaywright(browser, figmaThumbnailBase64, misalignedData, viewport, designOffset);
-    });
-  }
-  /**
-   * Annotate target using pre-cached base64 thumbnail data.
-   * Use this method when you have already downloaded the Figma thumbnail to avoid redundant downloads.
-   */
-  async annotateTargetFromBase64(figmaThumbnailBase64, misalignedData, viewport, designOffset) {
-    return await browserManagement(viewport, async (browser) => {
-      return await annotateTargetWithPlaywright(browser, figmaThumbnailBase64, misalignedData, viewport, designOffset);
-    });
-  }
-  async combine(renderMarked, targetMarked, outputPath, options) {
-    await combineSideBySide(renderMarked, targetMarked, outputPath, options);
-    return outputPath;
-  }
-  async diffHeatmap(renderSnap, targetSnap) {
-    return await generatePixelDiffHeatmap(renderSnap, targetSnap);
-  }
-  /**
-   * Generate annotated comparison screenshot for a single iteration.
-   * This is a convenience method that orchestrates the full screenshot workflow.
-   *
-   * @returns IterationScreenshotResult with individual annotated screenshots and combined path
-   */
-  async generateIterationScreenshot(misalignedComponents, serverUrl, figmaThumbnailUrl, viewport, designOffset, outputPath, cachedFigmaThumbnailBase64) {
-    if (misalignedComponents.length === 0) {
-      return { renderMarked: "", targetMarked: "", combinedPath: "" };
-    }
-    try {
-      const misalignedData = this.formatForVisualization(misalignedComponents);
-      const render = await this.annotateRender(serverUrl, misalignedData, viewport);
-      const targetMarked = cachedFigmaThumbnailBase64 ? await this.annotateTargetFromBase64(cachedFigmaThumbnailBase64, misalignedData, viewport, designOffset) : await this.annotateTarget(figmaThumbnailUrl, misalignedData, viewport, designOffset);
-      await this.combine(render.renderMarked, targetMarked, outputPath);
-      logger.printInfoLog(`Saved comparison screenshot: ${path7.basename(outputPath)}`);
-      return {
-        renderMarked: render.renderMarked,
-        targetMarked,
-        combinedPath: outputPath
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.printWarnLog(`Failed to generate iteration screenshot: ${errorMsg}`);
-      return { renderMarked: "", targetMarked: "", combinedPath: "" };
-    }
-  }
-  /**
-   * Transform MisalignedComponent[] to MisalignedComponentData[] format.
-   * This is an internal helper for converting validation results to visualization format.
-   */
-  formatForVisualization(components) {
-    return components.map((comp, idx) => {
-      if (comp.elementIds.length === 0) {
-        logger.printWarnLog(`Component ${comp.name} has no elementIds. Using componentId as fallback.`);
-      }
-      return {
-        index: idx + 1,
-        elementId: comp.elementIds[0] || comp.componentId,
-        elementName: comp.name,
-        componentId: comp.componentId,
-        componentName: comp.name,
-        componentPath: comp.path,
-        currentX: comp.currentX,
-        currentY: comp.currentY,
-        currentWidth: comp.currentWidth,
-        currentHeight: comp.currentHeight,
-        targetX: comp.targetX,
-        targetY: comp.targetY,
-        targetWidth: comp.targetWidth,
-        targetHeight: comp.targetHeight,
-        distance: comp.distance,
-        xDelta: comp.validationReport.absoluteError[0],
-        yDelta: comp.validationReport.absoluteError[1]
-      };
-    });
-  }
-};
-_init5 = __decoratorStart(null);
-VisualizationTool = __decorateElement(_init5, 0, "VisualizationTool", _VisualizationTool_decorators, VisualizationTool);
-__runInitializers(_init5, 1, VisualizationTool);
-
-// src/tools/report-tool/index.ts
-var _ReportTool_decorators, _init6;
-_ReportTool_decorators = [tools6({
-  generateReport: {
-    description: "Generate visual validation report structure from pre-computed validation results. Creates annotated screenshots, heatmap, and userReport structure.",
-    params: [
-      {
-        name: "request",
-        type: "object",
-        description: "ReportGenerationRequest with validationResult, figmaThumbnailUrl, serverUrl, outputDir, etc."
-      }
-    ],
-    returns: { type: "object", description: "ReportGenerationResult with userReport and misalignedCount" }
-  },
-  createMinimalReport: {
-    description: "Create a minimal user report for error scenarios without screenshots",
-    params: [{ name: "options", type: "object", description: "ErrorReportOptions with serverUrl, figmaThumbnailUrl, mae, sae" }],
-    returns: { type: "object", description: "Minimal UserReport structure" }
-  },
-  generateHtml: {
-    description: "Generate standalone HTML report file from userReport with embedded data and inlined assets",
-    params: [
-      { name: "userReport", type: "object", description: "UserReport data from validation with screenshots and metrics" },
-      { name: "outputDir", type: "string", description: "Output directory path for HTML file" }
-    ],
-    returns: { type: "object", description: "GenerateHtmlResult with success/htmlPath/error" }
-  }
-})];
-var ReportTool = class {
-  /**
-   * Generate visual validation report from validation results.
-   *
-   * This method ONLY does visualization and formatting:
-   * - Loads saved annotated screenshots from last validation iteration (avoids port mismatch)
-   * - Generates pixel difference heatmap
-   * - Builds userReport structure
-   *
-   */
-  async generateReport(request) {
-    logger.printInfoLog("\nGenerating validation report...");
-    const visualizationTool = new VisualizationTool();
-    const { validationResult } = request;
-    const comparisonDir = path8.join(request.outputDir, "comparison_screenshots");
-    if (!fs6.existsSync(comparisonDir)) {
-      fs6.mkdirSync(comparisonDir, { recursive: true });
-    }
-    const misalignedData = visualizationTool["formatForVisualization"](validationResult.misalignedComponents);
-    logger.printInfoLog(`Final misaligned components: ${misalignedData.length}`);
-    const renderMarkedBuffer = await fsPromises.readFile(request.savedRenderMarkedPath);
-    const targetMarkedBuffer = await fsPromises.readFile(request.savedTargetMarkedPath);
-    const renderMarked = `data:image/webp;base64,${renderMarkedBuffer.toString("base64")}`;
-    const targetMarked = `data:image/webp;base64,${targetMarkedBuffer.toString("base64")}`;
-    const screenshots = {
-      renderSnap: validationResult.screenshots?.renderSnap || renderMarked,
-      renderMarked,
-      targetMarked
-    };
-    const finalScreenshotPath = path8.join(comparisonDir, "final.webp");
-    await visualizationTool.combine(screenshots.renderMarked, screenshots.targetMarked, finalScreenshotPath);
-    logger.printSuccessLog(`Saved final comparison screenshot: ${path8.basename(finalScreenshotPath)}`);
-    let heatmap = "";
-    try {
-      heatmap = await visualizationTool.diffHeatmap(screenshots.renderSnap, request.figmaThumbnailUrl);
-      if (heatmap) {
-        const heatmapPath = path8.join(comparisonDir, "heatmap.webp");
-        const base64Data = heatmap.split(",")[1];
-        if (!base64Data) {
-          throw new Error("Invalid heatmap data URI format");
-        }
-        const buffer = Buffer.from(base64Data, "base64");
-        await fs6.promises.writeFile(heatmapPath, buffer);
-        logger.printSuccessLog(`Saved pixel difference heatmap: ${path8.basename(heatmapPath)}`);
-      }
-    } catch (heatmapError) {
-      const errorMsg = heatmapError instanceof Error ? heatmapError.message : "Unknown error";
-      logger.printWarnLog(`Failed to generate pixel difference heatmap: ${errorMsg}. Continuing without heatmap.`);
-    }
-    const userReport = this.buildUserReportStructure(
-      validationResult.mae,
-      validationResult.sae,
-      misalignedData.length,
-      screenshots,
-      heatmap,
-      request.serverUrl,
-      request.figmaThumbnailUrl,
-      misalignedData
-    );
-    logger.printSuccessLog("Validation report generated successfully");
-    return {
-      userReport,
-      misalignedCount: misalignedData.length
-    };
-  }
-  /**
-   * Creates a minimal user report for error scenarios.
-   */
-  createMinimalReport(options) {
-    return {
-      design: {
-        snap: options.figmaThumbnailUrl || "",
-        markedSnap: ""
-      },
-      page: {
-        url: options.serverUrl,
-        snap: "",
-        markedSnap: ""
-      },
-      report: {
-        heatmap: "",
-        detail: {
-          metrics: {
-            mae: options.mae ?? -1,
-            sae: options.sae ?? -1,
-            misalignedCount: 0
-          },
-          components: []
-        }
-      }
-    };
-  }
-  /**
-   * Generate standalone HTML report file from userReport.
-   * Inlines all assets (JS/CSS) for single-file distribution.
-   */
-  async generateHtml(userReport, outputDir) {
-    const reportDistDir = this.getReportDistDir();
-    const reportIndexHtml = path8.join(reportDistDir, "index.html");
-    logger.printInfoLog(`[ReportTool] Using template: ${reportIndexHtml}`);
-    logger.printInfoLog(`[ReportTool] Output directory: ${outputDir}`);
-    try {
-      try {
-        await fsPromises.access(reportIndexHtml);
-      } catch {
-        const errorMsg = `Template not found at ${reportIndexHtml}`;
-        logger.printErrorLog(`[ReportTool] ${errorMsg}. Skipping report generation.`);
-        return { success: false, error: errorMsg };
-      }
-      await fsPromises.mkdir(outputDir, { recursive: true });
-      let reportData = userReport;
-      if (reportData) {
-        reportData = this.transformReportData(reportData);
-      }
-      logger.printTestLog(`Report data: ${JSON.stringify(reportData)}`);
-      let htmlContent = await fsPromises.readFile(reportIndexHtml, "utf-8");
-      const jsonString = JSON.stringify(reportData).replace(/<\/script>/gi, "<\\/script>").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-      const scriptTag = `<script>window.__REPORT_DATA__ = ${jsonString};</script>`;
-      htmlContent = htmlContent.replace(/<script>\s*window\.__REPORT_DATA__\s*=\s*null;?\s*<\/script>/, scriptTag);
-      const scriptRegexGlobal = /<script\s+type="module"\s+crossorigin\s+src="\/assets\/([^"]+)"><\/script>/g;
-      const jsMatches = [...htmlContent.matchAll(scriptRegexGlobal)];
-      const jsContentsMap = /* @__PURE__ */ new Map();
-      for (const match of jsMatches) {
-        const fileName = match[1];
-        if (fileName) {
-          const jsFilePath = path8.join(reportDistDir, "assets", fileName);
-          try {
-            let jsContent = await fsPromises.readFile(jsFilePath, "utf-8");
-            jsContent = jsContent.replace(/<\/script>/g, "\\u003c/script>");
-            jsContentsMap.set(fileName, jsContent);
-          } catch {
-            logger.printWarnLog(`[ReportTool] JS asset not found: ${jsFilePath}`);
-          }
-        }
-      }
-      htmlContent = htmlContent.replace(scriptRegexGlobal, (match, fileName) => {
-        const jsContent = jsContentsMap.get(fileName);
-        if (jsContent) {
-          return `<script type="module">${jsContent}</script>`;
-        }
-        return match;
-      });
-      const cssRegex = /<link\s+rel="stylesheet"\s+crossorigin\s+href="\/assets\/(.*?)">/;
-      const cssMatch = htmlContent.match(cssRegex);
-      if (cssMatch) {
-        const cssFileName = cssMatch[1];
-        if (!cssFileName) {
-          logger.printWarnLog("[ReportTool] CSS filename not found in match");
-        } else {
-          const cssFilePath = path8.join(reportDistDir, "assets", cssFileName);
-          try {
-            const cssContent = await fsPromises.readFile(cssFilePath, "utf-8");
-            htmlContent = htmlContent.replace(cssMatch[0], `<style>${cssContent}</style>`);
-          } catch {
-          }
-        }
-      }
-      htmlContent = htmlContent.replace('<link rel="stylesheet" href="/index.css">', "");
-      const absoluteOutputPath = path8.join(outputDir, "index.html");
-      await fsPromises.writeFile(absoluteOutputPath, htmlContent);
-      return { success: true, htmlPath: absoluteOutputPath };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.printErrorLog(`[ReportTool] Failed to generate report: ${errorMsg}`);
-      return { success: false, error: errorMsg };
-    }
-  }
-  // ==================== PRIVATE HELPER METHODS ====================
-  /**
-   * Build userReport structure from validation results
-   */
-  buildUserReportStructure(mae, sae, misalignedCount, screenshots, heatmap, serverUrl, figmaThumbnailUrl, misalignedData) {
-    return {
-      design: {
-        snap: figmaThumbnailUrl,
-        markedSnap: screenshots.targetMarked
-      },
-      page: {
-        url: serverUrl,
-        snap: screenshots.renderSnap,
-        markedSnap: screenshots.renderMarked
-      },
-      report: {
-        heatmap,
-        detail: {
-          metrics: {
-            mae,
-            sae,
-            misalignedCount
-          },
-          components: misalignedData.map((c) => ({
-            componentId: c.componentId,
-            componentPath: c.componentPath,
-            elementId: c.elementId,
-            validationInfo: {
-              x: c.xDelta,
-              y: c.yDelta
-            }
-          }))
-        }
-      }
-    };
-  }
-  /**
-   * Transform report data by grouping components by componentId
-   */
-  transformReportData(reportData) {
-    const components = reportData?.report?.detail?.components || [];
-    if (!components?.length) return reportData;
-    const groupedComponentsMap = /* @__PURE__ */ new Map();
-    components.forEach((component, index) => {
-      const { componentId, componentPath, elementId, validationInfo } = component;
-      const elementIndex = index + 1;
-      if (!groupedComponentsMap.has(componentId)) {
-        groupedComponentsMap.set(componentId, {
-          componentId,
-          componentPath,
-          elements: []
-        });
-      }
-      groupedComponentsMap.get(componentId)?.elements?.push({
-        elementId: elementId || "",
-        elementIndex,
-        validationInfo: validationInfo || { x: 0, y: 0 }
-      });
-    });
-    const groupedComponents = Array.from(groupedComponentsMap.values());
-    return {
-      ...reportData,
-      report: {
-        ...reportData.report,
-        detail: {
-          ...reportData.report.detail,
-          components: groupedComponents
-        }
-      }
-    };
-  }
-  /**
-   * Determine the root directory of the package by walking up to find package.json
-   */
-  getPackageRoot() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path8.dirname(__filename);
-    let currentDir = __dirname;
-    while (currentDir !== path8.parse(currentDir).root) {
-      if (fs6.existsSync(path8.join(currentDir, "package.json"))) {
-        return currentDir;
-      }
-      currentDir = path8.dirname(currentDir);
-    }
-    return process.cwd();
-  }
-  /**
-   * Get the report dist directory containing built HTML/assets
-   */
-  getReportDistDir() {
-    const root = this.getPackageRoot();
-    const paths = [
-      path8.join(root, "dist/tools/report-tool/template"),
-      // Production layout (if copied)
-      path8.join(root, "src/tools/report-tool/template/dist")
-      // Development layout
-    ];
-    for (const p of paths) {
-      if (fs6.existsSync(path8.join(p, "index.html"))) {
-        return p;
-      }
-    }
-    return path8.join(root, "src/tools/report-tool/template/dist");
-  }
-};
-_init6 = __decoratorStart(null);
-ReportTool = __decorateElement(_init6, 0, "ReportTool", _ReportTool_decorators, ReportTool);
-__runInitializers(_init6, 1, ReportTool);
-
-// src/nodes/validation/report/index.ts
-async function report(options) {
-  const tool = new ReportTool();
-  try {
-    logger.printInfoLog("Generating validation report structure...");
-    const reportResult = await tool.generateReport({
-      validationResult: options.validationResult,
-      figmaThumbnailUrl: options.figmaThumbnailUrl,
-      cachedFigmaThumbnailBase64: options.cachedFigmaThumbnailBase64,
-      designOffset: options.designOffset,
-      outputDir: options.outputDir,
-      serverUrl: options.serverUrl,
-      savedRenderMarkedPath: options.savedRenderMarkedPath,
-      savedTargetMarkedPath: options.savedTargetMarkedPath
-    });
-    logger.printInfoLog("Generating HTML report file...");
-    const htmlResult = await tool.generateHtml(reportResult.userReport, options.outputDir);
-    if (!htmlResult.success) {
-      logger.printWarnLog(`Failed to generate HTML: ${htmlResult.error}`);
-      return {
-        success: false,
-        error: htmlResult.error,
-        userReport: reportResult.userReport
-      };
-    }
-    logger.printSuccessLog(`Report generated successfully: ${htmlResult.htmlPath}`);
-    return {
-      success: true,
-      htmlPath: htmlResult.htmlPath,
-      userReport: reportResult.userReport
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.printErrorLog(`Error generating report: ${errorMessage}`);
-    const minimalReport = tool.createMinimalReport({
-      serverUrl: options.serverUrl,
-      figmaThumbnailUrl: options.figmaThumbnailUrl,
-      mae: options.validationResult?.mae,
-      sae: options.validationResult?.sae
-    });
-    return {
-      success: false,
-      error: errorMessage,
-      userReport: minimalReport
-    };
-  }
-}
-
-// src/tools/launch-tool/index.ts
-import * as path9 from "path";
-import { tools as tools7 } from "evoltagent";
-
-// src/tools/launch-tool/utils/dev-server-manager.ts
-import * as http from "http";
-import * as net from "net";
-import { spawn as spawn2 } from "child_process";
-init_logger();
-function normalizeExecutable(executable) {
-  if (process.platform !== "win32") {
-    return executable;
-  }
-  const lower = executable.toLowerCase();
-  if (lower === "npm" || lower === "pnpm" || lower === "yarn" || lower === "npx") {
-    return `${lower}.cmd`;
-  }
-  return executable;
-}
-function parseCommandWithPortSupport(commandStr) {
-  const parts = commandStr.trim().split(/\s+/);
-  const executable = parts[0];
-  if (!executable) {
-    throw new Error("Failed to parse command: empty command string");
-  }
-  const args = parts.slice(1);
-  const needsDoubleDash = ["npm", "pnpm", "yarn"].includes(executable);
-  return { executable, args, needsDoubleDash };
-}
-async function isPortAvailable(port) {
-  return await new Promise((resolve2) => {
-    const server = net.createServer();
-    server.unref();
-    server.on("error", () => resolve2(false));
-    server.listen(port, () => {
-      server.close(() => resolve2(true));
-    });
-  });
-}
-function calculateHashPort(workspacePath, basePort = 5200) {
-  let hash = 0;
-  for (let i = 0; i < workspacePath.length; i++) {
-    hash = (hash << 5) - hash + workspacePath.charCodeAt(i);
-    hash = hash & hash;
-  }
-  const offset = Math.abs(hash) % 1e3;
-  return basePort + offset;
-}
-async function getFreeHashPort(workspacePath, _startPort = DEFAULT_PORT) {
-  const preferredPort = calculateHashPort(workspacePath);
-  if (await isPortAvailable(preferredPort)) {
-    logger.printInfoLog(`Using workspace-preferred port: ${preferredPort}`);
-    return preferredPort;
-  }
-  logger.printInfoLog(`Preferred port ${preferredPort} occupied, trying nearby ports...`);
-  for (let offset = 1; offset <= 10; offset++) {
-    const portUp = preferredPort + offset;
-    const portDown = preferredPort - offset;
-    if (await isPortAvailable(portUp)) {
-      logger.printInfoLog(`Using nearby port: ${portUp} (preferred was ${preferredPort})`);
-      return portUp;
-    }
-    if (portDown > 1024 && await isPortAvailable(portDown)) {
-      logger.printInfoLog(`Using nearby port: ${portDown} (preferred was ${preferredPort})`);
-      return portDown;
-    }
-  }
-  throw new Error(`No available ports found in workspace-preferred range (${preferredPort - 10} to ${preferredPort + 10})`);
-}
-async function waitForServerReady(url, timeoutMs) {
-  const start = Date.now();
-  const intervalMs = 400;
-  while (Date.now() - start < timeoutMs) {
-    const ok = await new Promise((resolve2) => {
-      const req = http.get(url, (res) => {
-        res.resume();
-        resolve2(res.statusCode !== void 0 && res.statusCode >= 200 && res.statusCode < 500);
-      });
-      req.on("error", () => resolve2(false));
-      req.setTimeout(500, () => req.destroy());
-    });
-    if (ok) return true;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-  return false;
-}
-var DevServerManager = class {
-  constructor(params) {
-    this.params = params;
-  }
-  handle = null;
-  get current() {
-    return this.handle;
-  }
-  async start(options = { timeoutMs: 6e4 }) {
-    if (this.handle) {
-      return this.handle;
-    }
-    const port = await getFreeHashPort(this.params.appPath);
-    const url = buildDevServerUrl(port);
-    const { executable, args, needsDoubleDash } = parseCommandWithPortSupport(this.params.runCommand);
-    const normalizedExecutable = normalizeExecutable(executable);
-    const commandArgs = needsDoubleDash ? [...args, "--", "--port", String(port)] : [...args, "--port", String(port)];
-    logger.printInfoLog(`Starting dev server: ${normalizedExecutable} ${commandArgs.join(" ")}`);
-    const child = spawn2(normalizedExecutable, commandArgs, {
-      cwd: this.params.appPath,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        PORT: String(port),
-        FORCE_COLOR: "1"
-      }
-    });
-    const maxBytes = 1e6;
-    let out = "";
-    const push = (chunk) => {
-      out += chunk.toString("utf-8");
-      if (out.length > maxBytes) {
-        out = out.slice(out.length - maxBytes);
-      }
-    };
-    child.stdout?.on("data", push);
-    child.stderr?.on("data", push);
-    process.once("exit", () => {
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    });
-    const ready = await waitForServerReady(url, options.timeoutMs);
-    if (!ready) {
-      const tail = out.trim();
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-      throw new Error(`Dev server did not become ready at ${url} within ${options.timeoutMs}ms.
-${tail}`);
-    }
-    this.handle = {
-      child,
-      port,
-      url,
-      outputTail: () => out.trim()
-    };
-    logger.printSuccessLog(`Dev server ready at ${url}`);
-    return this.handle;
-  }
-  async stop() {
-    if (!this.handle) return;
-    const child = this.handle.child;
-    this.handle = null;
-    await new Promise((resolve2) => {
-      try {
-        child.once("close", () => resolve2());
-        child.kill("SIGTERM");
-      } catch {
-        resolve2();
-      }
-      setTimeout(() => resolve2(), 1500);
-    });
-  }
-  async restart(options = { timeoutMs: 6e4 }) {
-    await this.stop();
-    return await this.start(options);
-  }
-};
-
-// src/tools/launch-tool/index.ts
-function makeServerKey(appPath) {
-  const safeApp = appPath.split(path9.sep).join("_");
-  return `launch:${safeApp}`;
-}
-var _LaunchTool_decorators, _init7;
-_LaunchTool_decorators = [tools7({
-  startDevServer: {
-    description: "Start a dev server in-process and wait for it to become reachable.",
-    params: [
-      { name: "appPath", type: "string", description: "Absolute path to the app directory" },
-      { name: "runCommand", type: "string", description: 'Run command (e.g. "pnpm dev")' },
-      { name: "timeoutMs", type: "number", description: "Timeout in milliseconds", optional: true }
-    ],
-    returns: { type: "string", description: "JSON string containing StartDevServerResult with url/port/pid/serverKey." }
-  },
-  stopDevServer: {
-    description: "Stop a previously started dev server by serverKey.",
-    params: [{ name: "serverKey", type: "string", description: "Server key returned by startDevServer()" }],
-    returns: { type: "string", description: "JSON string containing StopDevServerResult" }
-  }
-})];
-var _LaunchTool = class _LaunchTool {
-  static serverManagers = /* @__PURE__ */ new Map();
-  /** Mutex per appPath so only one startDevServer runs at a time for a given app (avoids duplicate port logs). */
-  static inFlightStarts = /* @__PURE__ */ new Map();
-  async startDevServer(appPath, runCommand, timeoutMs = 6e4) {
-    const serverKey = makeServerKey(appPath);
-    const prev = _LaunchTool.inFlightStarts.get(appPath);
-    let resolveThis;
-    const thisRun = new Promise((r) => {
-      resolveThis = r;
-    });
-    _LaunchTool.inFlightStarts.set(appPath, thisRun);
-    await prev;
-    try {
-      const entry = _LaunchTool.serverManagers.get(serverKey);
-      if (entry) {
-        const handle2 = await entry.manager.restart({ timeoutMs });
-        const result2 = {
-          success: true,
-          serverKey,
-          url: handle2.url,
-          port: handle2.port,
-          pid: handle2.child.pid ?? void 0,
-          outputTail: handle2.outputTail()
-        };
-        return JSON.stringify(result2, null, 2);
-      }
-      const manager = new DevServerManager({ appPath, runCommand: runCommand.trim() });
-      const handle = await manager.start({ timeoutMs });
-      _LaunchTool.serverManagers.set(serverKey, { manager, appPath });
-      const result = {
-        success: true,
-        serverKey,
-        url: handle.url,
-        port: handle.port,
-        pid: handle.child.pid ?? void 0,
-        outputTail: handle.outputTail()
-      };
-      return JSON.stringify(result, null, 2);
-    } catch (error) {
-      const result = {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-      return JSON.stringify(result, null, 2);
-    } finally {
-      resolveThis();
-      _LaunchTool.inFlightStarts.delete(appPath);
-    }
-  }
-  async stopDevServer(serverKey) {
-    const entry = _LaunchTool.serverManagers.get(serverKey);
-    if (!entry) {
-      const result = { success: false, serverKey, error: `Unknown serverKey: ${serverKey}` };
-      return JSON.stringify(result, null, 2);
-    }
-    try {
-      await entry.manager.stop();
-      _LaunchTool.serverManagers.delete(serverKey);
-      const result = { success: true, serverKey };
-      return JSON.stringify(result, null, 2);
-    } catch (error) {
-      const result = {
-        success: false,
-        serverKey,
-        error: error instanceof Error ? error.message : String(error)
-      };
-      return JSON.stringify(result, null, 2);
-    }
-  }
-};
-_init7 = __decoratorStart(null);
-_LaunchTool = __decorateElement(_init7, 0, "LaunchTool", _LaunchTool_decorators, _LaunchTool);
-__runInitializers(_init7, 1, _LaunchTool);
-var LaunchTool = _LaunchTool;
-
-// src/nodes/validation/utils/extraction/extract-protocol-context.ts
-function extractValidationContext(protocol) {
-  const offset = extractOffset(protocol);
-  const elements = /* @__PURE__ */ new Map();
-  const components = /* @__PURE__ */ new Map();
-  const elementToComponent = /* @__PURE__ */ new Map();
-  const figmaPositions = {};
-  traverseProtocol(protocol, (node) => {
-    const componentInfo = {
-      id: node.id,
-      name: node.data.name,
-      path: node.data.componentPath ?? node.data.path ?? node.data.kebabName ?? node.id
-    };
-    components.set(node.id, componentInfo);
-    const hasChildren = Array.isArray(node.children) && node.children.length > 0;
-    const itemType = hasChildren ? "frame" : "component";
-    if (node.data.elements && Array.isArray(node.data.elements)) {
-      extractElementsRecursive(
-        node.data.elements,
-        componentInfo,
-        itemType,
-        elements,
-        elementToComponent,
-        figmaPositions,
-        offset
-      );
-    }
-  });
-  return { offset, elements, components, elementToComponent, figmaPositions };
-}
-function extractOffset(protocol) {
-  if (protocol.data.layout?.boundingBox) {
-    return {
-      x: protocol.data.layout.boundingBox.left,
-      y: protocol.data.layout.boundingBox.top
-    };
-  }
-  const firstElement = protocol.data.elements?.[0];
-  if (firstElement?.absoluteBoundingBox) {
-    return {
-      x: firstElement.absoluteBoundingBox.x,
-      y: firstElement.absoluteBoundingBox.y
-    };
-  }
-  return { x: 0, y: 0 };
-}
-function traverseProtocol(node, callback) {
-  callback(node);
-  if (node.children && Array.isArray(node.children)) {
-    for (const child of node.children) {
-      traverseProtocol(child, callback);
-    }
-  }
-}
-function extractElementsRecursive(elements, componentInfo, itemType, elementsMap, elementToComponent, figmaPositions, offset) {
-  for (const element of elements) {
-    if (!element || !element.id) continue;
-    const bbox = element.absoluteBoundingBox;
-    const position = bbox ? {
-      x: bbox.x - offset.x,
-      y: bbox.y - offset.y,
-      w: bbox.width,
-      h: bbox.height
-    } : { x: 0, y: 0, w: 0, h: 0 };
-    figmaPositions[element.id] = position;
-    elementsMap.set(element.id, {
-      id: element.id,
-      name: element.name,
-      type: element.type,
-      position,
-      layoutMode: element.layoutMode,
-      primaryAxisAlignItems: element.primaryAxisAlignItems,
-      counterAxisAlignItems: element.counterAxisAlignItems,
-      itemSpacing: element.itemSpacing,
-      paddingTop: element.paddingTop,
-      paddingRight: element.paddingRight,
-      paddingBottom: element.paddingBottom,
-      paddingLeft: element.paddingLeft,
-      constraints: element.constraints,
-      parentComponentId: componentInfo.id,
-      parentComponentName: componentInfo.name,
-      parentComponentPath: componentInfo.path,
-      parentItemType: itemType
-    });
-    elementToComponent.set(element.id, componentInfo);
-    if (element.children && Array.isArray(element.children)) {
-      extractElementsRecursive(element.children, componentInfo, itemType, elementsMap, elementToComponent, figmaPositions, offset);
-    }
-    if (element.frames && Array.isArray(element.frames)) {
-      extractElementsRecursive(element.frames, componentInfo, itemType, elementsMap, elementToComponent, figmaPositions, offset);
-    }
-  }
-}
-function extractComponentPaths(context, workspace) {
-  const paths = {};
-  for (const [id, info] of context.components) {
-    if (info.path) {
-      paths[id] = workspaceManager.resolveAppSrc(workspace, workspaceManager.resolveComponentPath(info.path));
-    }
-  }
-  return paths;
-}
-function toElementMetadataRegistry(context) {
-  const elements = /* @__PURE__ */ new Map();
-  for (const [id, element] of context.elements) {
-    elements.set(id, {
-      id: element.id,
-      name: element.name,
-      parentComponentId: element.parentComponentId,
-      parentComponentName: element.parentComponentName,
-      parentComponentPath: element.parentComponentPath,
-      parentItemType: element.parentItemType
-    });
-  }
-  return { elements, components: context.components };
-}
-
-// src/nodes/validation/core/validate-position.ts
-init_logger();
-
-// src/tools/position-tool/index.ts
-init_logger();
-import { tools as tools8 } from "evoltagent";
-
-// src/tools/position-tool/utils/capture-position.ts
-init_logger();
-
-// src/tools/position-tool/utils/position-metrics.ts
-function calculatePositionMetrics(positions) {
-  const positionValues = Object.values(positions);
-  const comparableItems = positionValues.filter((p) => p.metrics);
-  const comparableCount = comparableItems.length;
-  if (comparableCount === 0) {
-    return {
-      mae: 0,
-      mse: 0,
-      rmse: 0,
-      accurateItems: 0,
-      misalignedItems: 0,
-      comparableItems: 0,
-      accuracyRate: 0,
-      averageDistance: 0,
-      maxDistance: 0
-    };
-  }
-  const distances = comparableItems.map((p) => p.metrics.absoluteDistance);
-  const mae = distances.reduce((sum, d) => sum + d, 0) / comparableCount;
-  const mse = distances.reduce((sum, d) => sum + d * d, 0) / comparableCount;
-  const rmse = Math.sqrt(mse);
-  const maxDistance = Math.max(...distances);
-  const accurateItems = comparableItems.filter((p) => p.metrics.status === "accurate").length;
-  const misalignedItems = comparableItems.filter((p) => p.metrics.status === "misaligned").length;
-  const accuracyRate = comparableCount > 0 ? accurateItems / comparableCount * 100 : 0;
-  return {
-    mae: Math.round(mae * 100) / 100,
-    mse: Math.round(mse * 100) / 100,
-    rmse: Math.round(rmse * 100) / 100,
-    accurateItems,
-    misalignedItems,
-    comparableItems: comparableCount,
-    accuracyRate: Math.round(accuracyRate * 100) / 100,
-    averageDistance: Math.round(mae * 100) / 100,
-    maxDistance: Math.round(maxDistance * 100) / 100
-  };
-}
-
-// src/tools/position-tool/utils/capture-position.ts
-async function captureBrowserPositions(input) {
-  const url = input.url;
-  const timeout = input.timeout ?? DEFAULT_TIMEOUT;
-  const positionThreshold = input.positionThreshold ?? POSITION_THRESHOLD;
-  const errors = [];
-  let browser = null;
-  let page = null;
-  try {
-    const figmaPositions = input.validationContext.figmaPositions;
-    const designOffset = input.validationContext.offset;
-    const allElements = Array.from(input.elementRegistry.elements.values()).map((e) => ({
-      id: e.id,
-      name: e.name,
-      parentItemId: e.parentComponentId,
-      parentItemName: e.parentComponentName,
-      parentItemType: e.parentItemType
-    }));
-    let viewport = input.viewport ?? DEFAULT_VIEWPORT;
-    if (input.figmaThumbnailUrl && !input.viewport) {
-      const { fetchThumbnailDimensions: fetchThumbnailDimensions2 } = await Promise.resolve().then(() => (init_fetch_thumbnail_dimensions(), fetch_thumbnail_dimensions_exports));
-      const thumbnailDimensions = await fetchThumbnailDimensions2(input.figmaThumbnailUrl);
-      if (thumbnailDimensions) {
-        viewport = { width: thumbnailDimensions.width, height: thumbnailDimensions.height };
-        logger.printInfoLog(`Using viewport dimensions from Figma thumbnail: ${viewport.width}\xD7${viewport.height}px`);
-      } else {
-        logger.printWarnLog(`Using default viewport dimensions: ${viewport.width}\xD7${viewport.height}px`);
-      }
-    }
-    try {
-      browser = await launchChromiumWithAutoInstall({ headless: true });
-    } catch (launchError) {
-      throw new Error(`Failed to launch Playwright Chromium browser for position validation: ${launchError.message}`);
-    }
-    const context = await browser.newContext({ viewport });
-    page = await context.newPage();
-    try {
-      await page.goto(url, { waitUntil: "domcontentloaded", timeout });
-    } catch (error) {
-      throw new Error(`Failed to load ${url}. Make sure the development server is running. Error: ${error.message}`);
-    }
-    if (input.waitForSelector) {
-      try {
-        await page.waitForSelector(input.waitForSelector, { timeout: SELECTOR_WAIT_TIMEOUT });
-      } catch {
-        errors.push(`Warning: waitForSelector "${input.waitForSelector}" timed out`);
-      }
-    }
-    let screenshot;
-    if (input.returnScreenshot) {
-      try {
-        const buffer = await page.screenshot({ fullPage: true, type: "png" });
-        screenshot = `data:image/png;base64,${buffer.toString("base64")}`;
-      } catch (error) {
-        errors.push(`Warning: Failed to capture screenshot: ${error.message}`);
-      }
-    }
-    const positions = {};
-    let capturedCount = 0;
-    for (const element of allElements) {
-      try {
-        const escapedId = element.id.replace(/:/g, "\\:");
-        const selector = `[id="${escapedId}"]`;
-        const result = await page.evaluate((sel) => {
-          const el = document.querySelector(sel);
-          if (!el) return null;
-          const rect = el.getBoundingClientRect();
-          const style = window.getComputedStyle(el);
-          if (rect.width === 0 && rect.height === 0) {
-            return null;
-          }
-          return {
-            boundingBox: {
-              x: rect.x,
-              y: rect.y,
-              width: rect.width,
-              height: rect.height,
-              top: rect.top,
-              left: rect.left,
-              right: rect.right,
-              bottom: rect.bottom
-            },
-            computedStyle: {
-              position: style.position,
-              display: style.display,
-              top: style.top,
-              left: style.left,
-              right: style.right,
-              bottom: style.bottom,
-              transform: style.transform,
-              tagName: el.tagName.toLowerCase()
-            }
-          };
-        }, selector);
-        if (!result) {
-          errors.push(`Element ${element.id} not found in DOM or has no dimensions`);
-          continue;
-        }
-        const figmaPos = figmaPositions[element.id];
-        let metrics;
-        if (figmaPos) {
-          const xDelta = result.boundingBox.x - figmaPos.x;
-          const yDelta = result.boundingBox.y - figmaPos.y;
-          const xOffset = Math.abs(xDelta);
-          const yOffset = Math.abs(yDelta);
-          const absoluteDistance = Math.sqrt(xOffset ** 2 + yOffset ** 2);
-          metrics = {
-            xOffset: Math.round(xOffset * 100) / 100,
-            yOffset: Math.round(yOffset * 100) / 100,
-            xDelta: Math.round(xDelta * 100) / 100,
-            yDelta: Math.round(yDelta * 100) / 100,
-            absoluteDistance: Math.round(absoluteDistance * 100) / 100,
-            status: absoluteDistance <= positionThreshold ? "accurate" : "misaligned"
-          };
-        }
-        positions[element.id] = {
-          elementId: element.id,
-          elementName: element.name,
-          parentItemId: element.parentItemId,
-          parentItemName: element.parentItemName,
-          parentItemType: element.parentItemType,
-          boundingBox: {
-            x: Math.round(result.boundingBox.x * 100) / 100,
-            y: Math.round(result.boundingBox.y * 100) / 100,
-            width: Math.round(result.boundingBox.width * 100) / 100,
-            height: Math.round(result.boundingBox.height * 100) / 100,
-            top: Math.round(result.boundingBox.top * 100) / 100,
-            left: Math.round(result.boundingBox.left * 100) / 100,
-            right: Math.round(result.boundingBox.right * 100) / 100,
-            bottom: Math.round(result.boundingBox.bottom * 100) / 100
-          },
-          computedStyle: result.computedStyle,
-          figmaPosition: figmaPos ? { x: figmaPos.x, y: figmaPos.y, width: figmaPos.w, height: figmaPos.h } : void 0,
-          metrics
-        };
-        capturedCount++;
-      } catch (error) {
-        const errorMsg = `Failed to capture position for ${element.id}` + (element.name ? ` (${element.name})` : "") + ` in ${element.parentItemName || "unknown component"}: ${error.message}`;
-        errors.push(errorMsg);
-      }
-    }
-    const maeMetrics = calculatePositionMetrics(positions);
-    return {
-      metadata: {
-        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        totalItems: allElements.length,
-        capturedItems: capturedCount,
-        ...maeMetrics,
-        url,
-        viewport,
-        designOffset
-      },
-      positions,
-      errors,
-      screenshot
-    };
-  } finally {
-    if (page) {
-      await page.close().catch(() => {
-      });
-    }
-    if (browser) {
-      await browser.close().catch(() => {
-      });
-    }
-  }
-}
-
-// src/tools/position-tool/utils/aggregate-elements.ts
-function toRect(rectLike) {
-  return { x: rectLike.x, y: rectLike.y, width: rectLike.width, height: rectLike.height };
-}
-function calculateAggregateBoundingBox(rectangles) {
-  if (rectangles.length === 0) {
-    throw new Error("Cannot calculate bounding box from empty array");
-  }
-  const minX = Math.min(...rectangles.map((r) => r.x));
-  const minY = Math.min(...rectangles.map((r) => r.y));
-  const maxRight = Math.max(...rectangles.map((r) => r.x + r.width));
-  const maxBottom = Math.max(...rectangles.map((r) => r.y + r.height));
-  return {
-    minX,
-    minY,
-    maxRight,
-    maxBottom,
-    width: maxRight - minX,
-    height: maxBottom - minY
-  };
-}
-function calculatePositionError(current, target) {
-  const errorX = Math.abs(target.minX - current.minX);
-  const errorY = Math.abs(target.minY - current.minY);
-  const distance = Math.sqrt(errorX ** 2 + errorY ** 2);
-  return { errorX, errorY, distance };
-}
-function calculateComponentMetrics(compData, positionThreshold) {
-  if (compData.positions.length === 0 || compData.targets.length === 0) {
-    return null;
-  }
-  const currentBounds = calculateAggregateBoundingBox(compData.positions);
-  const targetBounds = calculateAggregateBoundingBox(compData.targets);
-  const error = calculatePositionError(currentBounds, targetBounds);
-  if (error.distance <= positionThreshold) {
-    return null;
-  }
-  return { currentBounds, targetBounds, error };
-}
-
-// src/tools/position-tool/index.ts
-var _PositionTool_decorators, _init8;
-_PositionTool_decorators = [tools8({
-  capturePosition: {
-    description: "Capture viewport-relative positions in the browser and compare to Figma absoluteBoundingBox, returning per-element deltas and metrics.",
-    params: [{ name: "input", type: "object", description: "BrowserPositionInput (figmaJSON, structure, url, etc.)" }],
-    returns: { type: "object", description: "PositionValidationOutput containing metadata, positions, and errors." }
-  },
-  aggregateElements: {
-    description: "Aggregate element-level rectangles into component-level bounds and return misaligned components based on aggregate distance threshold.",
-    params: [
-      { name: "positions", type: "object", description: "Positions keyed by elementId (from capturePosition)." },
-      {
-        name: "elementToComponentMap",
-        type: "object",
-        description: "Mapping from elementId -> {id,name,path} for parent component (built from structure tree)."
-      },
-      { name: "positionThreshold", type: "number", description: "Pixel threshold for aggregate distance." }
-    ],
-    returns: { type: "object", description: "AggregateElementsResult: misalignedComponents + skippedElements." }
-  },
-  computeMetrics: {
-    description: "Compute MAE/MSE/RMSE/accuracy metrics from element positions, and SAE from component misalignments.",
-    params: [
-      { name: "positions", type: "object", description: "Positions keyed by elementId (from capturePosition)." },
-      {
-        name: "misalignedComponents",
-        type: "object",
-        description: "Optional component misalignments (from aggregateElements) used to compute SAE.",
-        optional: true
-      }
-    ],
-    returns: { type: "object", description: "PositionToolMetrics (ValidationMetrics + sae)." }
-  }
-})];
-var PositionTool = class {
-  async capturePosition(input) {
-    return await captureBrowserPositions(input);
-  }
-  /**
-   * Deterministic in-process aggregation.
-   * NOTE: Map-based inputs are not JSON-friendly for future agent calls; we can add a JSON form later.
-   */
-  aggregateElements(positions, elementToComponentMap, positionThreshold) {
-    const componentMap = /* @__PURE__ */ new Map();
-    const skippedElements = [];
-    for (const [elementId, position] of Object.entries(positions)) {
-      if (!position.figmaPosition) {
-        skippedElements.push({
-          elementId,
-          reason: "no_figma_position",
-          details: "Element exists in render but has no corresponding Figma position data"
-        });
-        continue;
-      }
-      const component = elementToComponentMap.get(elementId);
-      if (!component) {
-        skippedElements.push({
-          elementId,
-          reason: "missing_component_mapping",
-          details: "Element has no component mapping in structure tree"
-        });
-        continue;
-      }
-      if (!componentMap.has(component.id)) {
-        componentMap.set(component.id, {
-          componentId: component.id,
-          componentName: component.name,
-          componentPath: component.path,
-          elementIds: [],
-          positions: [],
-          targets: [],
-          errors: []
-        });
-      }
-      const compData = componentMap.get(component.id);
-      compData.elementIds.push(elementId);
-      compData.positions.push(toRect(position.boundingBox));
-      compData.targets.push(toRect(position.figmaPosition));
-      compData.errors.push({
-        x: Math.abs(position.metrics?.xDelta ?? 0),
-        y: Math.abs(position.metrics?.yDelta ?? 0)
-      });
-    }
-    this.logSkippedElementsSummary(skippedElements);
-    const misalignedComponents = [];
-    for (const compData of componentMap.values()) {
-      if (compData.positions.length === 0 || compData.targets.length === 0) {
-        for (const elemId of compData.elementIds) {
-          skippedElements.push({
-            elementId: elemId,
-            reason: "incomplete_data",
-            details: `Component ${compData.componentName} has ${compData.positions.length} positions, ${compData.targets.length} targets`
-          });
-        }
-        continue;
-      }
-      const metrics = calculateComponentMetrics(compData, positionThreshold);
-      if (!metrics) {
-        continue;
-      }
-      const { currentBounds, targetBounds, error } = metrics;
-      misalignedComponents.push({
-        name: compData.componentName,
-        componentId: compData.componentId,
-        elementIds: compData.elementIds,
-        path: compData.componentPath,
-        validationReport: {
-          currentPosition: [currentBounds.minX, currentBounds.minY],
-          targetPosition: [targetBounds.minX, targetBounds.minY],
-          absoluteError: [error.errorX, error.errorY]
-        },
-        currentX: currentBounds.minX,
-        currentY: currentBounds.minY,
-        targetX: targetBounds.minX,
-        targetY: targetBounds.minY,
-        currentWidth: currentBounds.width,
-        currentHeight: currentBounds.height,
-        targetWidth: targetBounds.width,
-        targetHeight: targetBounds.height,
-        distance: error.distance
-      });
-    }
-    return { misalignedComponents, skippedElements };
-  }
-  computeMetrics(positions, misalignedComponents) {
-    const metrics = calculatePositionMetrics(positions);
-    const sae = misalignedComponents?.reduce((sum, comp) => {
-      const [errorX, errorY] = comp.validationReport.absoluteError;
-      return sum + errorX + errorY;
-    }, 0) ?? 0;
-    return { ...metrics, sae: Math.round(sae * 100) / 100 };
-  }
-  logSkippedElementsSummary(skippedElements) {
-    if (skippedElements.length === 0) {
-      return;
-    }
-    const byReason = {
-      missing_component_mapping: 0,
-      incomplete_data: 0,
-      no_figma_position: 0
-    };
-    for (const elem of skippedElements) {
-      byReason[elem.reason] += 1;
-    }
-    const summary = Object.entries(byReason).filter(([, count]) => count > 0).map(([reason, count]) => `${count} ${reason.replace(/_/g, " ")}`).join(", ");
-    const firstFew = skippedElements.slice(0, 3).map((e) => e.elementId).join(", ");
-    logger.printWarnLog(`Skipped ${skippedElements.length} element(s): ${summary}. First few: ${firstFew}`);
-  }
-};
-_init8 = __decoratorStart(null);
-PositionTool = __decorateElement(_init8, 0, "PositionTool", _PositionTool_decorators, PositionTool);
-__runInitializers(_init8, 1, PositionTool);
-
-// src/nodes/validation/core/validate-position.ts
-async function validatePositions(config) {
-  const { serverUrl, figmaThumbnailUrl, protocol, positionThreshold, validationContext, elementRegistry, resolvedComponentPaths } = config;
-  const positionTool = new PositionTool();
-  const captureResult = await positionTool.capturePosition({
-    protocol,
-    validationContext,
-    url: serverUrl,
-    figmaThumbnailUrl,
-    positionThreshold,
-    returnScreenshot: true,
-    elementRegistry
-  });
-  const resolvedElementToComponent = /* @__PURE__ */ new Map();
-  for (const [elementId, componentInfo] of validationContext.elementToComponent) {
-    const resolvedPath = resolvedComponentPaths[componentInfo.id] || componentInfo.path;
-    resolvedElementToComponent.set(elementId, {
-      id: componentInfo.id,
-      name: componentInfo.name,
-      path: resolvedPath
-    });
-  }
-  const aggregated = positionTool.aggregateElements(captureResult.positions, resolvedElementToComponent, positionThreshold);
-  const misalignedComponents = aggregated.misalignedComponents;
-  const skippedElements = aggregated.skippedElements;
-  const sae = misalignedComponents.reduce((sum, comp) => {
-    const [errorX, errorY] = comp.validationReport.absoluteError;
-    return sum + errorX + errorY;
-  }, 0);
-  logger.printInfoLog(`Found ${misalignedComponents.length} misaligned components`);
-  return {
-    mae: captureResult.metadata.mae,
-    sae,
-    misalignedComponents,
-    skippedElements,
-    viewport: captureResult.metadata.viewport,
-    screenshots: captureResult.screenshot ? {
-      renderSnap: captureResult.screenshot
-    } : void 0
-  };
-}
-
-// src/nodes/validation/core/validation-loop.ts
-function filterComponentsToFix(misaligned, positionThreshold) {
-  return misaligned.filter((comp) => {
-    const [errorX, errorY] = comp.validationReport.absoluteError;
-    return errorX > positionThreshold || errorY > positionThreshold;
-  });
-}
-function recordComponentPosition(comp, iteration, componentHistory) {
-  const history = componentHistory[comp.componentId] ?? [];
-  history.push({
-    iteration,
-    position: comp.validationReport.currentPosition,
-    error: comp.validationReport.absoluteError,
-    fixApplied: null
-  });
-  componentHistory[comp.componentId] = history;
-}
-async function refineComponent(comp, context) {
-  const { workspace, structureTree, componentPaths, componentHistory, validationContext, previousScreenshotPath } = context;
-  try {
-    const elementIds = Array.from(validationContext.elements.values()).filter((e) => e.parentComponentId === comp.componentId).map((e) => e.id);
-    const figmaMetadata = extractLayoutFromContext(validationContext, elementIds);
-    logger.printLog(`  Analyzing ${comp.name}...`);
-    const judger = createJudgerAgent({
-      workspaceDir: workspace.app,
-      structureTree,
-      componentPaths,
-      history: componentHistory
-    });
-    const judgerInstruction = formatJudgerInstruction(comp, figmaMetadata, componentPaths);
-    const judgerImages = previousScreenshotPath ? [previousScreenshotPath] : void 0;
-    const diagnosis = await judger.run(judgerInstruction, judgerImages);
-    logger.printLog(`     Error type: ${diagnosis.errorType}`);
-    logger.printLog(`     Fix instructions: ${diagnosis.refineInstructions?.length || 0}`);
-    if (!diagnosis.refineInstructions || diagnosis.refineInstructions.length === 0) {
-      const history2 = componentHistory[comp.componentId];
-      return {
-        componentId: comp.componentId,
-        componentPath: comp.path,
-        elementIds: comp.elementIds,
-        validationReport: comp.validationReport,
-        diagnosis,
-        refinerResult: {
-          success: false,
-          summary: ["Skipped - no instructions from judger"],
-          editsApplied: 0
-        },
-        positionHistory: history2 ? [...history2] : void 0
-      };
-    }
-    logger.printLog(`  Applying fixes to ${comp.name}...`);
-    const refiner = createRefinerAgent(workspace.app);
-    const refinerInstruction = formatRefinerInstruction(comp, diagnosis, componentPaths);
-    const refinerResult = await refiner.run(refinerInstruction);
-    if (refinerResult.success) {
-      logger.printSuccessLog(`${comp.name}: ${refinerResult.editsApplied} edits applied`);
-    } else {
-      logger.printWarnLog(`${comp.name}: ${refinerResult.editsApplied} edits applied`);
-    }
-    const history = componentHistory[comp.componentId];
-    const last = history?.at(-1);
-    if (last) {
-      last.fixApplied = refinerResult.summary;
-    }
-    return {
-      componentId: comp.componentId,
-      componentPath: comp.path,
-      elementIds: comp.elementIds,
-      validationReport: comp.validationReport,
-      diagnosis,
-      refinerResult,
-      positionHistory: history ? [...history] : void 0
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.printInfoLog(`${comp.name}: ${errorMsg}`);
-    const history = componentHistory[comp.componentId];
-    return {
-      componentId: comp.componentId,
-      componentPath: comp.path,
-      elementIds: comp.elementIds,
-      validationReport: comp.validationReport,
-      diagnosis: void 0,
-      refinerResult: void 0,
-      positionHistory: history ? [...history] : void 0
-    };
-  }
-}
-function saveProcessedJson(outputDir, processedOutput) {
-  const processedJsonPath = path10.join(outputDir, "processed.json");
-  fs7.writeFileSync(processedJsonPath, JSON.stringify(processedOutput, null, 2));
-  logger.printInfoLog("Saved processed.json");
-}
-async function performCommit(appPath, iteration, stage) {
-  const commitResult = await commit({ appPath, iteration });
-  if (!commitResult.success) {
-    logger.printWarnLog(`Git commit (${stage}) failed: ${commitResult.message}`);
-  } else if (iteration === void 0) {
-    logger.printSuccessLog(`Initial project committed successfully, starting validation loop...`);
-  }
-}
-function saveIterationAndProcessedJson(iterations, iteration, currentMae, currentSae, misalignedCount, components, screenshotPath, skippedElements, outputDir, targetMae) {
-  iterations.push({
-    iteration,
-    metrics: { mae: currentMae, sae: currentSae, misalignedCount },
-    components,
-    screenshotPath,
-    skippedElements: skippedElements && skippedElements.length > 0 ? skippedElements : void 0
-  });
-  const processedOutput = {
-    iterations,
-    finalResult: {
-      success: currentMae <= targetMae,
-      finalMae: currentMae,
-      finalSae: currentSae,
-      totalIterations: iterations.length,
-      misalignedCount
-    }
-  };
-  saveProcessedJson(outputDir, processedOutput);
-}
-async function validationLoop(params) {
-  const { protocol, figmaThumbnailUrl, outputDir, workspace } = params;
-  if (!protocol || !figmaThumbnailUrl || !outputDir || !workspace) {
-    throw new Error("Something wrong in validation loop, missing required parameters...");
-  }
-  const config = {
-    ...DEFAULT_VALIDATION_LOOP_CONFIG,
-    ...params.config
-  };
-  const mode = config.mode ?? "full";
-  const maxIterations = mode === "reportOnly" ? 1 : config.maxIterations;
-  const visualizationTool = new VisualizationTool();
-  let currentServerUrl;
-  let serverKey;
-  try {
-    const validationContext = extractValidationContext(protocol);
-    const designOffset = [validationContext.offset.x, validationContext.offset.y];
-    if (Math.abs(designOffset[0]) >= 1 || Math.abs(designOffset[1]) >= 1) {
-      logger.printInfoLog(`Design offset: (${designOffset[0].toFixed(0)}, ${designOffset[1].toFixed(0)} px)`);
-    }
-    const resolvedComponentPaths = extractComponentPaths(validationContext, workspace);
-    const elementRegistry = toElementMetadataRegistry(validationContext);
-    logger.printInfoLog("Downloading Figma thumbnail (will be cached for all iterations)...");
-    const cachedFigmaThumbnailBase64 = await downloadImage(figmaThumbnailUrl, void 0, void 0, true);
-    logger.printSuccessLog("Figma thumbnail cached successfully");
-    const iterations = [];
-    const componentHistory = {};
-    let previousScreenshotPath;
-    let currentMae = -1;
-    let currentSae = 0;
-    let lastMisalignedCount = 0;
-    let lastValidationResult;
-    let lastRenderMarkedPath;
-    let lastTargetMarkedPath;
-    for (let iteration = 1; iteration <= maxIterations; iteration++) {
-      if (mode === "reportOnly") {
-        logger.printLog(`
-${"=".repeat(60)}`);
-        logger.printLog(`Running validation (report-only mode)`);
-        logger.printLog(`${"=".repeat(60)}`);
-      } else {
-        logger.printLog(`
-${"=".repeat(60)}`);
-        logger.printLog(`Iteration ${iteration}/${maxIterations}`);
-        logger.printLog(`${"=".repeat(60)}`);
-      }
-      if (iteration === 1) {
-        logger.printInfoLog("Initial launch: installing dependencies, building, fixing errors...");
-        const launchResult2 = await launch(workspace.app, {
-          skipDependencyInstall: false
-        });
-        if (!launchResult2.success) {
-          throw new Error(`Initial launch failed: ${launchResult2.error}`);
-        }
-        currentServerUrl = launchResult2.url;
-        serverKey = launchResult2.serverKey;
-        logger.printSuccessLog(`Dev server ready at ${currentServerUrl}`);
-        if (mode === "reportOnly") {
-          await performCommit(workspace.app, void 0, "initial state");
-        }
-      }
-      const validationResult = await validatePositions({
-        serverUrl: currentServerUrl,
-        figmaThumbnailUrl,
-        protocol,
-        iteration,
-        positionThreshold: config.positionThreshold,
-        designOffset,
-        outputDir,
-        validationContext,
-        elementRegistry,
-        cachedFigmaThumbnailBase64,
-        resolvedComponentPaths
-      });
-      lastValidationResult = validationResult;
-      currentMae = validationResult.mae;
-      currentSae = validationResult.sae;
-      const misaligned = validationResult.misalignedComponents;
-      lastMisalignedCount = misaligned.length;
-      logger.printLog(`MAE: ${currentMae.toFixed(2)}px (target: <=${config.targetMae}px)`);
-      logger.printLog(`SAE: ${currentSae.toFixed(2)}px`);
-      logger.printLog(`Misaligned: ${misaligned.length}`);
-      const screenshotResult = await visualizationTool.generateIterationScreenshot(
-        misaligned,
-        currentServerUrl,
-        figmaThumbnailUrl,
-        validationResult.viewport,
-        { x: designOffset[0], y: designOffset[1] },
-        path10.join(outputDir, "comparison_screenshots", `iteration_${iteration}.webp`),
-        cachedFigmaThumbnailBase64
-      );
-      if (screenshotResult.renderMarked && screenshotResult.targetMarked) {
-        const comparisonDir = path10.join(outputDir, "comparison_screenshots");
-        lastRenderMarkedPath = path10.join(comparisonDir, `iteration_${iteration}_render_marked.webp`);
-        lastTargetMarkedPath = path10.join(comparisonDir, `iteration_${iteration}_target_marked.webp`);
-        const sharp5 = (await import("sharp")).default;
-        await sharp5(Buffer.from(screenshotResult.renderMarked.split(",")[1], "base64")).toFile(lastRenderMarkedPath);
-        await sharp5(Buffer.from(screenshotResult.targetMarked.split(",")[1], "base64")).toFile(lastTargetMarkedPath);
-      }
-      const comparisonScreenshotPath = screenshotResult.combinedPath;
-      previousScreenshotPath = comparisonScreenshotPath;
-      const misalignedToFix = filterComponentsToFix(misaligned, config.positionThreshold);
-      if (mode === "reportOnly") {
-      } else {
-        logger.printInfoLog(
-          `Skipping ${misaligned.length - misalignedToFix.length} components with error <= ${config.positionThreshold}px`
-        );
-      }
-      for (const comp of misalignedToFix) {
-        recordComponentPosition(comp, iteration, componentHistory);
-      }
-      const componentLogs = [];
-      if (mode === "reportOnly") {
-        logger.printInfoLog("Report-only mode: skipping component refinement, saving validation report...");
-        saveIterationAndProcessedJson(
-          iterations,
-          iteration,
-          currentMae,
-          currentSae,
-          misaligned.length,
-          componentLogs,
-          comparisonScreenshotPath,
-          validationResult.skippedElements,
-          outputDir,
-          config.targetMae
-        );
-        break;
-      }
-      if (currentMae <= config.targetMae) {
-        logger.printSuccessLog("Validation passed!");
-        saveIterationAndProcessedJson(
-          iterations,
-          iteration,
-          currentMae,
-          currentSae,
-          misaligned.length,
-          componentLogs,
-          comparisonScreenshotPath,
-          validationResult.skippedElements,
-          outputDir,
-          config.targetMae
-        );
-        if (serverKey) {
-          await performCommit(workspace.app, iteration, `iteration ${iteration}`);
-        }
-        break;
-      }
-      logger.printInfoLog(`Refining ${misalignedToFix.length} components...`);
-      const refinementContext = {
-        workspace,
-        structureTree: protocol,
-        componentPaths: resolvedComponentPaths,
-        componentHistory,
-        validationContext,
-        previousScreenshotPath
-      };
-      for (const comp of misalignedToFix) {
-        const log = await refineComponent(comp, refinementContext);
-        componentLogs.push(log);
-      }
-      logger.printInfoLog("Re-launching dev server after refiner changes...");
-      const launchTool = new LaunchTool();
-      await launchTool.stopDevServer(serverKey).catch(() => {
-        logger.printWarnLog("Failed to stop previous server");
-      });
-      const launchResult = await launch(workspace.app, {
-        skipDependencyInstall: true
-      });
-      if (!launchResult.success) {
-        throw new Error(`Launch failed after refiner at iteration ${iteration}: ${launchResult.error}`);
-      }
-      currentServerUrl = launchResult.url;
-      serverKey = launchResult.serverKey;
-      logger.printSuccessLog(`Dev server restarted at ${currentServerUrl}`);
-      if (mode === "full") {
-        await performCommit(workspace.app, iteration, `iteration ${iteration}`);
-      }
-      saveIterationAndProcessedJson(
-        iterations,
-        iteration,
-        currentMae,
-        currentSae,
-        misaligned.length,
-        componentLogs,
-        comparisonScreenshotPath,
-        validationResult.skippedElements,
-        outputDir,
-        config.targetMae
-      );
-      logger.printInfoLog(`Iteration ${iteration} complete
-`);
-    }
-    const validationPassed = currentMae <= config.targetMae;
-    if (!validationPassed) {
-      if (mode === "reportOnly") {
-        logger.printWarnLog(
-          `Validation did not satisfy MAE threshold (${config.targetMae}px) in report-only mode. Final MAE: ${currentMae.toFixed(2)}px`
-        );
-      } else {
-        logger.printWarnLog(
-          `Max iterations (${maxIterations}) reached without satisfying MAE threshold (${config.targetMae}px). Final MAE: ${currentMae.toFixed(2)}px`
-        );
-      }
-    }
-    const finalOutput = {
-      iterations,
-      finalResult: {
-        success: validationPassed,
-        finalMae: currentMae,
-        finalSae: currentSae,
-        totalIterations: iterations.length,
-        misalignedCount: lastMisalignedCount
-      }
-    };
-    if (!currentServerUrl || !serverKey) {
-      throw new Error("Server was not launched properly during validation");
-    }
-    try {
-      if (!lastValidationResult) {
-        throw new Error("No validation results available for report generation");
-      }
-      if (!lastRenderMarkedPath || !lastTargetMarkedPath) {
-        throw new Error("No saved screenshots available for report generation");
-      }
-      const reportResult = await report({
-        validationResult: lastValidationResult,
-        figmaThumbnailUrl,
-        cachedFigmaThumbnailBase64,
-        designOffset: { x: designOffset[0], y: designOffset[1] },
-        outputDir,
-        serverUrl: currentServerUrl,
-        savedRenderMarkedPath: lastRenderMarkedPath,
-        savedTargetMarkedPath: lastTargetMarkedPath
-      });
-      finalOutput.finalResult.misalignedCount = lastValidationResult.misalignedComponents.length;
-      saveProcessedJson(outputDir, finalOutput);
-      return {
-        reportGenerated: reportResult.success,
-        validationPassed,
-        finalMae: currentMae,
-        finalSae: currentSae,
-        totalIterations: iterations.length,
-        processedOutput: finalOutput,
-        userReport: reportResult.userReport
-      };
-    } catch (screenshotError) {
-      const errorMsg = screenshotError instanceof Error ? screenshotError.message : String(screenshotError);
-      logger.printWarnLog(`Failed to generate final report: ${errorMsg}. Returning minimal report.`);
-      saveProcessedJson(outputDir, finalOutput);
-      return {
-        reportGenerated: false,
-        validationPassed,
-        finalMae: currentMae,
-        finalSae: currentSae,
-        totalIterations: iterations.length,
-        processedOutput: finalOutput,
-        userReport: {
-          design: { snap: figmaThumbnailUrl, markedSnap: "" },
-          page: { url: currentServerUrl, snap: "", markedSnap: "" },
-          report: {
-            heatmap: "",
-            detail: {
-              metrics: { mae: currentMae, sae: currentSae, misalignedCount: lastMisalignedCount },
-              components: []
-            }
-          }
-        }
-      };
-    }
-  } finally {
-    if (serverKey) {
-      logger.printInfoLog("Cleaning up dev server...");
-      const launchTool = new LaunchTool();
-      await launchTool.stopDevServer(serverKey).catch((err) => {
-        logger.printWarnLog(`Failed to stop dev server: ${err instanceof Error ? err.message : String(err)}`);
-      });
-    }
-  }
-}
-
-// src/nodes/validation/index.ts
-var runValidation = async (state) => {
-  if (!state.protocol) {
-    throw new Error("No protocol found for validation (state.protocol is missing).");
-  }
-  if (!state.figmaInfo?.thumbnail) {
-    throw new Error("Missing Figma thumbnail URL (state.figmaInfo.thumbnail is missing).");
-  }
-  const mode = state.config?.validationMode ?? "full";
-  if (mode === "codeOnly") {
-    logger.printInfoLog("Code-only mode: skipping validation, committing generated code...");
-    const commitResult = await commit({ appPath: state.workspace.app });
-    if (!commitResult.success) {
-      logger.printWarnLog(`Git commit failed: ${commitResult.message}`);
-    } else {
-      logger.printSuccessLog("Git commit completed successfully!");
-    }
-    return;
-  }
-  const outputDir = path11.join(state.workspace.process, "validation");
-  if (!fs8.existsSync(outputDir)) {
-    fs8.mkdirSync(outputDir, { recursive: true });
-  }
-  logger.printInfoLog(`Starting validation loop (mode: ${mode})...`);
-  const result = await validationLoop({
-    protocol: state.protocol,
-    figmaThumbnailUrl: state.figmaInfo.thumbnail,
-    outputDir,
-    workspace: state.workspace,
-    config: { mode }
-  });
-  if (result.error) {
-    throw new Error(result.error);
-  }
-  const reportHtmlPath = path11.join(outputDir, "index.html");
-  if (result.validationPassed) {
-    logger.printSuccessLog(`Validation PASSED (MAE: ${result.finalMae.toFixed(METRIC_DECIMAL_PLACES)}px)`);
-  } else {
-    logger.printWarnLog(`Validation FAILED (MAE: ${result.finalMae.toFixed(METRIC_DECIMAL_PLACES)}px)`);
-  }
-  logger.printInfoLog(`Validation report: ${reportHtmlPath}`);
-};
-
-// src/utils/url-parser.ts
-var parseFigmaUrl = (url) => {
-  let fileId = null;
-  let name = "untitled";
-  let nodeId = null;
-  try {
-    const urlObj = new URL(decodeURIComponent(url));
-    const pathParts = urlObj.pathname.split("/").filter(Boolean);
-    if (pathParts.length >= 3) {
-      fileId = pathParts[pathParts.length - 2] || null;
-      const fileName = pathParts[pathParts.length - 1];
-      name = fileName ? encodeURI(fileName).toLowerCase() : "untitled";
-      name = name.length > 20 ? name.substring(0, 20) : name;
-    }
-    nodeId = urlObj.searchParams.get("node-id") || null;
-    nodeId = nodeId ? nodeId.replace(/-/g, ":") : null;
-  } catch {
-  }
-  if (!fileId || !nodeId) {
-    throw new Error("Invalid Figma URL");
-  }
-  return { fileId, name, nodeId, projectName: `${name}_${nodeId}` };
-};
-
-// src/nodes/code/index.ts
-init_logger();
-
-// src/nodes/code/utils.ts
-init_logger();
-import fs10 from "fs";
-
-// src/nodes/code/prompt.ts
-var STYLING_GUIDELINES = `
-      - **Style Consistency**: Implement styles using the technical stack and libraries listed in <styling>.
-      - **Strict Restriction**: Absolutely ONLY use the technical stack and libraries listed in <styling>. Do NOT use any other styling methods, libraries, or frameworks (e.g., if clsx is not listed, do not use clsx).
-      - **Default Styling**: If <styling> is empty or does not contain specific libraries, DEFAULT to standard vanilla CSS.
-      
-      - **Tailwind CSS + CSS Modules (CRITICAL)**:
-        - If the stack includes BOTH Tailwind and CSS Modules (Less/SCSS), use them correctly:
-          1. **Tailwind utilities**: Use DIRECTLY in JSX className (e.g., \`className="flex items-center gap-4"\`)
-          2. **CSS Modules**: Use ONLY for complex styles that can't be expressed with Tailwind utilities (e.g., gradients, animations, pseudo-elements)
-          3. **NEVER use \`@apply\` in CSS Module files** - it's a Tailwind-specific directive that doesn't work in Less/SCSS
-          4. Example correct usage:
-             TSX: \`<div className={\`flex \${styles.customGradient}\`}>\`
-             Less: \`.customGradient { background: linear-gradient(...); }\`
-      
-      - **CSS Modules Only**: If the tech stack specifies CSS Modules without Tailwind:
-        1. Create a corresponding style file (e.g., \`index.module.less\`, \`index.module.scss\`, or \`index.module.css\`)
-        2. Import it as \`import styles from './index.module.[ext]';\` in the TSX
-        3. Define all styles in the style file using standard CSS/Less/SCSS syntax
-        4. Use \`styles.className\` in JSX`;
-var ASSETS_HANDLING = `
-      - **CRITICAL**: For any image URL starting with \`@/assets\`, you MUST import it at the top of the file.
-      - **Asset Name Matching**: 
-        - Check the \`<available_assets>\` list for actual filenames in the project.
-        - Asset filenames follow the pattern: \`kebab-case-name-id1-id2.ext\` (e.g., "Star 2.svg" \u2192 "star-2-1-2861.svg")
-        - Match the base name (ignoring spaces, case, and ID suffix): "@/assets/arXiv.svg" \u2192 look for "arxiv-*.svg" in the list
-        - Use the EXACT filename from the available assets list in your import.
-      - Example: If available_assets contains "arxiv-1-2956.svg", use:
-        \`import ArXivIcon from '@/assets/arxiv-1-2956.svg';\`
-      - **Usage**: \`<img src={ArXivIcon} />\`, do not use backgroundImage property.
-      - **NEVER** use the string path directly in JSX or styles.`;
-var DOM_IDS_REQUIREMENT = `
-      - Assign \`id\` attributes to the main container and any internal elements, matching \`frame_details\`.`;
-var REACT_IMPORT_RULE = `
-      - Do **NOT** include \`import React from 'react';\` at the top of the file.`;
-var FILE_NAMING_CONVENTION = `
-      - ALWAYS name the main component file \`index.tsx\`.
-      - ALWAYS name the style file (if applicable) \`index.module.[css|less|scss]\`.
-      - NEVER use PascalCase or other names for filenames (e.g., DO NOT use \`MainFrame.tsx\` or \`Button.tsx\`).`;
-var OUTPUT_FORMAT = `
-  <output_format>
-    If only one file (TSX) is needed:
-    \`\`\`tsx
-    // code...
-    \`\`\`
-
-    If multiple files are needed (e.g., TSX + Styles):
-    ## index.tsx
-    \`\`\`tsx
-    // code...
-    \`\`\`
+    If multiple files are needed (e.g., TSX + Styles):
+    ## index.tsx
+    \`\`\`tsx
+    // code...
+    \`\`\`
 
     ## index.module.[css|less|scss]
     \`\`\`[css|less|scss]
@@ -5851,72 +2135,6 @@ ${OUTPUT_FORMAT}
 </system_instructions>
 `.trim();
 };
-var injectRootComponentPrompt = ({
-  appContent,
-  componentName,
-  componentPath
-}) => {
-  return `
-<system_instructions>
-  <role>
-    You are a React code refactoring expert.
-    Your task is to inject a root component into an existing App.tsx file with minimal changes.
-  </role>
-
-  <input_context>
-    <current_app_content>
-${appContent}
-    </current_app_content>
-    <component_to_inject>
-      - Component Name: ${componentName}
-      - Import Path: ${componentPath}
-    </component_to_inject>
-  </input_context>
-
-  <requirements>
-    <req_1>
-      **Import Statement**:
-      - Add the import statement at the top of the file: \`import ${componentName} from '${componentPath}';\`
-      - Place it after existing imports, before the component definition.
-      - Do NOT remove or modify existing imports.
-    </req_1>
-
-    <req_2>
-      **Component Rendering**:
-      - Inside the App component's return statement, replace the existing content with \`<${componentName} />\`.
-      - If the return contains a wrapper div or other container, keep it and place the component inside.
-      - Preserve any existing className, styles, or other attributes on wrapper elements.
-    </req_2>
-
-    <req_3>
-      **Preserve Existing Code**:
-      - Keep all existing imports (CSS, Less, etc.)
-      - Preserve any hooks, state, or logic inside the App component
-      - Maintain the component structure and export statement
-      - Do NOT add comments or explanatory text
-    </req_3>
-
-    <req_4>
-      **Minimal Changes**:
-      - Only add the necessary import and render the component
-      - Do NOT refactor or optimize existing code
-      - Do NOT change formatting or styling unless necessary
-      - Do NOT add TypeScript types unless they already exist
-    </req_4>
-
-    <req_5>
-      **React Import**:
-${REACT_IMPORT_RULE}
-    </req_5>
-  </requirements>
-
-  <output_format>
-    Return ONLY the complete updated App.tsx code without markdown code blocks or explanation.
-    The output should be valid TypeScript/React code that can be directly written to the file.
-  </output_format>
-</system_instructions>
-`.trim();
-};
 
 // src/nodes/code/constants.ts
 var DEFAULT_STYLING = {
@@ -5932,124 +2150,14 @@ var DEFAULT_STYLING = {
     }
   ]
 };
-var DEFAULT_APP_CONTENT = `function App() {
-    return (
-        <div>
-            {/* Component will be injected here */}
-        </div>
-    );
-}
-
-export default App;`;
 
 // src/nodes/code/utils.ts
-import path12 from "path";
+import path4 from "path";
 
 // src/utils/code-cache.ts
-init_logger();
-import fs9 from "fs";
-function getCachePath(workspace) {
-  return workspace.checkpoint;
-}
-function loadCodeCache(workspace) {
-  const cachePath = getCachePath(workspace);
-  try {
-    if (!fs9.existsSync(cachePath)) {
-      logger.printInfoLog("No code cache found, starting fresh");
-      return createEmptyCache();
-    }
-    const content = fs9.readFileSync(cachePath, "utf-8");
-    const cache = JSON.parse(content);
-    if (!Array.isArray(cache.generatedComponents) || typeof cache.appInjected !== "boolean") {
-      logger.printWarnLog("Invalid cache format, starting fresh");
-      return createEmptyCache();
-    }
-    logger.printInfoLog(`Loaded code cache: ${cache.generatedComponents.length} components cached`);
-    return cache;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.printWarnLog(`Failed to load code cache: ${errorMessage}. Starting fresh.`);
-    return createEmptyCache();
-  }
-}
-function saveCodeCache(workspace, cache) {
-  const cachePath = getCachePath(workspace);
-  try {
-    if (!fs9.existsSync(workspace.process)) {
-      fs9.mkdirSync(workspace.process, { recursive: true });
-    }
-    const content = JSON.stringify(cache, null, 2);
-    fs9.writeFileSync(cachePath, content, "utf-8");
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.printWarnLog(`Failed to save code cache: ${errorMessage}`);
-  }
-}
-function isComponentGenerated(cache, nodeId) {
-  return cache.generatedComponents.includes(nodeId);
-}
-function markComponentGenerated(cache, nodeId) {
-  if (!isComponentGenerated(cache, nodeId)) {
-    cache.generatedComponents.push(nodeId);
-  }
-}
-function saveComponentGenerated(cache, nodeId, workspace) {
-  markComponentGenerated(cache, nodeId);
-  saveCodeCache(workspace, cache);
-}
-function isAppInjected(cache) {
-  return cache.appInjected;
-}
-function markAppInjected(cache) {
-  cache.appInjected = true;
-}
-function saveAppInjected(cache, workspace) {
-  markAppInjected(cache);
-  saveCodeCache(workspace, cache);
-}
-function createEmptyCache() {
-  return {
-    generatedComponents: [],
-    appInjected: false
-  };
-}
+import fs4 from "fs";
 
 // src/nodes/code/utils.ts
-async function processNode(state, cache) {
-  const assetFilesList = getAssetFilesList(state);
-  const flatNodes = flattenPostOrder(state.protocol);
-  const total = flatNodes.length;
-  if (total === 0) {
-    logger.printWarnLog("No components found in structure to generate.");
-    return 0;
-  }
-  logger.printInfoLog(`Processing ${total} nodes...`);
-  let processedCount = 0;
-  let skippedCount = 0;
-  const processSingleNode = async (currentNode) => {
-    const componentName = currentNode.data.name || currentNode.data.componentName || "UnknownComponent";
-    const nodeId = currentNode.id;
-    if (isComponentGenerated(cache, nodeId)) {
-      skippedCount++;
-      logger.printInfoLog(`[${processedCount + skippedCount}/${total}] \u23ED\uFE0F  Skipping (cached): ${componentName}`);
-      return;
-    }
-    const progressInfo = `[${++processedCount + skippedCount}/${total}]`;
-    const isLeaf = !currentNode.children?.length;
-    if (isLeaf) {
-      await generateComponent(currentNode, state, assetFilesList, progressInfo);
-    } else {
-      await generateFrame(currentNode, state, assetFilesList, progressInfo);
-    }
-    saveComponentGenerated(cache, nodeId, state.workspace);
-  };
-  await promisePool(flatNodes, processSingleNode);
-  if (skippedCount > 0) {
-    logger.printInfoLog(`\u23ED\uFE0F  Skipped ${skippedCount} cached components`);
-  }
-  logger.printSuccessLog(`Generated ${processedCount} components`);
-  return processedCount;
-}
 function flattenPostOrder(node) {
   const result = [];
   function traverse(n) {
@@ -6069,221 +2177,44 @@ function detectRenderingModes(node) {
   });
   return { hasStates, hasIndependentChildren };
 }
-async function generateFrame(node, state, assetFilesList, progressInfo) {
-  const frameName = node.data.name;
-  logger.printInfoLog(`${progressInfo} \u{1F5BC}\uFE0F  Generating Frame: ${frameName}`);
-  const childrenImports = (node.children || []).map((child) => ({
-    name: child.data.name || "",
-    path: child.data.path
-  }));
-  const renderingModes = detectRenderingModes(node);
-  const prompt = generateFramePrompt({
-    frameDetails: JSON.stringify(node.data),
-    childrenImports: JSON.stringify(childrenImports),
-    styling: JSON.stringify(DEFAULT_STYLING),
-    assetFiles: assetFilesList,
-    renderingModes
-  });
-  const code = await callModel({
-    question: prompt,
-    imageUrls: state.figmaInfo.thumbnail
-  });
-  const componentPath = node.data.path || "";
-  const filePath = workspaceManager.resolveAppSrc(state.workspace, workspaceManager.resolveComponentPath(componentPath));
-  saveGeneratedCode(code, filePath);
-  logger.printSuccessLog(`Successfully generated frame: ${frameName}`);
-}
-async function generateComponent(node, state, assetFilesList, progressInfo) {
-  const componentName = node.data.componentName || node.data.name || "UnknownComponent";
-  const componentPath = node.data.componentPath || node.data.path || "";
-  logger.printInfoLog(`${progressInfo} \u{1F4E6} Generating Component: ${componentName}`);
-  const prompt = generateComponentPrompt({
-    componentName,
-    componentDetails: JSON.stringify(node.data),
-    styling: JSON.stringify(DEFAULT_STYLING),
-    assetFiles: assetFilesList
-  });
-  const code = await callModel({
-    question: prompt,
-    imageUrls: state.figmaInfo.thumbnail
-  });
-  const filePath = workspaceManager.resolveAppSrc(state.workspace, workspaceManager.resolveComponentPath(componentPath));
-  saveGeneratedCode(code, filePath);
-  logger.printSuccessLog(`Successfully generated component: ${componentName}`);
-}
 function saveGeneratedCode(code, filePath) {
   const files = extractFiles(code);
   if (files.length > 0) {
     createFiles({ files, filePath });
   } else {
     const extractedCode = extractCode(code);
-    const folderPath = path12.dirname(filePath);
-    const fileName = path12.basename(filePath);
+    const folderPath = path4.dirname(filePath);
+    const fileName = path4.basename(filePath);
     writeFile(folderPath, fileName, extractedCode);
   }
 }
-function getAssetFilesList(state) {
-  try {
-    const assetsDir = workspaceManager.resolveAppSrc(state.workspace, "assets");
-    if (!fs10.existsSync(assetsDir)) {
-      return "";
-    }
-    const files = fs10.readdirSync(assetsDir);
-    return files.join(", ");
-  } catch {
-    return "";
-  }
-}
-async function injectRootComponentToApp(state, cache) {
-  try {
-    if (isAppInjected(cache)) {
-      logger.printInfoLog("\u23ED\uFE0F  Skipping App.tsx injection (already injected)");
-      return;
-    }
-    logger.printInfoLog("\u{1F489} Injecting root component into App.tsx...");
-    const appTsxPath = workspaceManager.resolveAppSrc(state.workspace, "App.tsx");
-    let appContent;
-    try {
-      appContent = fs10.readFileSync(appTsxPath, "utf8");
-    } catch {
-      logger.printWarnLog("App.tsx not found, using default template");
-      appContent = DEFAULT_APP_CONTENT;
-    }
-    const rootNode = state.protocol;
-    const componentName = rootNode.data.name || "RootComponent";
-    const componentPath = rootNode.data.path || "";
-    const prompt = injectRootComponentPrompt({
-      appContent,
-      componentName,
-      componentPath
-    });
-    const updatedCode = await callModel({
-      question: prompt
-    });
-    const finalCode = updatedCode.includes("```") ? extractCode(updatedCode) : updatedCode.trim();
-    const appFolderPath = path12.dirname(appTsxPath);
-    writeFile(appFolderPath, "App.tsx", finalCode);
-    saveAppInjected(cache, state.workspace);
-    logger.printSuccessLog(`Successfully injected ${componentName} into App.tsx`);
-  } catch (error) {
-    logger.printErrorLog(`Failed to inject root component: ${error.message}`);
-  }
-}
-
-// src/nodes/code/index.ts
-async function generateCode(state) {
-  try {
-    logger.printInfoLog("\u{1F680} Starting Code Generation...");
-    if (!state.protocol) {
-      throw new Error("No protocol data found");
-    }
-    const cache = loadCodeCache(state.workspace);
-    const totalComponents = await processNode(state, cache);
-    await injectRootComponentToApp(state, cache);
-    logger.printSuccessLog(`\u2728 Code generation completed! Generated ${totalComponents} components`);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Code generation failed: ${errorMessage}`);
-  }
-}
-
-// src/utils/checkpoint.ts
-init_logger();
-import fs11 from "fs";
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-
-// src/cli/prompts.ts
-init_logger();
-import prompts from "prompts";
-async function typedPrompt(config) {
-  return prompts(config, {
-    onCancel: () => {
-      logger.printWarnLog("Operation cancelled by user.");
-      process.exit(0);
-    }
-  });
-}
-async function promptUserChoice() {
-  const response = await typedPrompt({
-    type: "select",
-    name: "choice",
-    message: "What would you like to do?",
-    choices: [
-      { title: "Resume from cache", value: "resume" },
-      { title: "Start fresh (will clear existing cache)", value: "fresh" }
-    ],
-    initial: 0
-  });
-  return response.choice || "resume";
-}
-
-// src/utils/checkpoint.ts
-async function checkpointExists(checkpointer, threadId) {
-  try {
-    const checkpoints = checkpointer.list({ configurable: { thread_id: threadId } }, { limit: 1 });
-    const firstCheckpoint = await checkpoints.next();
-    return !firstCheckpoint.done && firstCheckpoint.value !== void 0;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.printTestLog(`Error checking checkpoint: ${errorMessage}`);
-    return false;
-  }
-}
-async function promptCheckpointChoice(checkpointer, threadId) {
-  const hasCheckpoint = await checkpointExists(checkpointer, threadId);
-  if (!hasCheckpoint) {
-    return void 0;
-  }
-  const choice = await promptUserChoice();
-  return choice === "resume";
-}
-function initializeSqliteSaver(dbPath) {
-  const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
-  if (!fs11.existsSync(dbDir)) {
-    fs11.mkdirSync(dbDir, { recursive: true });
-  }
-  const checkpointer = SqliteSaver.fromConnString(dbPath);
-  return checkpointer;
-}
-
-// src/graph.ts
-init_logger();
-async function design2code(url, mode) {
-  const urlInfo = parseFigmaUrl(url);
-  const threadId = urlInfo.projectName;
-  const workspace = workspaceManager.initWorkspace(threadId);
-  let checkpointer = initializeSqliteSaver(workspace.db);
-  const resume = await promptCheckpointChoice(checkpointer, threadId);
-  logger.printInfoLog(`Starting design-to-code process for: ${urlInfo.projectName}`);
-  if (resume !== true) {
-    workspaceManager.deleteWorkspace(workspace);
-    logger.printInfoLog("Starting fresh...");
-    checkpointer = initializeSqliteSaver(workspace.db);
-  } else {
-    logger.printInfoLog("Resuming from cache...");
-  }
-  await callModel({
-    question: "\u8BF7\u4ECB\u7ECD\u4F60\u81EA\u5DF1\uFF0C\u4F60\u662F\u4EC0\u4E48\u6A21\u578B",
-    streaming: false
-  });
-  const graph = new StateGraph(GraphStateAnnotation).addNode("initial" /* INITIAL */, initialProject).addNode("process" /* PROCESS */, generateProtocol).addNode("code" /* CODE */, generateCode).addNode("validation" /* VALIDATION */, runValidation).addEdge(START, "initial" /* INITIAL */).addEdge("initial" /* INITIAL */, "process" /* PROCESS */).addEdge("process" /* PROCESS */, "code" /* CODE */).addEdge("code" /* CODE */, "validation" /* VALIDATION */).addEdge("validation" /* VALIDATION */, END).compile({ checkpointer });
-  const config = { configurable: { thread_id: threadId } };
-  const validationMode = mode ?? "full";
-  const state = resume === true ? null : {
-    messages: [],
-    urlInfo,
-    workspace,
-    config: {
-      validationMode
-    }
-  };
-  await graph.invoke(state, config);
-  logger.printSuccessLog("Design-to-code process completed!");
-}
 export {
+  DEFAULT_STYLING,
+  FigmaImageFormat,
   GraphNode,
-  GraphStateAnnotation,
-  design2code,
+  INITIAL_AGENT_SYSTEM_PROMPT,
+  ValidationMode,
+  applyPropsAndStateToProtocol,
+  detectRenderingModes,
+  downloadImage,
+  executeFigmaAndImagesActions,
+  extractComponentGroups,
+  extractDataListPrompt,
+  extractHierarchicalNodesByIds,
+  extractJSON,
+  extractNodePositionsHierarchical,
+  figmaTool,
+  flattenPostOrder,
+  generateComponentPrompt,
+  generateFramePrompt,
+  generateStructurePrompt,
+  initialAgentInstruction,
+  parseFigmaUrl,
+  postProcessStructure,
+  saveGeneratedCode,
+  simplifyFigmaNodeForContent,
+  toKebabCase,
+  toPascalCase,
   workspaceManager
 };
 //# sourceMappingURL=index.js.map