zelune 1.6.3 → 1.6.4

package/mcp/server.mjs

@@ -1,4 +1,4 @@
-import fsSync from "node:fs";
+import fs$1 from "node:fs";
 import path from "node:path";
 import readline from "node:readline";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -6,7 +6,8 @@ import fs from "node:fs/promises";
 import { parse } from "@babel/parser";
 import _generate from "@babel/generator";
 import * as t from "@babel/types";
-const generate = _generate.default ?? _generate;
+import http from "node:http";
+const generate$1 = _generate.default ?? _generate;
 function getJsxTagName(nameNode) {
   if (t.isJSXIdentifier(nameNode)) {
     return nameNode.name;
@@ -99,7 +100,7 @@ function countScreenFilesInDirectory(screensDir, maxDepth = 4) {
     if (depth > maxDepth) return;
     let entries = [];
     try {
-      entries = fsSync.readdirSync(curr, { withFileTypes: true });
+      entries = fs$1.readdirSync(curr, { withFileTypes: true });
     } catch {
       return;
     }
@@ -128,7 +129,7 @@ function hasDirectScreenFiles(dirPath) {
   for (const rel of SCREEN_DIR_CANDIDATES) {
     const full = path.join(dirPath, rel);
     try {
-      if (fsSync.existsSync(full) && fsSync.statSync(full).isDirectory()) {
+      if (fs$1.existsSync(full) && fs$1.statSync(full).isDirectory()) {
         const count = countScreenFilesInDirectory(full);
         if (count > 0) {
           return { found: true, screenCount: count };
@@ -145,13 +146,13 @@ function scoreMobileCandidate(dirPath, screenCount) {
   if (/mobile|native|expo|app|client/.test(folderName)) {
     score += 10;
   }
-  if (fsSync.existsSync(path.join(dirPath, "app.json")) || fsSync.existsSync(path.join(dirPath, "eas.json"))) {
+  if (fs$1.existsSync(path.join(dirPath, "app.json")) || fs$1.existsSync(path.join(dirPath, "eas.json"))) {
     score += 25;
   }
   try {
     const pkgPath = path.join(dirPath, "package.json");
-    if (fsSync.existsSync(pkgPath)) {
-      const pkgRaw = fsSync.readFileSync(pkgPath, "utf-8");
+    if (fs$1.existsSync(pkgPath)) {
+      const pkgRaw = fs$1.readFileSync(pkgPath, "utf-8");
       if (pkgRaw.includes('"react-native"') || pkgRaw.includes('"expo"')) {
         score += 20;
       }
@@ -162,7 +163,7 @@ function scoreMobileCandidate(dirPath, screenCount) {
 }
 function findMobileAppRoot(rawRoot) {
   const normalizedRoot = path.resolve(rawRoot);
-  if (!fsSync.existsSync(normalizedRoot)) {
+  if (!fs$1.existsSync(normalizedRoot)) {
     return normalizedRoot;
   }
   const direct = hasDirectScreenFiles(normalizedRoot);
@@ -175,7 +176,7 @@ function findMobileAppRoot(rawRoot) {
     if (depth > 2) return;
     let entries = [];
     try {
-      entries = fsSync.readdirSync(parentDir, { withFileTypes: true });
+      entries = fs$1.readdirSync(parentDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -200,20 +201,20 @@ function findMobileAppRoot(rawRoot) {
 }
 function getActiveProjectRoot(fallbackRoot) {
   const envTarget = process.env.ANTIGRAVITY_TARGET_PROJECT;
-  const baseRoot = envTarget && fsSync.existsSync(envTarget) ? path.resolve(envTarget) : path.resolve(fallbackRoot);
+  const baseRoot = envTarget && fs$1.existsSync(envTarget) ? path.resolve(envTarget) : path.resolve(fallbackRoot);
   return findMobileAppRoot(baseRoot);
 }
 function resolveScreensDirectory(projectRoot) {
   const normalizedRoot = findMobileAppRoot(projectRoot);
   for (const rel of SCREEN_DIR_CANDIDATES) {
     const full = path.join(normalizedRoot, rel);
-    if (fsSync.existsSync(full) && fsSync.statSync(full).isDirectory() && countScreenFilesInDirectory(full) > 0) {
+    if (fs$1.existsSync(full) && fs$1.statSync(full).isDirectory() && countScreenFilesInDirectory(full) > 0) {
       return { dirPath: full, relDir: rel };
     }
   }
   for (const rel of SCREEN_DIR_CANDIDATES) {
     const full = path.join(normalizedRoot, rel);
-    if (fsSync.existsSync(full) && fsSync.statSync(full).isDirectory()) {
+    if (fs$1.existsSync(full) && fs$1.statSync(full).isDirectory()) {
       return { dirPath: full, relDir: rel };
     }
   }
@@ -225,7 +226,7 @@ function resolveScreensDirectory(projectRoot) {
 const FORBIDDEN_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function safeRealpath(targetPath) {
   try {
-    return fsSync.realpathSync(targetPath);
+    return fs$1.realpathSync(targetPath);
   } catch {
     return path.resolve(targetPath);
   }
@@ -236,7 +237,7 @@ function resolveSafeScreenPath(workspaceRoot, relativeFile) {
   const resolved = path.resolve(normalizedRoot, cleanRel);
   const allowedDirs = ["src/screens", "screens", "app", "src/app"].map((d) => {
     const candidate = path.resolve(normalizedRoot, d);
-    return fsSync.existsSync(candidate) ? safeRealpath(candidate) : candidate;
+    return fs$1.existsSync(candidate) ? safeRealpath(candidate) : candidate;
   });
   const isLexicallyAllowed = allowedDirs.some(
     (dir) => resolved.startsWith(dir + path.sep) || resolved === dir
@@ -249,8 +250,8 @@ function resolveSafeScreenPath(workspaceRoot, relativeFile) {
   if (!resolved.endsWith(".tsx") && !resolved.endsWith(".jsx")) {
     throw new Error(`Invalid file extension for "${relativeFile}". Only .tsx and .jsx are allowed.`);
   }
-  if (fsSync.existsSync(resolved)) {
-    const stat = fsSync.lstatSync(resolved);
+  if (fs$1.existsSync(resolved)) {
+    const stat = fs$1.lstatSync(resolved);
     if (stat.isSymbolicLink()) {
       throw new Error(
         `Security violation: Symbolic link "${relativeFile}" is not permitted inside screen directories`
@@ -365,7 +366,7 @@ function extractElementNavigationTarget(openingElement) {
       }
       if (t.isJSXExpressionContainer(attr.value)) {
         const expr = attr.value.expression;
-        const codeStr = generate(expr).code;
+        const codeStr = generate$1(expr).code;
         const match = codeStr.match(/(?:navigate|push|replace|jumpTo)\(\s*['"`]([^'"`$]+)['"`]/);
         if (match) return normalizeRouteTarget(match[1]);
         const objMatch = codeStr.match(/(?:pathname|screen|route|name)\s*:\s*['"`]([^'"`$]+)['"`]/);
@@ -429,7 +430,7 @@ function discoverScreenFilesSync(workspaceRoot) {
     if (depth > 4) return;
     let dirents = [];
     try {
-      dirents = fsSync.readdirSync(currDir, { withFileTypes: true });
+      dirents = fs$1.readdirSync(currDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -636,7 +637,7 @@ async function discoverScreens(workspaceRoot) {
       const extractTriggerLabelFromAncestry = (nodePath, fallbackTarget) => {
         const jsxParent = nodePath.findParent((p) => p.isJSXElement());
         if (jsxParent) {
-          const rawCode = generate(jsxParent.node).code;
+          const rawCode = generate$1(jsxParent.node).code;
           const textMatches = Array.from(rawCode.matchAll(/>([^<>{}\n]+)</g)).map((m) => m[1].trim()).filter(Boolean);
           if (textMatches.length > 0) {
             return textMatches.slice(0, 2).join(" · ");
@@ -666,7 +667,7 @@ async function discoverScreens(workspaceRoot) {
               }
             }
             if (attrName === "onPress" && t.isJSXExpressionContainer(attr.value)) {
-              const exprCode = generate(attr.value.expression).code;
+              const exprCode = generate$1(attr.value.expression).code;
               if (/\b(?:goBack|back|pop|popToTop)\s*\(/.test(exprCode)) {
                 hasBackNavigation = true;
                 backLine = line;
@@ -931,7 +932,7 @@ async function inspectElement(workspaceRoot, params) {
   const textInfo = inspectJsxTextChildren(element);
   const styleInfo = resolveElementStyles(opening, styleSheetInfo);
   const navigationTarget = extractElementNavigationTarget(opening);
-  const snippetRaw = generate(element, { concise: false }).code;
+  const snippetRaw = generate$1(element, { concise: false }).code;
   const codeSnippet = snippetRaw.length > 600 ? `${snippetRaw.slice(0, 600)}
   /* ... */` : snippetRaw;
   return {
@@ -1065,7 +1066,7 @@ async function patchElement(workspaceRoot, payload) {
         upsertObjectProperty(targetObject, styleKey, styleVal);
       }
     }
-    const output = generate(ast, {
+    const output = generate$1(ast, {
       retainLines: false,
       comments: true,
       jsescOption: { minimal: true }
@@ -1201,7 +1202,7 @@ async function reorderElement(workspaceRoot, payload) {
         }
       }
     });
-    const output = generate(ast, {
+    const output = generate$1(ast, {
       retainLines: false,
       comments: true,
       jsescOption: { minimal: true }
@@ -1733,7 +1734,7 @@ async function insertElement(workspaceRoot, payload) {
         }
       }
     });
-    const output = generate(ast, {
+    const output = generate$1(ast, {
       retainLines: false,
       comments: true,
       jsescOption: { minimal: true }
@@ -1810,7 +1811,7 @@ async function duplicateElement(workspaceRoot, payload) {
         }
       }
     });
-    const output = generate(ast, {
+    const output = generate$1(ast, {
       retainLines: false,
       comments: true,
       jsescOption: { minimal: true }
@@ -1878,7 +1879,7 @@ async function deleteElement(workspaceRoot, payload) {
       throw new Error("Could not find element inside parent children.");
     }
     siblings.splice(pos, 1);
-    const output = generate(ast, {
+    const output = generate$1(ast, {
       retainLines: false,
       comments: true,
       jsescOption: { minimal: true }
@@ -1903,6 +1904,1299 @@ async function deleteElement(workspaceRoot, payload) {
     };
   });
 }
+async function undoLastPatch(workspaceRoot) {
+  const entry = undoStack.pop();
+  if (!entry) {
+    return {
+      restoredFile: null,
+      description: null,
+      undoAvailable: 0,
+      redoAvailable: redoStack.length
+    };
+  }
+  const fullPath = resolveSafeScreenPath(workspaceRoot, entry.file);
+  await withFileLock(fullPath, async () => {
+    await fs.writeFile(fullPath, entry.previousContent, "utf-8");
+  });
+  redoStack.push(entry);
+  return {
+    restoredFile: entry.file,
+    description: entry.description,
+    undoAvailable: undoStack.length,
+    redoAvailable: redoStack.length
+  };
+}
+async function redoLastPatch(workspaceRoot) {
+  const entry = redoStack.pop();
+  if (!entry) {
+    return {
+      restoredFile: null,
+      description: null,
+      undoAvailable: undoStack.length,
+      redoAvailable: 0
+    };
+  }
+  const fullPath = resolveSafeScreenPath(workspaceRoot, entry.file);
+  await withFileLock(fullPath, async () => {
+    await fs.writeFile(fullPath, entry.nextContent, "utf-8");
+  });
+  undoStack.push(entry);
+  return {
+    restoredFile: entry.file,
+    description: entry.description,
+    undoAvailable: undoStack.length,
+    redoAvailable: redoStack.length
+  };
+}
+function getHistoryStatus() {
+  return {
+    undoAvailable: undoStack.length,
+    redoAvailable: redoStack.length
+  };
+}
+const MAX_BODY_BYTES = 1e6;
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+const FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isLoopbackHostHeader(hostHeader) {
+  if (!hostHeader) return false;
+  const trimmed = hostHeader.trim().toLowerCase();
+  if (trimmed.startsWith("[")) {
+    const closeIdx = trimmed.indexOf("]");
+    if (closeIdx === -1) return false;
+    const ipv6Host = trimmed.slice(0, closeIdx + 1);
+    return LOOPBACK_HOSTS.has(ipv6Host);
+  }
+  const hostname = trimmed.split(":")[0];
+  return LOOPBACK_HOSTS.has(hostname);
+}
+function verifyApiRequestSecurity(req) {
+  const host = typeof req.headers.host === "string" ? req.headers.host : void 0;
+  if (!isLoopbackHostHeader(host)) {
+    return {
+      allowed: false,
+      reason: "Forbidden Host header: Local API only accepts loopback connections (127.0.0.1, localhost, [::1])"
+    };
+  }
+  const secFetchSite = typeof req.headers["sec-fetch-site"] === "string" ? req.headers["sec-fetch-site"].toLowerCase() : void 0;
+  if (secFetchSite && secFetchSite !== "same-origin" && secFetchSite !== "none") {
+    return {
+      allowed: false,
+      reason: `Forbidden cross-site request (Sec-Fetch-Site: ${secFetchSite})`
+    };
+  }
+  const origin = typeof req.headers.origin === "string" ? req.headers.origin : void 0;
+  if (origin) {
+    try {
+      const parsedOrigin = new URL(origin);
+      if (!LOOPBACK_HOSTS.has(parsedOrigin.hostname.toLowerCase())) {
+        return {
+          allowed: false,
+          reason: `Forbidden cross-origin request from ${origin}`
+        };
+      }
+    } catch {
+      return {
+        allowed: false,
+        reason: "Malformed Origin header"
+      };
+    }
+  }
+  if (req.method === "POST") {
+    const contentType = typeof req.headers["content-type"] === "string" ? req.headers["content-type"].toLowerCase() : "";
+    if (!contentType.startsWith("application/json")) {
+      return {
+        allowed: false,
+        reason: "POST requests to /api/* must specify Content-Type: application/json"
+      };
+    }
+  }
+  return { allowed: true };
+}
+function sanitizeLayoutPayload(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("Invalid layout payload: expected an object map of screen coordinates");
+  }
+  const sanitized = /* @__PURE__ */ Object.create(null);
+  const entries = Object.entries(input);
+  if (entries.length > 200) {
+    throw new Error("Invalid layout payload: too many screen entries");
+  }
+  for (const [screenId, rawBox] of entries) {
+    if (!screenId || FORBIDDEN_KEYS.has(screenId) || screenId.length > 120) {
+      throw new Error(`Invalid screen key in layout payload: "${screenId}"`);
+    }
+    if (!rawBox || typeof rawBox !== "object" || Array.isArray(rawBox)) {
+      throw new Error(`Invalid layout coordinates for screen "${screenId}"`);
+    }
+    const box = rawBox;
+    const x = Number(box.x);
+    const y = Number(box.y);
+    const width = Number(box.width);
+    const height = Number(box.height);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(width) || !Number.isFinite(height) || Math.abs(x) > 1e5 || Math.abs(y) > 1e5 || width < 100 || width > 5e3 || height < 100 || height > 5e3) {
+      throw new Error(`Out-of-bounds layout coordinates for screen "${screenId}"`);
+    }
+    sanitized[screenId] = {
+      x: Math.round(x),
+      y: Math.round(y),
+      width: Math.round(width),
+      height: Math.round(height)
+    };
+  }
+  return sanitized;
+}
+async function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    let byteCount = 0;
+    let aborted = false;
+    req.on("data", (chunk) => {
+      if (aborted) return;
+      const chunkBytes = typeof chunk === "string" ? Buffer.byteLength(chunk, "utf-8") : chunk.length;
+      byteCount += chunkBytes;
+      if (byteCount > MAX_BODY_BYTES) {
+        aborted = true;
+        req.destroy();
+        reject(new Error("Request payload too large"));
+        return;
+      }
+      raw += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    });
+    req.on("end", () => {
+      if (aborted) return;
+      try {
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", (err) => {
+      if (!aborted) {
+        aborted = true;
+        reject(err);
+      }
+    });
+  });
+}
+const generate = _generate.default ?? _generate;
+const ALLOWED_SCREEN_PREFIXES = ["src/screens/", "screens/", "app/", "src/app/"];
+const RESOLVABLE_EXTENSIONS = [
+  ".web.tsx",
+  ".web.ts",
+  ".web.jsx",
+  ".web.js",
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".json",
+  ".css"
+];
+function stripJsonCommentsAndTrailingCommas(input) {
+  const withoutComments = input.replace(
+    /("(?:\\.|[^"\\])*")|\/\*[\s\S]*?\*\/|\/\/.*/g,
+    (_match, quotedString) => quotedString ?? ""
+  );
+  return withoutComments.replace(/,\s*([}\]])/g, "$1");
+}
+function tryResolveLocalModule(candidateBase) {
+  try {
+    const cleanBase = candidateBase.split("?")[0];
+    if (fs$1.existsSync(cleanBase) && fs$1.statSync(cleanBase).isFile()) {
+      return cleanBase;
+    }
+    for (const ext of RESOLVABLE_EXTENSIONS) {
+      const withExt = cleanBase + ext;
+      if (fs$1.existsSync(withExt) && fs$1.statSync(withExt).isFile()) {
+        return withExt;
+      }
+    }
+    if (fs$1.existsSync(cleanBase) && fs$1.statSync(cleanBase).isDirectory()) {
+      for (const ext of RESOLVABLE_EXTENSIONS) {
+        const indexFile = path.join(cleanBase, `index${ext}`);
+        if (fs$1.existsSync(indexFile) && fs$1.statSync(indexFile).isFile()) {
+          return indexFile;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function loadTsconfigAliases(roots) {
+  var _a, _b;
+  const mappings = [];
+  for (const rootDir of roots) {
+    try {
+      const tsconfigPath = path.join(rootDir, "tsconfig.json");
+      if (!fs$1.existsSync(tsconfigPath)) continue;
+      const raw = fs$1.readFileSync(tsconfigPath, "utf-8");
+      const parsed = JSON.parse(stripJsonCommentsAndTrailingCommas(raw));
+      const baseUrl = ((_a = parsed.compilerOptions) == null ? void 0 : _a.baseUrl) ?? ".";
+      const paths = ((_b = parsed.compilerOptions) == null ? void 0 : _b.paths) ?? {};
+      for (const [pattern, targets] of Object.entries(paths)) {
+        if (!Array.isArray(targets)) continue;
+        const cleanPrefix = pattern.replace(/\/\*$/, "");
+        if (!cleanPrefix) continue;
+        for (const target of targets) {
+          const cleanTarget = target.replace(/\/\*$/, "");
+          const resolvedDir = path.resolve(rootDir, baseUrl, cleanTarget);
+          mappings.push({ prefix: cleanPrefix, targetDir: resolvedDir });
+        }
+      }
+    } catch {
+    }
+  }
+  return mappings;
+}
+function cleanJsxText(rawText) {
+  const lines = rawText.split(/\r\n|\n|\r/);
+  let lastNonEmptyLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (/[^ \t]/.test(lines[i])) {
+      lastNonEmptyLine = i;
+    }
+  }
+  let str = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isFirstLine = i === 0;
+    const isLastLine = i === lines.length - 1;
+    const isLastNonEmptyLine = i === lastNonEmptyLine;
+    let trimmedLine = line.replace(/\t/g, " ");
+    if (!isFirstLine) {
+      trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+    }
+    if (!isLastLine) {
+      trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+    }
+    if (trimmedLine) {
+      if (!isLastNonEmptyLine) {
+        trimmedLine += " ";
+      }
+      str += trimmedLine;
+    }
+  }
+  return str.length > 0 ? str : null;
+}
+function convertJsxElementNameToExpr(nameNode) {
+  if (t.isJSXIdentifier(nameNode)) {
+    if (nameNode.name === "this") {
+      return t.thisExpression();
+    }
+    if (/^[a-z]/.test(nameNode.name) || nameNode.name.includes("-")) {
+      return t.stringLiteral(nameNode.name);
+    }
+    return t.identifier(nameNode.name);
+  }
+  if (t.isJSXMemberExpression(nameNode)) {
+    return t.memberExpression(
+      convertJsxElementNameToExpr(nameNode.object),
+      t.identifier(nameNode.property.name)
+    );
+  }
+  if (t.isJSXNamespacedName(nameNode)) {
+    return t.stringLiteral(`${nameNode.namespace.name}:${nameNode.name.name}`);
+  }
+  return t.stringLiteral("div");
+}
+function convertJsxAttributesToExpr(attributes) {
+  if (attributes.length === 0) {
+    return t.nullLiteral();
+  }
+  const props = [];
+  for (const attr of attributes) {
+    if (t.isJSXSpreadAttribute(attr)) {
+      props.push(t.spreadElement(attr.argument));
+      continue;
+    }
+    const rawKey = t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+    const keyNode = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(rawKey) ? t.identifier(rawKey) : t.stringLiteral(rawKey);
+    let valExpr;
+    if (attr.value === null || attr.value === void 0) {
+      valExpr = t.booleanLiteral(true);
+    } else if (t.isJSXExpressionContainer(attr.value)) {
+      if (t.isJSXEmptyExpression(attr.value.expression)) {
+        valExpr = t.booleanLiteral(true);
+      } else {
+        valExpr = attr.value.expression;
+      }
+    } else if (t.isJSXElement(attr.value) || t.isJSXFragment(attr.value)) {
+      valExpr = transformJsxNode(attr.value);
+    } else {
+      valExpr = attr.value;
+    }
+    props.push(t.objectProperty(keyNode, valExpr));
+  }
+  return t.objectExpression(props);
+}
+function convertJsxChildrenToExprs(children) {
+  const out = [];
+  for (const child of children) {
+    if (t.isJSXText(child)) {
+      const cleaned = cleanJsxText(child.value);
+      if (cleaned !== null) {
+        out.push(t.stringLiteral(cleaned));
+      }
+    } else if (t.isJSXExpressionContainer(child)) {
+      if (!t.isJSXEmptyExpression(child.expression)) {
+        out.push(child.expression);
+      }
+    } else if (t.isJSXSpreadChild(child)) {
+      out.push(child.expression);
+    } else if (t.isJSXElement(child) || t.isJSXFragment(child)) {
+      out.push(transformJsxNode(child));
+    }
+  }
+  return out;
+}
+function transformJsxNode(node) {
+  const createElMember = t.memberExpression(
+    t.identifier("React"),
+    t.identifier("createElement")
+  );
+  if (t.isJSXFragment(node)) {
+    const fragMember = t.memberExpression(
+      t.identifier("React"),
+      t.identifier("Fragment")
+    );
+    const children2 = convertJsxChildrenToExprs(node.children);
+    return t.callExpression(createElMember, [fragMember, t.nullLiteral(), ...children2]);
+  }
+  const tagExpr = convertJsxElementNameToExpr(node.openingElement.name);
+  const propsExpr = convertJsxAttributesToExpr(node.openingElement.attributes);
+  const children = convertJsxChildrenToExprs(node.children);
+  return t.callExpression(createElMember, [tagExpr, propsExpr, ...children]);
+}
+function convertTsEnumToVar(enumNode) {
+  const props = [];
+  let nextNumericValue = 0;
+  for (const member of enumNode.members) {
+    const keyNode = t.isIdentifier(member.id) ? t.identifier(member.id.name) : t.stringLiteral(member.id.value);
+    let initExpr;
+    if (member.initializer) {
+      initExpr = member.initializer;
+      if (t.isNumericLiteral(member.initializer)) {
+        nextNumericValue = member.initializer.value + 1;
+      }
+    } else {
+      initExpr = t.numericLiteral(nextNumericValue++);
+    }
+    props.push(t.objectProperty(keyNode, initExpr));
+  }
+  return t.variableDeclaration("const", [
+    t.variableDeclarator(t.identifier(enumNode.id.name), t.objectExpression(props))
+  ]);
+}
+function stripTypeScriptAndTransformJsxAst(node) {
+  var _a;
+  if (!node || typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    const nextArr = [];
+    for (let i = 0; i < node.length; i++) {
+      const item = node[i];
+      if (!item) continue;
+      if (item.type === "TSInterfaceDeclaration" || item.type === "TSTypeAliasDeclaration" || item.type === "TSDeclareFunction" || item.type === "TSDeclareMethod" || item.type === "TSModuleDeclaration" || item.type === "TSIndexSignature") {
+        continue;
+      }
+      if (item.type === "ImportDeclaration" && item.importKind === "type") {
+        continue;
+      }
+      if (item.type === "ExportNamedDeclaration") {
+        if (item.exportKind === "type") continue;
+        if (item.declaration && (item.declaration.type === "TSInterfaceDeclaration" || item.declaration.type === "TSTypeAliasDeclaration" || item.declaration.type === "TSDeclareFunction" || item.declaration.type === "TSModuleDeclaration")) {
+          continue;
+        }
+      }
+      const transformed = stripTypeScriptAndTransformJsxAst(item);
+      if (transformed !== null && transformed !== void 0) {
+        nextArr.push(transformed);
+      }
+    }
+    return nextArr;
+  }
+  while (node && (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSInstantiationExpression")) {
+    node = node.expression;
+  }
+  if (!node || typeof node !== "object") return node;
+  if (node.type === "TSEnumDeclaration") {
+    return convertTsEnumToVar(node);
+  }
+  if (node.type === "ExportNamedDeclaration" && ((_a = node.declaration) == null ? void 0 : _a.type) === "TSEnumDeclaration") {
+    node.declaration = convertTsEnumToVar(node.declaration);
+  }
+  if (node.type === "ImportDeclaration" && Array.isArray(node.specifiers)) {
+    const origCount = node.specifiers.length;
+    node.specifiers = node.specifiers.filter(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (s) => s.importKind !== "type"
+    );
+    if (origCount > 0 && node.specifiers.length === 0) {
+      return null;
+    }
+  }
+  if (node.type === "ExportNamedDeclaration" && Array.isArray(node.specifiers)) {
+    node.specifiers = node.specifiers.filter(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (s) => s.exportKind !== "type"
+    );
+    if (!node.declaration && node.specifiers.length === 0) {
+      return null;
+    }
+  }
+  delete node.typeAnnotation;
+  delete node.returnType;
+  delete node.typeParameters;
+  delete node.typeArguments;
+  delete node.implements;
+  delete node.superTypeParameters;
+  delete node.definite;
+  delete node.accessibility;
+  delete node.readonly;
+  delete node.declare;
+  delete node.override;
+  delete node.optional;
+  if (node.type === "TSParameterProperty") {
+    return stripTypeScriptAndTransformJsxAst(node.parameter);
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "comments" || key === "leadingComments" || key === "trailingComments") {
+      continue;
+    }
+    const val = node[key];
+    if (val && typeof val === "object") {
+      node[key] = stripTypeScriptAndTransformJsxAst(val);
+    }
+  }
+  if (node.type === "JSXElement" || node.type === "JSXFragment") {
+    return transformJsxNode(node);
+  }
+  return node;
+}
+function injectScreenAgyAttributes(ast, relPath) {
+  let jsxIndex = 0;
+  let hasJsx = false;
+  function visit(node) {
+    var _a, _b;
+    if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+    const typed = node;
+    if (typed.type === "JSXFragment") {
+      hasJsx = true;
+    } else if (typed.type === "JSXOpeningElement") {
+      hasJsx = true;
+      const tagName = getJsxTagName(typed.name);
+      if (tagName !== "Fragment" && tagName !== "React.Fragment" && tagName !== "") {
+        const hasAgyAttr = typed.attributes.some(
+          (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: "data-agy-ast-path" })
+        );
+        if (!hasAgyAttr) {
+          const currentIndex = String(jsxIndex++);
+          const line = String(((_a = typed.loc) == null ? void 0 : _a.start.line) ?? 1);
+          const col = String(((_b = typed.loc) == null ? void 0 : _b.start.column) ?? 0);
+          const dataSetProps = [
+            t.objectProperty(t.identifier("agyFile"), t.stringLiteral(relPath)),
+            t.objectProperty(t.identifier("agyLine"), t.stringLiteral(line)),
+            t.objectProperty(t.identifier("agyCol"), t.stringLiteral(col)),
+            t.objectProperty(t.identifier("agyAstPath"), t.stringLiteral(currentIndex)),
+            t.objectProperty(t.identifier("agyTag"), t.stringLiteral(tagName))
+          ];
+          typed.attributes.push(
+            t.jsxAttribute(
+              t.jsxIdentifier("dataSet"),
+              t.jsxExpressionContainer(t.objectExpression(dataSetProps))
+            ),
+            t.jsxAttribute(t.jsxIdentifier("data-agy-file"), t.stringLiteral(relPath)),
+            t.jsxAttribute(t.jsxIdentifier("data-agy-line"), t.stringLiteral(line)),
+            t.jsxAttribute(t.jsxIdentifier("data-agy-col"), t.stringLiteral(col)),
+            t.jsxAttribute(t.jsxIdentifier("data-agy-ast-path"), t.stringLiteral(currentIndex)),
+            t.jsxAttribute(t.jsxIdentifier("data-agy-tag"), t.stringLiteral(tagName))
+          );
+        }
+      }
+    }
+    const keys = t.VISITOR_KEYS[typed.type];
+    if (!keys) return;
+    const rec = typed;
+    for (const key of keys) {
+      const child = rec[key];
+      if (Array.isArray(child)) {
+        for (let i = 0; i < child.length; i++) {
+          if (child[i]) visit(child[i]);
+        }
+      } else if (child && typeof child === "object") {
+        visit(child);
+      }
+    }
+  }
+  visit(ast);
+  return hasJsx;
+}
+function compileModuleForBrowser(options) {
+  const { filePath, targetProjectRoot, workspaceRoot = targetProjectRoot } = options;
+  const cleanFilePath = filePath.split("?")[0];
+  const ext = path.extname(cleanFilePath).toLowerCase();
+  if (ext === ".css") {
+    return "export default {};\n";
+  }
+  if (ext === ".json") {
+    const rawJson = fs$1.readFileSync(cleanFilePath, "utf-8");
+    return `export default ${rawJson};
+`;
+  }
+  if (/\.(png|jpe?g|gif|webp|svg|avif|bmp)$/i.test(ext)) {
+    const assetUrl = `/@zelune/asset?file=${encodeURIComponent(cleanFilePath)}`;
+    return `export default { uri: ${JSON.stringify(assetUrl)} };
+`;
+  }
+  const code = fs$1.readFileSync(cleanFilePath, "utf-8");
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx", "decorators-legacy"],
+    errorRecovery: true
+  });
+  const normalizedTargetRoot = path.resolve(targetProjectRoot);
+  const relPath = path.relative(normalizedTargetRoot, path.resolve(cleanFilePath)).replace(/\\/g, "/");
+  const isScreenFile = ALLOWED_SCREEN_PREFIXES.some((prefix) => relPath.startsWith(prefix));
+  const hadJsx = isScreenFile ? injectScreenAgyAttributes(ast, relPath) : true;
+  const uniqueRoots = Array.from(
+    /* @__PURE__ */ new Set([path.resolve(targetProjectRoot), path.resolve(workspaceRoot)])
+  );
+  const tsconfigAliases = loadTsconfigAliases(uniqueRoots);
+  function resolveAlias(specifier) {
+    for (const mapping of tsconfigAliases) {
+      if (specifier === mapping.prefix) {
+        const found = tryResolveLocalModule(mapping.targetDir);
+        if (found) return found;
+      } else if (specifier.startsWith(mapping.prefix + "/")) {
+        const rel = specifier.slice(mapping.prefix.length + 1);
+        const found = tryResolveLocalModule(path.join(mapping.targetDir, rel));
+        if (found) return found;
+      }
+    }
+    if (specifier.startsWith("@/") || specifier.startsWith("~/")) {
+      const rel = specifier.slice(2);
+      for (const r of uniqueRoots) {
+        const direct = tryResolveLocalModule(path.join(r, rel));
+        if (direct) return direct;
+        const inSrc = tryResolveLocalModule(path.join(r, "src", rel));
+        if (inSrc) return inSrc;
+      }
+    }
+    return null;
+  }
+  function rewriteSpecifier(specifier, requestedExports) {
+    if (specifier === "react" || specifier === "react/jsx-runtime" || specifier === "react/jsx-dev-runtime") {
+      return "/@zelune/shim/react.js";
+    }
+    if (specifier === "react-dom" || specifier === "react-dom/client") {
+      return "/@zelune/shim/react-dom.js";
+    }
+    if (specifier === "react-native" || specifier === "react-native-web") {
+      return "/@zelune/shim/react-native.js";
+    }
+    if (specifier === "lucide-react" || specifier === "lucide-react-native") {
+      return `/@zelune/shim/lucide.js?exports=${encodeURIComponent(requestedExports.join(","))}`;
+    }
+    if (specifier.startsWith(".")) {
+      const candidate = path.resolve(path.dirname(cleanFilePath), specifier);
+      const resolved = tryResolveLocalModule(candidate);
+      if (resolved) {
+        return `/@zelune/module?file=${encodeURIComponent(resolved)}`;
+      }
+      return `/@zelune/shim/stub.js?pkg=${encodeURIComponent(specifier)}&exports=${encodeURIComponent(
+        requestedExports.join(",")
+      )}`;
+    }
+    if (specifier.startsWith("@/") || specifier.startsWith("~/") || tsconfigAliases.some((m) => specifier === m.prefix || specifier.startsWith(m.prefix + "/"))) {
+      const resolved = resolveAlias(specifier);
+      if (resolved) {
+        return `/@zelune/module?file=${encodeURIComponent(resolved)}`;
+      }
+      return `/@zelune/shim/stub.js?pkg=${encodeURIComponent(specifier)}&exports=${encodeURIComponent(
+        requestedExports.join(",")
+      )}`;
+    }
+    return `/@zelune/shim/stub.js?pkg=${encodeURIComponent(specifier)}&exports=${encodeURIComponent(
+      requestedExports.join(",")
+    )}`;
+  }
+  stripTypeScriptAndTransformJsxAst(ast);
+  let hasReactIdentifierInScope = false;
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      const requested = [];
+      for (const spec of stmt.specifiers) {
+        if (spec.local.name === "React") {
+          hasReactIdentifierInScope = true;
+        }
+        if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+          if (importedName && importedName !== "default") {
+            requested.push(importedName);
+          }
+        }
+      }
+      stmt.source.value = rewriteSpecifier(stmt.source.value, requested);
+    } else if ((stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportAllDeclaration") && stmt.source) {
+      const requested = [];
+      if (stmt.type === "ExportNamedDeclaration") {
+        for (const spec of stmt.specifiers) {
+          if (spec.type === "ExportSpecifier") {
+            const localName = spec.local.type === "Identifier" ? spec.local.name : spec.local.value;
+            const exportedName = spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value;
+            if (localName && localName !== "default") requested.push(localName);
+            if (exportedName && exportedName !== "default") requested.push(exportedName);
+          }
+        }
+      }
+      stmt.source.value = rewriteSpecifier(stmt.source.value, requested);
+    }
+  }
+  if (hadJsx && !hasReactIdentifierInScope) {
+    ast.program.body.unshift(
+      t.importDeclaration(
+        [t.importDefaultSpecifier(t.identifier("React"))],
+        t.stringLiteral("/@zelune/shim/react.js")
+      )
+    );
+  }
+  const out = generate(ast, {
+    retainLines: false,
+    compact: false
+  });
+  return out.code;
+}
+function extractStaticAstValue(node, scope, depth = 0) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (!node || depth > 12) return void 0;
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return node.value;
+    case "NullLiteral":
+      return null;
+    case "UnaryExpression": {
+      const arg = extractStaticAstValue(node.argument, scope, depth + 1);
+      if (typeof arg === "number") {
+        if (node.operator === "-") return -arg;
+        if (node.operator === "+") return +arg;
+      }
+      return void 0;
+    }
+    case "TemplateLiteral": {
+      if (Array.isArray(node.expressions) && node.expressions.length === 0) {
+        return ((_c = (_b = (_a = node.quasis) == null ? void 0 : _a[0]) == null ? void 0 : _b.value) == null ? void 0 : _c.cooked) ?? ((_f = (_e = (_d = node.quasis) == null ? void 0 : _d[0]) == null ? void 0 : _e.value) == null ? void 0 : _f.raw) ?? "";
+      }
+      return void 0;
+    }
+    case "ArrayExpression": {
+      const items = [];
+      for (const el of node.elements ?? []) {
+        if (!el) continue;
+        if (el.type === "SpreadElement") {
+          const spreadVal = extractStaticAstValue(el.argument, scope, depth + 1);
+          if (Array.isArray(spreadVal)) items.push(...spreadVal);
+        } else {
+          const val = extractStaticAstValue(el, scope, depth + 1);
+          if (val !== void 0) items.push(val);
+        }
+      }
+      return items;
+    }
+    case "ObjectExpression": {
+      const result = {};
+      for (const prop of node.properties ?? []) {
+        if (prop.type === "SpreadElement") {
+          const spreadObj = extractStaticAstValue(prop.argument, scope, depth + 1);
+          if (spreadObj && typeof spreadObj === "object" && !Array.isArray(spreadObj)) {
+            Object.assign(result, spreadObj);
+          }
+          continue;
+        }
+        if (prop.type !== "ObjectProperty" || prop.computed) continue;
+        const key = ((_g = prop.key) == null ? void 0 : _g.type) === "Identifier" ? prop.key.name : ((_h = prop.key) == null ? void 0 : _h.type) === "StringLiteral" || ((_i = prop.key) == null ? void 0 : _i.type) === "NumericLiteral" ? String(prop.key.value) : null;
+        if (!key) continue;
+        const val = extractStaticAstValue(prop.value, scope, depth + 1);
+        if (val !== void 0) {
+          result[key] = val;
+        }
+      }
+      return result;
+    }
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSTypeAssertion":
+    case "ParenthesizedExpression":
+      return extractStaticAstValue(node.expression, scope, depth + 1);
+    case "Identifier":
+      return scope.get(node.name);
+    default:
+      return void 0;
+  }
+}
+function parseTailwindConfigSource(raw) {
+  try {
+    const ast = parse(raw, {
+      sourceType: "unambiguous",
+      plugins: ["typescript", "jsx"],
+      errorRecovery: true
+    });
+    const scope = /* @__PURE__ */ new Map();
+    let exportedConfig;
+    for (const stmt of ast.program.body) {
+      if (stmt.type === "VariableDeclaration") {
+        for (const decl of stmt.declarations) {
+          if (decl.id.type === "Identifier" && decl.init) {
+            const val = extractStaticAstValue(decl.init, scope);
+            if (val !== void 0) {
+              scope.set(decl.id.name, val);
+            }
+          }
+        }
+      } else if (stmt.type === "ExportDefaultDeclaration") {
+        exportedConfig = extractStaticAstValue(stmt.declaration, scope);
+      } else if (stmt.type === "ExpressionStatement" && stmt.expression.type === "AssignmentExpression") {
+        const left = stmt.expression.left;
+        if (left.type === "MemberExpression" && left.object.type === "Identifier" && left.property.type === "Identifier" && (left.object.name === "module" && left.property.name === "exports" || left.object.name === "exports" && left.property.name === "default")) {
+          exportedConfig = extractStaticAstValue(stmt.expression.right, scope);
+        }
+      }
+    }
+    const cfg = exportedConfig;
+    if ((cfg == null ? void 0 : cfg.theme) && typeof cfg.theme === "object") {
+      const baseTheme = { ...cfg.theme };
+      const extendTheme = cfg.theme.extend && typeof cfg.theme.extend === "object" ? cfg.theme.extend : {};
+      delete baseTheme.extend;
+      const merged = { ...baseTheme };
+      for (const [k, v] of Object.entries(extendTheme)) {
+        if (v && typeof v === "object" && !Array.isArray(v)) {
+          merged[k] = {
+            ...baseTheme[k] ?? {},
+            ...v
+          };
+        } else {
+          merged[k] = v;
+        }
+      }
+      return merged;
+    }
+  } catch {
+  }
+  return {};
+}
+function loadProjectTailwindTheme(roots) {
+  const candidates = [
+    "tailwind.config.js",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs",
+    "tailwind.config.ts"
+  ];
+  const uniqueRoots = Array.from(new Set(roots.map((r) => path.resolve(r))));
+  for (const rootDir of uniqueRoots) {
+    for (const fileName of candidates) {
+      const fullPath = path.join(rootDir, fileName);
+      try {
+        if (!fs$1.existsSync(fullPath)) continue;
+        const raw = fs$1.readFileSync(fullPath, "utf-8");
+        const parsedTheme = parseTailwindConfigSource(raw);
+        if (Object.keys(parsedTheme).length > 0) {
+          return parsedTheme;
+        }
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+const MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon"
+};
+const REACT_EXPORTS = [
+  "Children",
+  "Component",
+  "Fragment",
+  "Profiler",
+  "PureComponent",
+  "StrictMode",
+  "Suspense",
+  "cloneElement",
+  "createContext",
+  "createElement",
+  "createFactory",
+  "createRef",
+  "forwardRef",
+  "isValidElement",
+  "lazy",
+  "memo",
+  "startTransition",
+  "useCallback",
+  "useContext",
+  "useDebugValue",
+  "useDeferredValue",
+  "useEffect",
+  "useId",
+  "useImperativeHandle",
+  "useInsertionEffect",
+  "useLayoutEffect",
+  "useMemo",
+  "useReducer",
+  "useRef",
+  "useState",
+  "useSyncExternalStore",
+  "useTransition",
+  "version"
+];
+const REACT_NATIVE_EXPORTS = [
+  "View",
+  "Text",
+  "Pressable",
+  "TouchableOpacity",
+  "TouchableHighlight",
+  "TouchableWithoutFeedback",
+  "TouchableNativeFeedback",
+  "ScrollView",
+  "FlatList",
+  "SectionList",
+  "VirtualizedList",
+  "KeyboardAvoidingView",
+  "TextInput",
+  "Image",
+  "ImageBackground",
+  "SafeAreaView",
+  "ActivityIndicator",
+  "Switch",
+  "Modal",
+  "Button",
+  "RefreshControl",
+  "StatusBar",
+  "StyleSheet",
+  "Platform",
+  "Dimensions",
+  "useWindowDimensions",
+  "PixelRatio",
+  "Animated",
+  "useAnimatedValue",
+  "Easing",
+  "Alert",
+  "Linking",
+  "Share",
+  "Vibration",
+  "Keyboard",
+  "BackHandler",
+  "AppState",
+  "Appearance",
+  "useColorScheme",
+  "PanResponder",
+  "LayoutAnimation",
+  "UIManager",
+  "InteractionManager",
+  "NativeEventEmitter",
+  "DeviceEventEmitter",
+  "NativeAppEventEmitter",
+  "NativeModules",
+  "I18nManager",
+  "AccessibilityInfo",
+  "LogBox",
+  "YellowBox",
+  "findNodeHandle",
+  "processColor",
+  "PermissionsAndroid",
+  "ToastAndroid",
+  "ActionSheetIOS",
+  "InputAccessoryView",
+  "DrawerLayoutAndroid",
+  "TurboModuleRegistry",
+  "requireNativeComponent",
+  "codegenNativeComponent",
+  "PlatformColor",
+  "DynamicColorIOS",
+  "DevSettings",
+  "Systrace",
+  "Networking",
+  "Settings"
+];
+function sendJson(res, status, payload) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.end(JSON.stringify(payload));
+}
+function sendJs(res, code) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+  res.setHeader("Cache-Control", "no-store");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.end(code);
+}
+function buildReactShimModule() {
+  const lines = [
+    `const R = window.__ZELUNE_RUNTIME__.React;`,
+    `export default R;`,
+    `export const jsx = R.createElement;`,
+    `export const jsxs = R.createElement;`,
+    `export const jsxDEV = R.createElement;`
+  ];
+  for (const name of REACT_EXPORTS) {
+    lines.push(`export const ${name} = R.${name};`);
+  }
+  return lines.join("\n");
+}
+function buildReactDomShimModule() {
+  return [
+    `const RD = window.__ZELUNE_RUNTIME__.ReactDOM;`,
+    `export default RD;`,
+    `export const createRoot = RD.createRoot;`,
+    `export const hydrateRoot = RD.hydrateRoot;`,
+    `export const flushSync = RD.flushSync;`,
+    `export const createPortal = RD.createPortal;`
+  ].join("\n");
+}
+function buildReactNativeShimModule() {
+  const lines = [
+    `const RN = window.__ZELUNE_RUNTIME__.ReactNative;`,
+    `export default RN.default || RN;`
+  ];
+  for (const name of REACT_NATIVE_EXPORTS) {
+    lines.push(`export const ${name} = RN.${name};`);
+  }
+  return lines.join("\n");
+}
+function buildLucideShimModule(requestedNames) {
+  const lines = [
+    `const L = window.__ZELUNE_RUNTIME__.LucideIcons || {};`,
+    `const M = window.__ZELUNE_RUNTIME__.MockNav || {};`,
+    `export default L;`
+  ];
+  const unique = Array.from(
+    new Set(
+      requestedNames.map((s) => s.trim()).filter((s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s) && s !== "default")
+    )
+  );
+  for (const name of unique) {
+    lines.push(
+      `export const ${name} = L[${JSON.stringify(name)}] || M.createVectorIconComponent(${JSON.stringify(name)});`
+    );
+  }
+  return lines.join("\n");
+}
+function buildUniversalStubModule(requestedNames) {
+  const lines = [
+    `const React = window.__ZELUNE_RUNTIME__.React;`,
+    `const RN = window.__ZELUNE_RUNTIME__.ReactNative;`,
+    `const M = window.__ZELUNE_RUNTIME__.MockNav;`,
+    `export default M.default || M;`,
+    `const COMPOUND_SUB_NAMES = ['Item', 'Header', 'Footer', 'Title', 'Content', 'Trigger', 'Portal', 'Overlay', 'Close', 'Action', 'Cancel', 'Description', 'Label', 'Group', 'Separator', 'Value', 'Icon', 'Viewport', 'Root', 'Screen', 'Navigator', 'Provider', 'Consumer'];`,
+    `function createSubStub(displayName) {`,
+    `  const Sub = React.forwardRef(function SubComp(props, ref) {`,
+    `    const content = typeof props?.children === 'function' ? props.children(M.SAFE_CHAINABLE_PROXY) : props?.children;`,
+    `    return React.createElement(RN.View, { style: props?.style, className: props?.className, ref }, content);`,
+    `  });`,
+    `  Sub.displayName = displayName;`,
+    `  return Sub;`,
+    `}`,
+    `function createComponentStub(displayName) {`,
+    `  const Comp = React.forwardRef(function StubComp(props, ref) {`,
+    `    if (typeof props?.render === 'function') {`,
+    `      return props.render({`,
+    `        field: { name: props?.name ?? '', value: props?.defaultValue ?? '', onChange: () => undefined, onBlur: () => undefined, ref: () => undefined },`,
+    `        fieldState: { invalid: false, isTouched: false, isDirty: false, error: undefined },`,
+    `        formState: { errors: {}, isSubmitting: false, isValid: true },`,
+    `      });`,
+    `    }`,
+    `    const content = typeof props?.children === 'function' ? props.children(M.SAFE_CHAINABLE_PROXY) : props?.children;`,
+    `    return React.createElement(RN.View, { style: props?.style, className: props?.className, ref }, content);`,
+    `  });`,
+    `  Comp.displayName = displayName;`,
+    `  for (const sub of COMPOUND_SUB_NAMES) {`,
+    `    Comp[sub] = createSubStub(displayName + '.' + sub);`,
+    `  }`,
+    `  return Comp;`,
+    `}`,
+    `function resolveExport(name) {`,
+    `  if (name in M) return M[name];`,
+    `  if (M.default && name in M.default) return M.default[name];`,
+    `  if (/^use[A-Z]/.test(name)) return () => M.SAFE_CHAINABLE_PROXY;`,
+    `  if (/^[A-Z]/.test(name)) return createComponentStub(name);`,
+    `  return M.SAFE_CHAINABLE_PROXY;`,
+    `}`
+  ];
+  const unique = Array.from(
+    new Set(
+      requestedNames.map((s) => s.trim()).filter((s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s) && s !== "default")
+    )
+  );
+  for (const name of unique) {
+    lines.push(`export const ${name} = resolveExport(${JSON.stringify(name)});`);
+  }
+  return lines.join("\n");
+}
+async function resolveConnectedProjectName(workspaceRoot) {
+  var _a;
+  const activeRoot = getActiveProjectRoot(workspaceRoot);
+  const dirName = path.basename(activeRoot);
+  try {
+    const appJsonRaw = await fs.readFile(path.join(activeRoot, "app.json"), "utf-8");
+    const appJson = JSON.parse(appJsonRaw);
+    if ((_a = appJson == null ? void 0 : appJson.expo) == null ? void 0 : _a.name) return appJson.expo.name;
+    if (appJson == null ? void 0 : appJson.name) return appJson.name;
+  } catch {
+  }
+  try {
+    const pkgRaw = await fs.readFile(path.join(activeRoot, "package.json"), "utf-8");
+    const pkg = JSON.parse(pkgRaw);
+    if ((pkg == null ? void 0 : pkg.name) && pkg.name.toLowerCase() !== "zelune") {
+      return pkg.name;
+    }
+  } catch {
+  }
+  return dirName;
+}
+async function startStudioHttpServer(options) {
+  const { packageRoot, targetProjectRoot, workspaceRoot } = options;
+  const distDir = path.resolve(packageRoot, "dist");
+  const allowedRoots = Array.from(
+    /* @__PURE__ */ new Set([
+      path.resolve(packageRoot),
+      path.resolve(targetProjectRoot),
+      path.resolve(workspaceRoot)
+    ])
+  );
+  function isPathAllowed(candidatePath) {
+    const resolved = path.resolve(candidatePath);
+    return allowedRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep));
+  }
+  const requestHandler = async (req, res) => {
+    const rawUrl = req.url ?? "/";
+    const qIdx = rawUrl.indexOf("?");
+    const pathname = qIdx === -1 ? rawUrl : rawUrl.slice(0, qIdx);
+    const searchParams = new URLSearchParams(qIdx === -1 ? "" : rawUrl.slice(qIdx + 1));
+    if (pathname.startsWith("/api/")) {
+      const securityCheck = verifyApiRequestSecurity(req);
+      if (!securityCheck.allowed) {
+        return sendJson(res, 403, { ok: false, error: securityCheck.reason });
+      }
+      const activeRoot = getActiveProjectRoot(targetProjectRoot);
+      const layoutFilePath = path.resolve(activeRoot, ".canvas-layout.json");
+      try {
+        if (req.method === "GET" && pathname === "/api/screens") {
+          const [screens, projectName] = await Promise.all([
+            discoverScreens(targetProjectRoot),
+            resolveConnectedProjectName(targetProjectRoot)
+          ]);
+          const history = getHistoryStatus();
+          return sendJson(res, 200, { ok: true, projectName, screens, history });
+        }
+        if (req.method === "GET" && pathname === "/api/inspect") {
+          const file = searchParams.get("file") ?? "";
+          const astPath = searchParams.get("astPath") ?? "";
+          const lineParam = searchParams.get("line");
+          const line = lineParam ? Number.parseInt(lineParam, 10) : void 0;
+          const element = await inspectElement(targetProjectRoot, { file, astPath, line });
+          const history = getHistoryStatus();
+          return sendJson(res, 200, { ok: true, element, history });
+        }
+        if (req.method === "POST" && pathname === "/api/patch") {
+          const body = await readJsonBody(req);
+          const result = await patchElement(targetProjectRoot, body);
+          return sendJson(res, 200, {
+            ok: true,
+            element: result.element,
+            history: {
+              undoAvailable: result.undoAvailable,
+              redoAvailable: result.redoAvailable
+            }
+          });
+        }
+        if (req.method === "POST" && pathname === "/api/reorder") {
+          const body = await readJsonBody(req);
+          const result = await reorderElement(targetProjectRoot, body);
+          return sendJson(res, 200, {
+            ok: true,
+            element: result.element,
+            history: {
+              undoAvailable: result.undoAvailable,
+              redoAvailable: result.redoAvailable
+            }
+          });
+        }
+        if (req.method === "POST" && pathname === "/api/insert") {
+          const body = await readJsonBody(req);
+          const result = await insertElement(targetProjectRoot, body);
+          return sendJson(res, 200, {
+            ok: true,
+            element: result.element,
+            history: {
+              undoAvailable: result.undoAvailable,
+              redoAvailable: result.redoAvailable
+            }
+          });
+        }
+        if (req.method === "POST" && pathname === "/api/duplicate") {
+          const body = await readJsonBody(req);
+          const result = await duplicateElement(targetProjectRoot, body);
+          return sendJson(res, 200, {
+            ok: true,
+            element: result.element,
+            history: {
+              undoAvailable: result.undoAvailable,
+              redoAvailable: result.redoAvailable
+            }
+          });
+        }
+        if (req.method === "POST" && pathname === "/api/delete") {
+          const body = await readJsonBody(req);
+          const result = await deleteElement(targetProjectRoot, body);
+          return sendJson(res, 200, {
+            ok: true,
+            deletedAstPath: result.deletedAstPath,
+            history: {
+              undoAvailable: result.undoAvailable,
+              redoAvailable: result.redoAvailable
+            }
+          });
+        }
+        if (req.method === "POST" && pathname === "/api/undo") {
+          const result = await undoLastPatch(targetProjectRoot);
+          return sendJson(res, 200, { ok: true, ...result });
+        }
+        if (req.method === "POST" && pathname === "/api/redo") {
+          const result = await redoLastPatch(targetProjectRoot);
+          return sendJson(res, 200, { ok: true, ...result });
+        }
+        if (req.method === "GET" && pathname === "/api/layout") {
+          try {
+            const raw = await fs.readFile(layoutFilePath, "utf-8");
+            const validated = sanitizeLayoutPayload(JSON.parse(raw));
+            return sendJson(res, 200, { ok: true, layout: validated });
+          } catch {
+            return sendJson(res, 200, { ok: true, layout: null });
+          }
+        }
+        if (req.method === "POST" && pathname === "/api/layout") {
+          const body = await readJsonBody(req);
+          const validated = sanitizeLayoutPayload(body);
+          await fs.writeFile(layoutFilePath, JSON.stringify(validated, null, 2), "utf-8");
+          return sendJson(res, 200, { ok: true });
+        }
+        return sendJson(res, 404, { ok: false, error: `Unknown API route: ${pathname}` });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return sendJson(res, 400, { ok: false, error: message });
+      }
+    }
+    if (pathname === "/@zelune/shim/react.js") {
+      return sendJs(res, buildReactShimModule());
+    }
+    if (pathname === "/@zelune/shim/react-dom.js") {
+      return sendJs(res, buildReactDomShimModule());
+    }
+    if (pathname === "/@zelune/shim/react-native.js") {
+      return sendJs(res, buildReactNativeShimModule());
+    }
+    if (pathname === "/@zelune/shim/lucide.js") {
+      const exportsParam = searchParams.get("exports") ?? "";
+      return sendJs(res, buildLucideShimModule(exportsParam.split(",")));
+    }
+    if (pathname === "/@zelune/shim/stub.js") {
+      const exportsParam = searchParams.get("exports") ?? "";
+      return sendJs(res, buildUniversalStubModule(exportsParam.split(",")));
+    }
+    if (pathname === "/@zelune/module") {
+      const fileParam = searchParams.get("file") ?? "";
+      if (!fileParam || !isPathAllowed(fileParam) || !fs$1.existsSync(fileParam)) {
+        res.statusCode = 404;
+        return res.end("// Module not found\nexport default {};\n");
+      }
+      try {
+        const compiled = compileModuleForBrowser({
+          filePath: fileParam,
+          targetProjectRoot,
+          workspaceRoot
+        });
+        return sendJs(res, compiled);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.statusCode = 500;
+        return res.end(`throw new Error(${JSON.stringify(msg)});
+`);
+      }
+    }
+    if (pathname === "/@zelune/asset") {
+      const fileParam = searchParams.get("file") ?? "";
+      if (!fileParam || !isPathAllowed(fileParam) || !fs$1.existsSync(fileParam)) {
+        res.statusCode = 404;
+        return res.end("Not found");
+      }
+      const ext = path.extname(fileParam).toLowerCase();
+      res.statusCode = 200;
+      res.setHeader("Content-Type", MIME_TYPES[ext] ?? "application/octet-stream");
+      return fs$1.createReadStream(fileParam).pipe(res);
+    }
+    if (pathname === "/" || pathname === "/index.html") {
+      const indexHtmlPath = path.join(distDir, "index.html");
+      if (!fs$1.existsSync(indexHtmlPath)) {
+        res.statusCode = 500;
+        return res.end("Zelune dist/index.html not found.");
+      }
+      const rawHtml = await fs.readFile(indexHtmlPath, "utf-8");
+      const tailwindTheme = loadProjectTailwindTheme([targetProjectRoot, workspaceRoot]);
+      const discoveredManifest = discoverScreenFilesSync(targetProjectRoot);
+      const runtimeScript = `<script>window.__ZELUNE_TAILWIND_THEME__ = ${JSON.stringify(
+        tailwindTheme
+      )}; window.__ZELUNE_SCREEN_MANIFEST__ = ${JSON.stringify(discoveredManifest)};<\/script>`;
+      const injectedHtml = rawHtml.replace("<head>", `<head>
+    ${runtimeScript}`);
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.setHeader("Cache-Control", "no-store");
+      return res.end(injectedHtml);
+    }
+    const relativeAsset = pathname.replace(/^\/+/, "");
+    const assetCandidate = path.resolve(distDir, relativeAsset);
+    if (assetCandidate.startsWith(distDir + path.sep) && fs$1.existsSync(assetCandidate) && fs$1.statSync(assetCandidate).isFile()) {
+      const ext = path.extname(assetCandidate).toLowerCase();
+      res.statusCode = 200;
+      res.setHeader("Content-Type", MIME_TYPES[ext] ?? "application/octet-stream");
+      return fs$1.createReadStream(assetCandidate).pipe(res);
+    }
+    res.statusCode = 404;
+    res.end("Not found");
+  };
+  const basePort = options.port ?? 5173;
+  for (let offset = 0; offset < 25; offset++) {
+    const candidatePort = basePort + offset;
+    try {
+      const srv = await new Promise((resolve, reject) => {
+        const s = http.createServer(requestHandler);
+        s.once("error", reject);
+        s.listen(candidatePort, "127.0.0.1", () => {
+          s.removeListener("error", reject);
+          resolve(s);
+        });
+      });
+      return { server: srv, port: candidatePort };
+    } catch (err) {
+      const code = err == null ? void 0 : err.code;
+      if (code === "EADDRINUSE" && !options.port) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Unable to bind Studio HTTP server starting from port ${basePort}`);
+}
 const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
 const DEFAULT_WORKSPACE_ROOT = path.resolve(__dirname$1, "..");
 const MCP_TOOLS = [
@@ -2155,7 +3449,7 @@ async function handleMcpJsonRpcRequest(request, customWorkspaceRoot) {
           },
           serverInfo: {
             name: "zelune",
-            version: "1.6.3"
+            version: "1.6.4"
           }
         }
       };
@@ -2254,7 +3548,7 @@ function startMcpServer(customWorkspaceRoot) {
 }
 const isDirectExecution = Boolean(process.argv[1]) && (() => {
   try {
-    return import.meta.url === pathToFileURL(fsSync.realpathSync(process.argv[1])).href;
+    return import.meta.url === pathToFileURL(fs$1.realpathSync(process.argv[1])).href;
   } catch {
     return false;
   }
@@ -2265,5 +3559,6 @@ if (isDirectExecution) {
 export {
   MCP_TOOLS,
   handleMcpJsonRpcRequest,
-  startMcpServer
+  startMcpServer,
+  startStudioHttpServer
 };