zelune 1.6.3 → 1.6.5

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 };
     }
   }
@@ -223,20 +224,20 @@ function resolveScreensDirectory(projectRoot) {
   };
 }
 const FORBIDDEN_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function safeRealpath(targetPath) {
+function safeRealpath$1(targetPath) {
   try {
-    return fsSync.realpathSync(targetPath);
+    return fs$1.realpathSync(targetPath);
   } catch {
     return path.resolve(targetPath);
   }
 }
 function resolveSafeScreenPath(workspaceRoot, relativeFile) {
-  const normalizedRoot = safeRealpath(getActiveProjectRoot(workspaceRoot));
+  const normalizedRoot = safeRealpath$1(getActiveProjectRoot(workspaceRoot));
   const cleanRel = String(relativeFile ?? "").replace(/^[/\\]+/, "");
   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$1(candidate) : candidate;
   });
   const isLexicallyAllowed = allowedDirs.some(
     (dir) => resolved.startsWith(dir + path.sep) || resolved === dir
@@ -249,14 +250,14 @@ 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`
       );
     }
-    const realTarget = safeRealpath(resolved);
+    const realTarget = safeRealpath$1(resolved);
     const isRealInsideAllowed = allowedDirs.some(
       (dir) => realTarget.startsWith(dir + path.sep) || realTarget === dir
     );
@@ -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,1878 @@ 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 ASSET_EXT_REGEX = /\.(png|jpe?g|gif|webp|svg|avif|bmp|ico|ttf|otf|woff2?|mp3|mp4|wav|m4a|webm|lottie|pdf|bin)$/i;
+const RESOLVABLE_EXTENSIONS = [
+  ".web.tsx",
+  ".web.ts",
+  ".web.jsx",
+  ".web.js",
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".native.tsx",
+  ".native.ts",
+  ".native.jsx",
+  ".native.js",
+  ".ios.tsx",
+  ".ios.ts",
+  ".android.tsx",
+  ".android.ts",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".css"
+];
+const ZELUNE_JSX_REACT_IDENT = "__zeluneReact";
+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, onJsxSeen) {
+  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, onJsxSeen);
+    } else {
+      valExpr = attr.value;
+    }
+    props.push(t.objectProperty(keyNode, valExpr));
+  }
+  return t.objectExpression(props);
+}
+function convertJsxChildrenToExprs(children, onJsxSeen) {
+  const out = [];
+  for (const child of children) {
+    if (!child) continue;
+    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, onJsxSeen));
+    } else if (t.isSpreadElement(child) || t.isExpression(child)) {
+      out.push(child);
+    }
+  }
+  return out;
+}
+function transformJsxNode(node, onJsxSeen) {
+  onJsxSeen();
+  const createElMember = t.memberExpression(
+    t.identifier(ZELUNE_JSX_REACT_IDENT),
+    t.identifier("createElement")
+  );
+  if (t.isJSXFragment(node)) {
+    const fragMember = t.memberExpression(
+      t.identifier(ZELUNE_JSX_REACT_IDENT),
+      t.identifier("Fragment")
+    );
+    const children2 = convertJsxChildrenToExprs(node.children, onJsxSeen);
+    return t.callExpression(createElMember, [fragMember, t.nullLiteral(), ...children2]);
+  }
+  const tagExpr = convertJsxElementNameToExpr(node.openingElement.name);
+  const propsExpr = convertJsxAttributesToExpr(node.openingElement.attributes, onJsxSeen);
+  const children = convertJsxChildrenToExprs(node.children, onJsxSeen);
+  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 isTsDeclarationOnlyNode(item) {
+  const nodeType = item.type;
+  if (nodeType === "TSInterfaceDeclaration" || nodeType === "TSTypeAliasDeclaration" || nodeType === "TSDeclareFunction" || nodeType === "TSDeclareMethod" || nodeType === "TSModuleDeclaration" || nodeType === "TSIndexSignature" || nodeType === "TSAbstractMethodDefinition" || nodeType === "TSAbstractPropertyDefinition" || nodeType === "TSAbstractAccessorProperty") {
+    return true;
+  }
+  if ((nodeType === "ClassMethod" || nodeType === "ClassProperty" || nodeType === "ClassPrivateProperty" || nodeType === "AccessorProperty") && (item.abstract === true || item.declare === true)) {
+    return true;
+  }
+  if (nodeType === "VariableDeclaration" && item.declare === true) {
+    return true;
+  }
+  if (nodeType === "ClassDeclaration" && item.declare === true) {
+    return true;
+  }
+  return false;
+}
+function stripTypeScriptAndTransformJsxAst(node, onJsxSeen = () => {
+}) {
+  var _a, _b, _c, _d, _e;
+  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 (isTsDeclarationOnlyNode(item)) {
+        continue;
+      }
+      if (item.type === "ImportDeclaration" && item.importKind === "type") {
+        continue;
+      }
+      if (item.type === "ExportAllDeclaration" && item.exportKind === "type") {
+        continue;
+      }
+      if (item.type === "ExportNamedDeclaration") {
+        if (item.exportKind === "type") continue;
+        if (item.declaration && isTsDeclarationOnlyNode(item.declaration)) {
+          continue;
+        }
+      }
+      if (item.type === "ExportDefaultDeclaration") {
+        if (item.declaration && isTsDeclarationOnlyNode(item.declaration)) {
+          continue;
+        }
+      }
+      const transformed = stripTypeScriptAndTransformJsxAst(item, onJsxSeen);
+      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.abstract;
+  delete node.importKind;
+  delete node.exportKind;
+  if (node.type !== "OptionalMemberExpression" && node.type !== "OptionalCallExpression") {
+    delete node.optional;
+  }
+  if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ObjectMethod" || node.type === "ClassMethod" || node.type === "ClassPrivateMethod") && Array.isArray(node.params) && ((_b = node.params[0]) == null ? void 0 : _b.type) === "Identifier" && ((_c = node.params[0]) == null ? void 0 : _c.name) === "this") {
+    node.params = node.params.slice(1);
+  }
+  if (node.type === "ClassMethod" && node.kind === "constructor" && Array.isArray(node.params) && ((_d = node.body) == null ? void 0 : _d.type) === "BlockStatement" && Array.isArray(node.body.body)) {
+    const paramPropAssignments = [];
+    for (const p of node.params) {
+      if ((p == null ? void 0 : p.type) === "TSParameterProperty") {
+        const inner = p.parameter;
+        const propName = (inner == null ? void 0 : inner.type) === "Identifier" ? inner.name : (inner == null ? void 0 : inner.type) === "AssignmentPattern" && ((_e = inner.left) == null ? void 0 : _e.type) === "Identifier" ? inner.left.name : null;
+        if (propName) {
+          paramPropAssignments.push(
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.memberExpression(t.thisExpression(), t.identifier(propName)),
+                t.identifier(propName)
+              )
+            )
+          );
+        }
+      }
+    }
+    if (paramPropAssignments.length > 0) {
+      const superIdx = node.body.body.findIndex(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (s) => {
+          var _a2, _b2;
+          return (s == null ? void 0 : s.type) === "ExpressionStatement" && ((_a2 = s.expression) == null ? void 0 : _a2.type) === "CallExpression" && ((_b2 = s.expression.callee) == null ? void 0 : _b2.type) === "Super";
+        }
+      );
+      const insertPos = superIdx >= 0 ? superIdx + 1 : 0;
+      node.body.body.splice(insertPos, 0, ...paramPropAssignments);
+    }
+  }
+  if (node.type === "TSParameterProperty") {
+    return stripTypeScriptAndTransformJsxAst(node.parameter, onJsxSeen);
+  }
+  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, onJsxSeen);
+    }
+  }
+  if (node.type === "JSXElement" || node.type === "JSXFragment") {
+    return transformJsxNode(node, onJsxSeen);
+  }
+  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 collectNamespaceMemberAccesses(ast, namespaceLocalNames) {
+  const accesses = /* @__PURE__ */ new Map();
+  if (namespaceLocalNames.size === 0) return accesses;
+  for (const name of namespaceLocalNames) {
+    accesses.set(name, /* @__PURE__ */ new Set());
+  }
+  function visit(node) {
+    var _a;
+    if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+    const typed = node;
+    if ((typed.type === "MemberExpression" || typed.type === "OptionalMemberExpression") && !typed.computed && typed.object.type === "Identifier" && namespaceLocalNames.has(typed.object.name) && typed.property.type === "Identifier") {
+      (_a = accesses.get(typed.object.name)) == null ? void 0 : _a.add(typed.property.name);
+    }
+    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 accesses;
+}
+function collectRuntimeReferencedIdentifiers(stmts) {
+  const refs = /* @__PURE__ */ new Set();
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        if (node[i]) walk(node[i]);
+      }
+      return;
+    }
+    if (node.type === "Identifier" && typeof node.name === "string") {
+      refs.add(node.name);
+    }
+    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") {
+        walk(val);
+      }
+    }
+  }
+  for (const stmt of stmts) {
+    if (stmt && stmt.type !== "ImportDeclaration") {
+      walk(stmt);
+    }
+  }
+  return refs;
+}
+function getLocalTypeOnlyDeclaredNames(localFilePath) {
+  var _a;
+  const typeNames = /* @__PURE__ */ new Set();
+  const valueNames = /* @__PURE__ */ new Set();
+  try {
+    if (!/\.(tsx?|mts|cts)$/i.test(localFilePath) || !fs$1.existsSync(localFilePath)) {
+      return typeNames;
+    }
+    const raw = fs$1.readFileSync(localFilePath, "utf-8");
+    const parsed = parse(raw, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx", "decorators-legacy"],
+      errorRecovery: true
+    });
+    for (const stmt of parsed.program.body) {
+      if (stmt.type === "ExportNamedDeclaration") {
+        if (stmt.exportKind === "type") {
+          if (stmt.declaration && "id" in stmt.declaration && ((_a = stmt.declaration.id) == null ? void 0 : _a.type) === "Identifier") {
+            typeNames.add(stmt.declaration.id.name);
+          }
+          for (const s of stmt.specifiers) {
+            if (s.type === "ExportSpecifier") {
+              const exp = s.exported.type === "Identifier" ? s.exported.name : s.exported.value;
+              typeNames.add(exp);
+            }
+          }
+          continue;
+        }
+        const decl = stmt.declaration;
+        if (decl) {
+          if (decl.type === "TSInterfaceDeclaration" || decl.type === "TSTypeAliasDeclaration") {
+            typeNames.add(decl.id.name);
+          } else if ((decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration" || decl.type === "TSEnumDeclaration") && decl.id) {
+            valueNames.add(decl.id.name);
+          } else if (decl.type === "VariableDeclaration") {
+            for (const d of decl.declarations) {
+              if (d.id.type === "Identifier") valueNames.add(d.id.name);
+            }
+          }
+        }
+      }
+    }
+    for (const v of valueNames) {
+      typeNames.delete(v);
+    }
+  } catch {
+  }
+  return typeNames;
+}
+function compileModuleForBrowser(options) {
+  const { filePath, targetProjectRoot, workspaceRoot = targetProjectRoot, versionTag } = 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 (ASSET_EXT_REGEX.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));
+  let emittedJsx = false;
+  if (isScreenFile) {
+    if (injectScreenAgyAttributes(ast, relPath)) {
+      emittedJsx = 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 resolveLocalOrAliasFile(specifier) {
+    if (specifier.startsWith(".")) {
+      const candidate = path.resolve(path.dirname(cleanFilePath), specifier);
+      return tryResolveLocalModule(candidate);
+    }
+    if (specifier.startsWith("@/") || specifier.startsWith("~/") || tsconfigAliases.some((m) => specifier === m.prefix || specifier.startsWith(m.prefix + "/"))) {
+      return resolveAlias(specifier);
+    }
+    return null;
+  }
+  function rewriteResolvedLocalFile(resolved, requestedExports) {
+    const normalized = resolved.replace(/\\/g, "/");
+    if (normalized.endsWith("/src/runtime/MockNavigationContext.tsx")) {
+      return `/@zelune/shim/stub.js?pkg=zelune-mock-nav&exports=${encodeURIComponent(
+        requestedExports.join(",")
+      )}`;
+    }
+    if (normalized.endsWith("/src/runtime/reactNativeShim.ts")) {
+      return "/@zelune/shim/react-native.js";
+    }
+    const vSuffix = versionTag ? `&t=${encodeURIComponent(versionTag)}` : "";
+    return `/@zelune/module?file=${encodeURIComponent(resolved)}${vSuffix}`;
+  }
+  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(".") || specifier.startsWith("@/") || specifier.startsWith("~/") || tsconfigAliases.some((m) => specifier === m.prefix || specifier.startsWith(m.prefix + "/"))) {
+      const resolved = resolveLocalOrAliasFile(specifier);
+      if (resolved) {
+        return rewriteResolvedLocalFile(resolved, requestedExports);
+      }
+      return `/@zelune/shim/stub.js?pkg=${encodeURIComponent(specifier)}&exports=${encodeURIComponent(
+        requestedExports.join(",")
+      )}`;
+    }
+    return `/@zelune/shim/stub.js?pkg=${encodeURIComponent(specifier)}&exports=${encodeURIComponent(
+      requestedExports.join(",")
+    )}`;
+  }
+  const sideEffectImportNodes = /* @__PURE__ */ new WeakSet();
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration" && stmt.specifiers.length === 0 && stmt.importKind !== "type") {
+      sideEffectImportNodes.add(stmt);
+    }
+  }
+  stripTypeScriptAndTransformJsxAst(ast, () => {
+    emittedJsx = true;
+  });
+  const hoistedRequireImports = [];
+  let reqCounter = 0;
+  function transformRequireCalls(node) {
+    var _a, _b;
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        if (node[i]) node[i] = transformRequireCalls(node[i]);
+      }
+      return node;
+    }
+    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] = transformRequireCalls(val);
+      }
+    }
+    if (node.type === "CallExpression" && ((_a = node.callee) == null ? void 0 : _a.type) === "Identifier" && node.callee.name === "require" && Array.isArray(node.arguments) && node.arguments.length === 1 && ((_b = node.arguments[0]) == null ? void 0 : _b.type) === "StringLiteral") {
+      const rawSpec = node.arguments[0].value;
+      const localResolved = resolveLocalOrAliasFile(rawSpec);
+      if (localResolved && ASSET_EXT_REGEX.test(path.extname(localResolved))) {
+        const assetUrl = `/@zelune/asset?file=${encodeURIComponent(localResolved)}`;
+        return t.objectExpression([
+          t.objectProperty(t.identifier("uri"), t.stringLiteral(assetUrl))
+        ]);
+      }
+      if (ASSET_EXT_REGEX.test(rawSpec)) {
+        return t.objectExpression([
+          t.objectProperty(t.identifier("uri"), t.stringLiteral(""))
+        ]);
+      }
+      const reqIdent = t.identifier(`__zeluneReq_${reqCounter++}`);
+      const rewritten = localResolved ? rewriteResolvedLocalFile(localResolved, []) : rewriteSpecifier(rawSpec, []);
+      hoistedRequireImports.push(
+        t.importDeclaration([t.importNamespaceSpecifier(reqIdent)], t.stringLiteral(rewritten))
+      );
+      return t.logicalExpression(
+        "??",
+        t.optionalMemberExpression(reqIdent, t.identifier("default"), false, true),
+        reqIdent
+      );
+    }
+    return node;
+  }
+  transformRequireCalls(ast.program.body);
+  const runtimeReferencedIds = collectRuntimeReferencedIdentifiers(ast.program.body);
+  const elidedBody = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      if (sideEffectImportNodes.has(stmt)) {
+        elidedBody.push(stmt);
+        continue;
+      }
+      stmt.specifiers = stmt.specifiers.filter((spec) => runtimeReferencedIds.has(spec.local.name));
+      if (stmt.specifiers.length > 0) {
+        elidedBody.push(stmt);
+      }
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.source && !stmt.declaration && stmt.specifiers.length > 0) {
+      const localTarget = resolveLocalOrAliasFile(stmt.source.value);
+      if (localTarget) {
+        const typeOnlyNames = getLocalTypeOnlyDeclaredNames(localTarget);
+        if (typeOnlyNames.size > 0) {
+          stmt.specifiers = stmt.specifiers.filter((spec) => {
+            if (spec.type !== "ExportSpecifier") return true;
+            return !typeOnlyNames.has(spec.local.name);
+          });
+          if (stmt.specifiers.length === 0) {
+            continue;
+          }
+        }
+      }
+    }
+    elidedBody.push(stmt);
+  }
+  ast.program.body = elidedBody;
+  const namespaceLocals = /* @__PURE__ */ new Set();
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      for (const spec of stmt.specifiers) {
+        if (spec.type === "ImportNamespaceSpecifier") {
+          namespaceLocals.add(spec.local.name);
+        }
+      }
+    }
+  }
+  const namespaceMemberMap = collectNamespaceMemberAccesses(ast, namespaceLocals);
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      const requested = [];
+      for (const spec of stmt.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+          if (importedName && importedName !== "default") {
+            requested.push(importedName);
+          }
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          const accessed = namespaceMemberMap.get(spec.local.name);
+          if (accessed) {
+            for (const memberName of accessed) {
+              if (memberName !== "default") requested.push(memberName);
+            }
+          }
+        }
+      }
+      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.name;
+            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 (hoistedRequireImports.length > 0) {
+    ast.program.body.unshift(...hoistedRequireImports);
+  }
+  if (emittedJsx) {
+    ast.program.body.unshift(
+      t.importDeclaration(
+        [t.importDefaultSpecifier(t.identifier(ZELUNE_JSX_REACT_IDENT))],
+        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",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm"
+};
+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"
+];
+const DEFAULT_MOCK_NAV_EXPORTS = [
+  "MockNavigationProvider",
+  "useNavigation",
+  "useRoute",
+  "useFocusEffect",
+  "useIsFocused",
+  "useScrollToTop",
+  "NavigationContainer",
+  "CommonActions",
+  "StackActions",
+  "createNativeStackNavigator",
+  "createStackNavigator",
+  "createBottomTabNavigator",
+  "createDrawerNavigator",
+  "createMaterialTopTabNavigator",
+  "DefaultTheme",
+  "DarkTheme",
+  "ThemeProvider",
+  "useTheme",
+  "useNavigationContainerRef",
+  "useRouter",
+  "router",
+  "useLocalSearchParams",
+  "useGlobalSearchParams",
+  "usePathname",
+  "useSegments",
+  "useRootNavigationState",
+  "Link",
+  "Redirect",
+  "Stack",
+  "Tabs",
+  "Drawer",
+  "Slot",
+  "SplashScreen",
+  "SafeAreaProvider",
+  "SafeAreaView",
+  "useSafeAreaInsets",
+  "useSafeAreaFrame",
+  "SafeAreaInsetsContext",
+  "SafeAreaFrameContext",
+  "withSafeAreaInsets",
+  "initialWindowMetrics",
+  "StatusBar",
+  "createVectorIconComponent",
+  "Ionicons",
+  "Feather",
+  "MaterialIcons",
+  "MaterialCommunityIcons",
+  "FontAwesome",
+  "FontAwesome5",
+  "FontAwesome6",
+  "AntDesign",
+  "Entypo",
+  "EvilIcons",
+  "Foundation",
+  "Octicons",
+  "SimpleLineIcons",
+  "Zocial",
+  "Fontisto",
+  "createIconSet",
+  "createIconSetFromIcoMoon",
+  "createIconSetFromFontello",
+  "LinearGradient",
+  "BlurView",
+  "Image",
+  "ImageBackground",
+  "FlashList",
+  "Svg",
+  "Circle",
+  "Ellipse",
+  "G",
+  "SvgText",
+  "TSpan",
+  "TextPath",
+  "Path",
+  "Polygon",
+  "Polyline",
+  "Line",
+  "Rect",
+  "Use",
+  "SvgImage",
+  "Symbol",
+  "Defs",
+  "RadialGradient",
+  "Stop",
+  "ClipPath",
+  "Pattern",
+  "Mask",
+  "ForeignObject",
+  "SvgXml",
+  "SvgUri",
+  "FadeIn",
+  "FadeInDown",
+  "FadeInUp",
+  "FadeInLeft",
+  "FadeInRight",
+  "FadeOut",
+  "FadeOutDown",
+  "FadeOutUp",
+  "SlideInDown",
+  "SlideInUp",
+  "SlideInLeft",
+  "SlideInRight",
+  "SlideOutDown",
+  "SlideOutUp",
+  "SlideOutLeft",
+  "SlideOutRight",
+  "ZoomIn",
+  "ZoomOut",
+  "Layout",
+  "LinearTransition",
+  "SequencedTransition",
+  "FadingTransition",
+  "useSharedValue",
+  "useAnimatedStyle",
+  "useDerivedValue",
+  "useAnimatedProps",
+  "useAnimatedScrollHandler",
+  "useAnimatedRef",
+  "useAnimatedGestureHandler",
+  "withTiming",
+  "withSpring",
+  "withDelay",
+  "withSequence",
+  "withRepeat",
+  "cancelAnimation",
+  "runOnJS",
+  "runOnUI",
+  "interpolate",
+  "Extrapolation",
+  "Extrapolate",
+  "Easing",
+  "createAnimatedComponent",
+  "Animated",
+  "GestureHandlerRootView",
+  "ScrollView",
+  "FlatList",
+  "TouchableOpacity",
+  "TouchableHighlight",
+  "TouchableWithoutFeedback",
+  "Pressable",
+  "Swipeable",
+  "DrawerLayout",
+  "PanGestureHandler",
+  "TapGestureHandler",
+  "LongPressGestureHandler",
+  "GestureDetector",
+  "Gesture",
+  "State",
+  "Directions",
+  "ImpactFeedbackStyle",
+  "NotificationFeedbackType",
+  "impactAsync",
+  "notificationAsync",
+  "selectionAsync",
+  "Constants",
+  "useFonts",
+  "loadAsync",
+  "isLoaded",
+  "preventAutoHideAsync",
+  "hideAsync",
+  "AsyncStorage",
+  "getItemAsync",
+  "setItemAsync",
+  "deleteItemAsync",
+  "setStringAsync",
+  "getStringAsync",
+  "openURL",
+  "createURL",
+  "create",
+  "useStore",
+  "QueryClient",
+  "QueryClientProvider",
+  "useQueryClient",
+  "useQuery",
+  "useInfiniteQuery",
+  "useMutation",
+  "createSafeChainableProxy",
+  "SAFE_CHAINABLE_PROXY",
+  "z",
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "union",
+  "literal",
+  "record",
+  "tuple",
+  "any",
+  "unknown",
+  "optional",
+  "nullable",
+  "coerce",
+  "zodResolver",
+  "yupResolver",
+  "scale",
+  "verticalScale",
+  "moderateScale",
+  "moderateVerticalScale",
+  "s",
+  "vs",
+  "ms",
+  "mvs",
+  "RFValue",
+  "RFPercentage",
+  "widthPercentageToDP",
+  "heightPercentageToDP",
+  "wp",
+  "hp",
+  "clsx",
+  "cn",
+  "twMerge",
+  "styled",
+  "cssInterop",
+  "remapProps",
+  "tw",
+  "createTw",
+  "useForm",
+  "useFormContext",
+  "FormProvider",
+  "useWatch",
+  "useFieldArray",
+  "Controller",
+  "SAFE_CONTEXT_FALLBACK",
+  "createClient"
+];
+function safeRealpath(targetPath) {
+  try {
+    return fs$1.realpathSync(targetPath);
+  } catch {
+    return path.resolve(targetPath);
+  }
+}
+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(
+      [...DEFAULT_MOCK_NAV_EXPORTS, ...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 activeProjectRoot = getActiveProjectRoot(targetProjectRoot);
+  const allowedRoots = Array.from(
+    /* @__PURE__ */ new Set([
+      path.resolve(packageRoot),
+      safeRealpath(packageRoot),
+      path.resolve(targetProjectRoot),
+      safeRealpath(targetProjectRoot),
+      path.resolve(activeProjectRoot),
+      safeRealpath(activeProjectRoot),
+      path.resolve(workspaceRoot),
+      safeRealpath(workspaceRoot)
+    ])
+  );
+  function resolveCandidateFileParam(rawParam) {
+    const clean = rawParam.split("?")[0].trim();
+    if (!clean) return null;
+    const candidate = path.isAbsolute(clean) ? path.resolve(clean) : path.resolve(getActiveProjectRoot(targetProjectRoot), clean.replace(/^[/\\]+/, ""));
+    const lexicallyAllowed = allowedRoots.some(
+      (root) => candidate === root || candidate.startsWith(root + path.sep)
+    );
+    if (!lexicallyAllowed || !fs$1.existsSync(candidate)) {
+      return null;
+    }
+    const real = safeRealpath(candidate);
+    const canonicallyAllowed = allowedRoots.some(
+      (root) => real === root || real.startsWith(root + path.sep)
+    );
+    if (!canonicallyAllowed) {
+      return null;
+    }
+    return real;
+  }
+  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") ?? "";
+      const versionTag = searchParams.get("t") ?? void 0;
+      const resolvedFile = resolveCandidateFileParam(fileParam);
+      if (!resolvedFile) {
+        return sendJs(res, "// Module not found\nexport default {};\n");
+      }
+      try {
+        const compiled = compileModuleForBrowser({
+          filePath: resolvedFile,
+          targetProjectRoot: getActiveProjectRoot(targetProjectRoot),
+          workspaceRoot,
+          versionTag
+        });
+        return sendJs(res, compiled);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return sendJs(res, `throw new Error(${JSON.stringify(msg)});
+`);
+      }
+    }
+    if (pathname === "/@zelune/asset") {
+      const fileParam = searchParams.get("file") ?? "";
+      const resolvedAsset = resolveCandidateFileParam(fileParam);
+      if (!resolvedAsset) {
+        res.statusCode = 404;
+        return res.end("Not found");
+      }
+      const ext = path.extname(resolvedAsset).toLowerCase();
+      res.statusCode = 200;
+      res.setHeader("Content-Type", MIME_TYPES[ext] ?? "application/octet-stream");
+      return fs$1.createReadStream(resolvedAsset).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 safeThemeJson = JSON.stringify(tailwindTheme).replace(/</g, "\\u003c");
+      const safeManifestJson = JSON.stringify(discoveredManifest).replace(/</g, "\\u003c");
+      const runtimeScript = `<script>window.__ZELUNE_STUDIO_SERVER__ = true; window.__ZELUNE_TAILWIND_THEME__ = ${safeThemeJson}; window.__ZELUNE_SCREEN_MANIFEST__ = ${safeManifestJson};<\/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 +4028,7 @@ async function handleMcpJsonRpcRequest(request, customWorkspaceRoot) {
           },
           serverInfo: {
             name: "zelune",
-            version: "1.6.3"
+            version: "1.6.5"
           }
         }
       };
@@ -2254,7 +4127,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 +4138,6 @@ if (isDirectExecution) {
 export {
   MCP_TOOLS,
   handleMcpJsonRpcRequest,
-  startMcpServer
+  startMcpServer,
+  startStudioHttpServer
 };