@nasti-toolchain/nasti 2.4.2 → 2.4.4

package/dist/cli.cjs

@@ -5,10 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __glob = (map) => (path18) => {
-  var fn = map[path18];
+var __glob = (map) => (path19) => {
+  var fn = map[path19];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path18);
+  throw new Error("Module not found in bundle: " + path19);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -851,6 +851,24 @@ var init_module_graph = __esm({
       getModulesByFile(file) {
         return this.fileToModulesMap.get(file);
       }
+      /**
+       * Modules whose registered entry file lives under `dir` (inclusive).
+       * Used when a non-entry source inside a prebundled workspace package changes:
+       * only the package entry was registered, so getModulesByFile(changedFile)
+       * misses — we invalidate every /@modules entry rooted in that package.
+       */
+      getModulesWithFileUnder(dir) {
+        const result = /* @__PURE__ */ new Set();
+        const normDir = dir.replace(/\\/g, "/");
+        const normPrefix = normDir.endsWith("/") ? normDir : normDir + "/";
+        for (const [file, mods] of this.fileToModulesMap) {
+          const normFile = file.replace(/\\/g, "/");
+          if (normFile === normDir || normFile.startsWith(normPrefix)) {
+            for (const m of mods) result.add(m);
+          }
+        }
+        return result;
+      }
       async ensureEntryFromUrl(url) {
         const normalizedUrl = removeTimestampQuery(url);
         let mod = this.urlToModuleMap.get(normalizedUrl);
@@ -1583,6 +1601,120 @@ var init_assets = __esm({
   }
 });
 
+// src/server/fs-allow.ts
+function isUnderRoot(abs, root) {
+  const rel = import_node_path5.default.relative(root, abs);
+  return !!rel && !rel.startsWith("..") && !import_node_path5.default.isAbsolute(rel);
+}
+function discoverLinkedPackageRoots(projectRoot, maxDepth = 4) {
+  const results = [];
+  const seenReal = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set([projectRoot]);
+  const queue = [projectRoot];
+  for (let depth = 0; depth < maxDepth && queue.length > 0; depth++) {
+    const levelCount = queue.length;
+    for (let i = 0; i < levelCount; i++) {
+      const dir = queue.shift();
+      const nm = import_node_path5.default.join(dir, "node_modules");
+      let entries;
+      try {
+        entries = import_node_fs5.default.readdirSync(nm, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const ent of entries) {
+        if (ent.name.startsWith(".") || ent.name === "node_modules") continue;
+        const pkgNames = ent.name.startsWith("@") ? listScopedPackages(nm, ent.name) : [ent.name];
+        for (const pkgName of pkgNames) {
+          const pkgPath = import_node_path5.default.join(nm, pkgName);
+          let real;
+          try {
+            real = import_node_fs5.default.realpathSync(pkgPath);
+          } catch {
+            continue;
+          }
+          if (seenReal.has(real)) continue;
+          seenReal.add(real);
+          if (!queued.has(real)) {
+            queued.add(real);
+            queue.push(real);
+          }
+          if (real !== projectRoot && !isUnderRoot(real, projectRoot) && !real.includes(NM)) {
+            results.push(real);
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function listScopedPackages(nm, scope) {
+  try {
+    return import_node_fs5.default.readdirSync(import_node_path5.default.join(nm, scope)).filter((name) => !name.startsWith(".")).map((name) => import_node_path5.default.join(scope, name));
+  } catch {
+    return [];
+  }
+}
+function getLinkedPackageRoots(projectRoot) {
+  let mtimeMs = 0;
+  try {
+    mtimeMs = import_node_fs5.default.statSync(import_node_path5.default.join(projectRoot, "node_modules")).mtimeMs;
+  } catch {
+    mtimeMs = 0;
+  }
+  const cached2 = linkedRootsCache.get(projectRoot);
+  if (cached2 && cached2.mtimeMs === mtimeMs) {
+    return cached2.roots;
+  }
+  const roots = discoverLinkedPackageRoots(projectRoot);
+  linkedRootsCache.set(projectRoot, { roots, mtimeMs });
+  return roots;
+}
+function clearLinkedPackageRootsCache() {
+  linkedRootsCache.clear();
+}
+function isAllowedDevModulePath(realId, projectRoot) {
+  if (realId === projectRoot || isUnderRoot(realId, projectRoot)) return true;
+  for (const pkgRoot of getLinkedPackageRoots(projectRoot)) {
+    if (realId === pkgRoot || realId.startsWith(pkgRoot + import_node_path5.default.sep)) return true;
+  }
+  let dir = projectRoot;
+  for (; ; ) {
+    const nm = import_node_path5.default.join(dir, "node_modules");
+    if (realId === nm || realId.startsWith(nm + import_node_path5.default.sep)) return true;
+    const parent = import_node_path5.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+function findNearestPackageRoot(file) {
+  let dir = import_node_path5.default.dirname(file);
+  for (; ; ) {
+    const pkgJson = import_node_path5.default.join(dir, "package.json");
+    if (import_node_fs5.default.existsSync(pkgJson)) {
+      try {
+        const pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgJson, "utf-8"));
+        if (typeof pkg?.name === "string" && pkg.name) return dir;
+      } catch {
+      }
+    }
+    const parent = import_node_path5.default.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+var import_node_fs5, import_node_path5, NM, linkedRootsCache;
+var init_fs_allow = __esm({
+  "src/server/fs-allow.ts"() {
+    "use strict";
+    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
+    NM = `${import_node_path5.default.sep}node_modules${import_node_path5.default.sep}`;
+    linkedRootsCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/server/middleware.ts
 function getReactRefreshRuntimeEsm(includeBoundaryHelpers = false) {
   if (__refreshRuntimeCache) {
@@ -1591,10 +1723,10 @@ function getReactRefreshRuntimeEsm(includeBoundaryHelpers = false) {
   let cjsPath;
   try {
     const pkgPath = __require.resolve("react-refresh/package.json");
-    cjsPath = import_node_path5.default.join(import_node_path5.default.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+    cjsPath = import_node_path6.default.join(import_node_path6.default.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
-    cjsPath = import_node_path5.default.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
-    if (!import_node_fs5.default.existsSync(cjsPath)) {
+    cjsPath = import_node_path6.default.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    if (!import_node_fs6.default.existsSync(cjsPath)) {
       const origMsg = err instanceof Error ? err.message : String(err);
       throw new Error(
         `[nasti] Missing dependency "react-refresh". Install it with: npm install react-refresh
@@ -1602,7 +1734,7 @@ Original resolve error: ${origMsg}`
       );
     }
   }
-  const cjsSource = import_node_fs5.default.readFileSync(cjsPath, "utf-8");
+  const cjsSource = import_node_fs6.default.readFileSync(cjsPath, "utf-8");
   __refreshRuntimeCache = `// Wrapped react-refresh runtime -> ESM
 const exports = {};
 const module = { exports };
@@ -1773,8 +1905,8 @@ async function transformRequest(url, ctx) {
     let realIdValid = false;
     try {
       if (idParam) {
-        realId = import_node_fs5.default.realpathSync(idParam);
-        realIdValid = import_node_fs5.default.statSync(realId).isFile() && (realId.includes(`${import_node_path5.default.sep}node_modules${import_node_path5.default.sep}`) || isUnderRoot(realId, config.root));
+        realId = import_node_fs6.default.realpathSync(idParam);
+        realIdValid = import_node_fs6.default.statSync(realId).isFile() && isAllowedDevModulePath(realId, config.root);
       }
     } catch {
       realId = null;
@@ -1841,7 +1973,7 @@ async function transformRequest(url, ctx) {
     }
   }
   const filePath = resolveUrlToFile(url, config.root);
-  if (!filePath || !import_node_fs5.default.existsSync(filePath)) return null;
+  if (!filePath || !import_node_fs6.default.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
   moduleGraph.registerModule(mod, filePath);
   const transformVersion = mod.invalidationVersion;
@@ -1852,7 +1984,7 @@ async function transformRequest(url, ctx) {
     return transformResult2;
   }
   const loaded = await pluginContainer.load(filePath);
-  let code = loaded == null ? import_node_fs5.default.readFileSync(filePath, "utf-8") : typeof loaded === "string" ? loaded : loaded.code;
+  let code = loaded == null ? import_node_fs6.default.readFileSync(filePath, "utf-8") : typeof loaded === "string" ? loaded : loaded.code;
   let map = loaded && typeof loaded !== "string" ? loaded.map : void 0;
   const pluginResult = await pluginContainer.transform(code, filePath);
   if (pluginResult) {
@@ -1910,7 +2042,7 @@ async function loadVirtualModule(spec, ctx) {
   const resolved = await pluginContainer.resolveId(spec);
   if (resolved == null) return null;
   const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
-  const looksVirtual = resolvedId.startsWith("\0") || !import_node_fs5.default.existsSync(resolvedId);
+  const looksVirtual = resolvedId.startsWith("\0") || !import_node_fs6.default.existsSync(resolvedId);
   if (!looksVirtual) return null;
   const loadResult = await pluginContainer.load(resolvedId);
   if (loadResult == null) return null;
@@ -1924,7 +2056,7 @@ async function loadVirtualModule(spec, ctx) {
     config.mode,
     ssrDefineOverrides(ctx.environment?.consumer ?? "client")
   ));
-  const anchor = import_node_path5.default.join(config.root, "__nasti_virtual__.ts");
+  const anchor = import_node_path6.default.join(config.root, "__nasti_virtual__.ts");
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
@@ -1950,7 +2082,7 @@ async function doBundlePackage(entryFile, root) {
   await bundle2.close();
   let code = result.output[0].code;
   code = code.replace(/process\.env\.NODE_ENV/g, '"development"');
-  const externalBaseDir = import_node_path5.default.dirname(entryFile);
+  const externalBaseDir = import_node_path6.default.dirname(entryFile);
   code = code.replace(
     /^(import\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm,
     (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir, root)}${q}`
@@ -1968,16 +2100,16 @@ async function doBundlePackage(entryFile, root) {
   return code;
 }
 async function tryGenerateSubpathShim(entryFile, root) {
-  const NM = `${import_node_path5.default.sep}node_modules${import_node_path5.default.sep}`;
-  if (!entryFile.includes(NM)) return null;
+  const NM2 = `${import_node_path6.default.sep}node_modules${import_node_path6.default.sep}`;
+  if (!entryFile.includes(NM2)) return null;
   let pkgDir = null;
   let pkgName = null;
-  let dir = import_node_path5.default.dirname(entryFile);
+  let dir = import_node_path6.default.dirname(entryFile);
   while (true) {
-    const pkgJsonPath = import_node_path5.default.join(dir, "package.json");
-    if (import_node_fs5.default.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = import_node_path6.default.join(dir, "package.json");
+    if (import_node_fs6.default.existsSync(pkgJsonPath)) {
       try {
-        const pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgJsonPath, "utf-8"));
+        const pkg = JSON.parse(import_node_fs6.default.readFileSync(pkgJsonPath, "utf-8"));
         if (typeof pkg?.name === "string" && pkg.name) {
           pkgDir = dir;
           pkgName = pkg.name;
@@ -1986,16 +2118,16 @@ async function tryGenerateSubpathShim(entryFile, root) {
       } catch {
       }
     }
-    const parent = import_node_path5.default.dirname(dir);
+    const parent = import_node_path6.default.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
-    if (!dir.includes(NM)) return null;
+    if (!dir.includes(NM2)) return null;
   }
   if (!pkgDir || !pkgName) return null;
-  const entryExt = import_node_path5.default.extname(entryFile);
+  const entryExt = import_node_path6.default.extname(entryFile);
   const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
   if (!mainEntry) return null;
-  if (import_node_path5.default.resolve(mainEntry) === import_node_path5.default.resolve(entryFile)) return null;
+  if (import_node_path6.default.resolve(mainEntry) === import_node_path6.default.resolve(entryFile)) return null;
   let mainNs;
   let subNs;
   try {
@@ -2019,7 +2151,7 @@ async function tryGenerateSubpathShim(entryFile, root) {
     if (mainNs["default"] !== subNs["default"]) return null;
   }
   const rootMain = resolveNodeModule(root, pkgName);
-  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + import_node_path5.default.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
+  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + import_node_path6.default.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
   const lines = [
     `// Nasti subpath shim \u2192 ${pkgName} (avoid duplicate bundling)`,
     `import * as __pkg from "${mainEntryUrl}";`
@@ -2033,10 +2165,10 @@ async function tryGenerateSubpathShim(entryFile, root) {
   return lines.join("\n") + "\n";
 }
 function pickMainEntryByExtension(pkgDir, preferredExt) {
-  const pkgJsonPath = import_node_path5.default.join(pkgDir, "package.json");
+  const pkgJsonPath = import_node_path6.default.join(pkgDir, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(import_node_fs6.default.readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2055,14 +2187,14 @@ function pickMainEntryByExtension(pkgDir, preferredExt) {
   if (typeof pkg.module === "string") candidates.push(pkg.module);
   if (typeof pkg.main === "string") candidates.push(pkg.main);
   for (const cand of candidates) {
-    if (import_node_path5.default.extname(cand) === preferredExt) {
-      const full = import_node_path5.default.resolve(pkgDir, cand);
-      if (import_node_fs5.default.existsSync(full)) return full;
+    if (import_node_path6.default.extname(cand) === preferredExt) {
+      const full = import_node_path6.default.resolve(pkgDir, cand);
+      if (import_node_fs6.default.existsSync(full)) return full;
     }
   }
   for (const cand of candidates) {
-    const full = import_node_path5.default.resolve(pkgDir, cand);
-    if (import_node_fs5.default.existsSync(full)) return full;
+    const full = import_node_path6.default.resolve(pkgDir, cand);
+    if (import_node_fs6.default.existsSync(full)) return full;
   }
   return null;
 }
@@ -2087,8 +2219,8 @@ function rewriteExternalRequires(code, baseDir, root) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire6 } = await import("module");
-    const req = createRequire6(entryFile);
+    const { createRequire: createRequire7 } = await import("module");
+    const req = createRequire7(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -2129,11 +2261,22 @@ function rewriteImports(code, config, filePath, importedUrls, moduleGraph) {
 }
 function createModuleSpecifierResolver(config, filePath) {
   const root = config.root;
-  const fileDir = import_node_path5.default.dirname(filePath);
+  const fileDir = import_node_path6.default.dirname(filePath);
   const aliasEntries = Object.entries(config.resolve.alias).sort(
     ([a], [b]) => b.length - a.length
   );
-  const toRootUrl = (abs) => "/" + import_node_path5.default.relative(root, abs).replace(/\\/g, "/");
+  const toServableUrl = (abs) => {
+    if (isUnderRoot(abs, root)) {
+      return "/" + import_node_path6.default.relative(root, abs).replace(/\\/g, "/");
+    }
+    for (const pkgRoot of getLinkedPackageRoots(root)) {
+      if (abs === pkgRoot || abs.startsWith(pkgRoot + import_node_path6.default.sep)) {
+        const normalized = abs.replace(/\\/g, "/");
+        return "/@fs/" + (normalized.startsWith("/") ? normalized.slice(1) : normalized);
+      }
+    }
+    return null;
+  };
   return (specifier) => {
     const suffixMatch = specifier.match(/[?#].*$/);
     const suffix = suffixMatch ? suffixMatch[0] : "";
@@ -2142,18 +2285,21 @@ function createModuleSpecifierResolver(config, filePath) {
       if (baseSpec === key || baseSpec.startsWith(key + "/")) {
         const aliasBase = resolveAliasTarget(value, root);
         const sub = baseSpec.slice(key.length).replace(/^\//, "");
-        const target = sub ? import_node_path5.default.join(aliasBase, sub) : aliasBase;
+        const target = sub ? import_node_path6.default.join(aliasBase, sub) : aliasBase;
         const resolved = tryResolveDiskPath(target);
-        return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
+        const url = resolved ? toServableUrl(resolved) : null;
+        return url ? url + suffix : specifier;
       }
     }
     if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
-      const resolved = tryResolveDiskPath(import_node_path5.default.resolve(fileDir, baseSpec));
-      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
+      const resolved = tryResolveDiskPath(import_node_path6.default.resolve(fileDir, baseSpec));
+      const url = resolved ? toServableUrl(resolved) : null;
+      return url ? url + suffix : specifier;
     }
     if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
-      const resolved = tryResolveDiskPath(import_node_path5.default.join(root, baseSpec.replace(/^\//, "")));
-      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
+      const resolved = tryResolveDiskPath(import_node_path6.default.join(root, baseSpec.replace(/^\//, "")));
+      const url = resolved ? toServableUrl(resolved) : null;
+      return url ? url + suffix : specifier;
     }
     if (baseSpec.startsWith("/")) return specifier;
     return `/@modules/${specifier}`;
@@ -2306,28 +2452,24 @@ function maskStringsAndComments(code) {
   return masked.join("");
 }
 function resolveAliasTarget(value, root) {
-  if (import_node_path5.default.isAbsolute(value) && import_node_fs5.default.existsSync(value)) return value;
-  if (value.startsWith("/")) return import_node_path5.default.join(root, value.slice(1));
-  return import_node_path5.default.resolve(root, value);
+  if (import_node_path6.default.isAbsolute(value) && import_node_fs6.default.existsSync(value)) return value;
+  if (value.startsWith("/")) return import_node_path6.default.join(root, value.slice(1));
+  return import_node_path6.default.resolve(root, value);
 }
 function tryResolveDiskPath(target) {
-  if (import_node_fs5.default.existsSync(target) && import_node_fs5.default.statSync(target).isFile()) return target;
+  if (import_node_fs6.default.existsSync(target) && import_node_fs6.default.statSync(target).isFile()) return target;
   for (const ext of RESOLVE_EXTENSIONS) {
     const withExt = target + ext;
-    if (import_node_fs5.default.existsSync(withExt) && import_node_fs5.default.statSync(withExt).isFile()) return withExt;
+    if (import_node_fs6.default.existsSync(withExt) && import_node_fs6.default.statSync(withExt).isFile()) return withExt;
   }
-  if (import_node_fs5.default.existsSync(target) && import_node_fs5.default.statSync(target).isDirectory()) {
+  if (import_node_fs6.default.existsSync(target) && import_node_fs6.default.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const idx = import_node_path5.default.join(target, "index" + ext);
-      if (import_node_fs5.default.existsSync(idx) && import_node_fs5.default.statSync(idx).isFile()) return idx;
+      const idx = import_node_path6.default.join(target, "index" + ext);
+      if (import_node_fs6.default.existsSync(idx) && import_node_fs6.default.statSync(idx).isFile()) return idx;
     }
   }
   return null;
 }
-function isUnderRoot(abs, root) {
-  const rel = import_node_path5.default.relative(root, abs);
-  return !!rel && !rel.startsWith("..") && !import_node_path5.default.isAbsolute(rel);
-}
 function appendTimestampQuery(url, timestamp) {
   const hashIndex = url.indexOf("#");
   const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
@@ -2345,7 +2487,7 @@ function resolveNodeModule(baseDir, moduleName) {
   const resolved = resolveNodeModuleEntry(baseDir, moduleName);
   if (!resolved) return null;
   try {
-    return import_node_fs5.default.realpathSync(resolved);
+    return import_node_fs6.default.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -2365,21 +2507,21 @@ function resolveNodeModuleEntry(root, moduleName) {
   let pkgDir = null;
   let dir = root;
   for (; ; ) {
-    const candidate = import_node_path5.default.join(dir, "node_modules", pkgName);
-    if (import_node_fs5.default.existsSync(candidate)) {
+    const candidate = import_node_path6.default.join(dir, "node_modules", pkgName);
+    if (import_node_fs6.default.existsSync(candidate)) {
       pkgDir = candidate;
       break;
     }
-    const parent = import_node_path5.default.dirname(dir);
+    const parent = import_node_path6.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   if (!pkgDir) return null;
-  const pkgJsonPath = import_node_path5.default.join(pkgDir, "package.json");
-  if (!import_node_fs5.default.existsSync(pkgJsonPath)) return null;
+  const pkgJsonPath = import_node_path6.default.join(pkgDir, "package.json");
+  if (!import_node_fs6.default.existsSync(pkgJsonPath)) return null;
   let pkg;
   try {
-    pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(import_node_fs6.default.readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2392,32 +2534,32 @@ function resolveNodeModuleEntry(root, moduleName) {
     const subDirs = [""];
     for (const field of ["module", "main"]) {
       if (typeof pkg[field] === "string") {
-        const dir2 = import_node_path5.default.dirname(pkg[field]);
+        const dir2 = import_node_path6.default.dirname(pkg[field]);
         if (dir2 && dir2 !== "." && !subDirs.includes(dir2)) subDirs.push(dir2);
       }
     }
     for (const dir2 of subDirs) {
-      const direct = import_node_path5.default.join(pkgDir, dir2, subpath);
-      if (import_node_fs5.default.existsSync(direct) && import_node_fs5.default.statSync(direct).isFile()) return direct;
+      const direct = import_node_path6.default.join(pkgDir, dir2, subpath);
+      if (import_node_fs6.default.existsSync(direct) && import_node_fs6.default.statSync(direct).isFile()) return direct;
       for (const ext of RESOLVE_EXTENSIONS) {
-        if (import_node_fs5.default.existsSync(direct + ext)) return direct + ext;
+        if (import_node_fs6.default.existsSync(direct + ext)) return direct + ext;
       }
     }
     return null;
   }
   for (const field of ["module", "jsnext:main", "jsnext", "main"]) {
     if (typeof pkg[field] === "string") {
-      const entry = import_node_path5.default.join(pkgDir, pkg[field]);
-      if (import_node_fs5.default.existsSync(entry)) return entry;
+      const entry = import_node_path6.default.join(pkgDir, pkg[field]);
+      if (import_node_fs6.default.existsSync(entry)) return entry;
     }
   }
-  const indexFallback = import_node_path5.default.join(pkgDir, "index.js");
-  if (import_node_fs5.default.existsSync(indexFallback)) return indexFallback;
+  const indexFallback = import_node_path6.default.join(pkgDir, "index.js");
+  if (import_node_fs6.default.existsSync(indexFallback)) return indexFallback;
   return null;
 }
 function resolvePackageExports(exports2, key, pkgDir) {
   if (typeof exports2 === "string") {
-    return key === "." ? import_node_path5.default.join(pkgDir, exports2) : null;
+    return key === "." ? import_node_path6.default.join(pkgDir, exports2) : null;
   }
   const entry = exports2[key];
   if (entry === void 0) {
@@ -2429,7 +2571,7 @@ function resolvePackageExports(exports2, key, pkgDir) {
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
-  if (typeof value === "string") return import_node_path5.default.join(pkgDir, value);
+  if (typeof value === "string") return import_node_path6.default.join(pkgDir, value);
   if (Array.isArray(value)) {
     for (const item of value) {
       const r = resolveExportValue(item, pkgDir);
@@ -2448,35 +2590,54 @@ function resolveExportValue(value, pkgDir) {
   return null;
 }
 function resolveUrlToFile(url, root) {
-  const cleanUrl = url.split("?")[0];
+  const cleanUrl = url.split(/[?#]/)[0];
   if (cleanUrl.startsWith("/@modules/")) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     return resolveNodeModule(root, moduleName);
   }
-  const filePath = import_node_path5.default.resolve(root, cleanUrl.replace(/^\//, ""));
-  if (import_node_fs5.default.existsSync(filePath) && import_node_fs5.default.statSync(filePath).isFile()) {
+  if (cleanUrl.startsWith("/@fs/")) {
+    let abs = cleanUrl.slice("/@fs/".length);
+    if (process.platform === "win32") {
+      abs = abs.replace(/\//g, import_node_path6.default.sep);
+    } else if (!abs.startsWith("/")) {
+      abs = "/" + abs;
+    }
+    try {
+      const real = import_node_fs6.default.realpathSync(abs);
+      if (import_node_fs6.default.statSync(real).isFile() && isAllowedDevModulePath(real, root)) return real;
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const filePath = import_node_path6.default.resolve(root, cleanUrl.replace(/^\//, ""));
+  if (import_node_fs6.default.existsSync(filePath) && import_node_fs6.default.statSync(filePath).isFile()) {
     return filePath;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
     const withExt = filePath + ext;
-    if (import_node_fs5.default.existsSync(withExt)) return withExt;
+    if (import_node_fs6.default.existsSync(withExt)) return withExt;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexFile = import_node_path5.default.join(filePath, "index" + ext);
-    if (import_node_fs5.default.existsSync(indexFile)) return indexFile;
+    const indexFile = import_node_path6.default.join(filePath, "index" + ext);
+    if (import_node_fs6.default.existsSync(indexFile)) return indexFile;
   }
   return null;
 }
 function isModuleRequest(url, destination) {
-  const cleanUrl = url.split("?")[0];
+  const cleanUrl = url.split(/[?#]/)[0];
   if (/\.(ts|tsx|jsx|js|mjs|vue|css|json)$/.test(cleanUrl)) return true;
   if (cleanUrl.startsWith("/@modules/")) return true;
+  if (cleanUrl.startsWith("/@fs/")) return true;
   if (isAssetFile(cleanUrl)) {
-    const query = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
+    const qIdx = url.indexOf("?");
+    const hIdx = url.indexOf("#");
+    const queryEnd = hIdx === -1 ? url.length : hIdx;
+    const query = qIdx === -1 || qIdx > queryEnd ? "" : url.slice(qIdx + 1, queryEnd);
     const isExplicitAssetModule = /(?:^|&)(?:url|raw)(?:&|$)/.test(query);
     return isExplicitAssetModule || destination === "script";
   }
-  if (!import_node_path5.default.extname(cleanUrl)) return true;
+  if (!import_node_path6.default.extname(cleanUrl)) return true;
   return false;
 }
 function getHmrClientCode() {
@@ -2706,12 +2867,12 @@ function clearCustomListeners(ownerPath) {
 }
 `;
 }
-var import_node_path5, import_node_fs5, import_node_module, import_node_url2, import_picocolors3, import_meta, __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_BOUNDARY_HELPERS, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
+var import_node_path6, import_node_fs6, import_node_module, import_node_url2, import_picocolors3, import_meta, __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_BOUNDARY_HELPERS, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
-    import_node_path5 = __toESM(require("path"), 1);
-    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
+    import_node_fs6 = __toESM(require("fs"), 1);
     import_node_module = require("module");
     import_node_url2 = require("url");
     import_picocolors3 = __toESM(require("picocolors"), 1);
@@ -2720,8 +2881,9 @@ var init_middleware = __esm({
     init_env();
     init_url();
     init_assets();
+    init_fs_allow();
     import_meta = {};
-    __dirname_esm = import_node_path5.default.dirname((0, import_node_url2.fileURLToPath)(import_meta.url));
+    __dirname_esm = import_node_path6.default.dirname((0, import_node_url2.fileURLToPath)(import_meta.url));
     __require = (0, import_node_module.createRequire)(import_meta.url);
     __refreshRuntimeCache = null;
     REACT_REFRESH_BOUNDARY_HELPERS = `
@@ -2810,9 +2972,26 @@ async function handleFileChange(file, server, environmentName = "client", timest
   }
   const moduleGraph = environment.moduleGraph;
   const logger = config.logger;
-  const relativePath = "/" + import_node_path6.default.relative(config.root, file);
-  const shortFile = import_node_path6.default.relative(config.root, file);
-  const mods = moduleGraph.getModulesByFile(file);
+  const relativePath = "/" + import_node_path7.default.relative(config.root, file);
+  const shortFile = import_node_path7.default.relative(config.root, file);
+  let mods = moduleGraph.getModulesByFile(file);
+  if (!mods || mods.size === 0) {
+    try {
+      const real = import_node_fs7.default.realpathSync(file);
+      if (real !== file) mods = moduleGraph.getModulesByFile(real);
+      if (mods && mods.size > 0) file = real;
+    } catch {
+    }
+  }
+  if (!mods || mods.size === 0) {
+    const packageRoot = findNearestPackageRoot(file);
+    if (packageRoot && getLinkedPackageRoots(config.root).some(
+      (r) => packageRoot === r || packageRoot.startsWith(r + import_node_path7.default.sep)
+    )) {
+      const under = moduleGraph.getModulesWithFileUnder(packageRoot);
+      if (under.size > 0) mods = under;
+    }
+  }
   if (!mods || mods.size === 0) {
     return null;
   }
@@ -2827,7 +3006,7 @@ async function handleFileChange(file, server, environmentName = "client", timest
       file,
       timestamp,
       modules: [mod],
-      read: () => import_node_fs6.default.readFileSync(file, "utf-8"),
+      read: () => import_node_fs7.default.readFileSync(file, "utf-8"),
       server,
       environment
     };
@@ -2888,20 +3067,21 @@ async function handleFileChange(file, server, environmentName = "client", timest
     fullReload
   };
 }
-var import_node_path6, import_node_fs6, import_picocolors4;
+var import_node_path7, import_node_fs7, import_picocolors4;
 var init_hmr = __esm({
   "src/server/hmr.ts"() {
     "use strict";
-    import_node_path6 = __toESM(require("path"), 1);
-    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
+    import_node_fs7 = __toESM(require("fs"), 1);
     import_picocolors4 = __toESM(require("picocolors"), 1);
+    init_fs_allow();
   }
 });
 
 // src/plugins/resolve.ts
 function resolvePlugin(config) {
   const { alias, extensions } = config.resolve;
-  const require2 = (0, import_node_module2.createRequire)(import_node_path7.default.resolve(config.root, "package.json"));
+  const require2 = (0, import_node_module2.createRequire)(import_node_path8.default.resolve(config.root, "package.json"));
   const aliasEntries = Object.entries(alias).sort(
     ([a], [b]) => b.length - a.length
   );
@@ -2909,10 +3089,10 @@ function resolvePlugin(config) {
   if (config.framework === "vue") {
     try {
       const vuePkgJson = require2.resolve("vue/package.json", { paths: [config.root] });
-      const vueDir = import_node_path7.default.dirname(vuePkgJson);
-      const mod = JSON.parse(import_node_fs7.default.readFileSync(vuePkgJson, "utf-8")).module;
-      const entry = import_node_path7.default.join(vueDir, mod ?? "dist/vue.runtime.esm-bundler.js");
-      if (import_node_fs7.default.existsSync(entry)) vueRuntimeEntry = entry;
+      const vueDir = import_node_path8.default.dirname(vuePkgJson);
+      const mod = JSON.parse(import_node_fs8.default.readFileSync(vuePkgJson, "utf-8")).module;
+      const entry = import_node_path8.default.join(vueDir, mod ?? "dist/vue.runtime.esm-bundler.js");
+      if (import_node_fs8.default.existsSync(entry)) vueRuntimeEntry = entry;
     } catch {
     }
   }
@@ -2924,24 +3104,24 @@ function resolvePlugin(config) {
         if (source === key || source.startsWith(key + "/")) {
           const aliasBase = resolveAliasTarget2(value, config.root);
           const sub = source.slice(key.length).replace(/^\//, "");
-          const target = sub ? import_node_path7.default.join(aliasBase, sub) : aliasBase;
+          const target = sub ? import_node_path8.default.join(aliasBase, sub) : aliasBase;
           const resolved = tryResolveFile(target, extensions);
           if (resolved) return resolved;
           break;
         }
       }
       if (source.startsWith("/") && !source.startsWith("//")) {
-        const rootRelative = import_node_path7.default.join(config.root, source.slice(1));
+        const rootRelative = import_node_path8.default.join(config.root, source.slice(1));
         const resolved = tryResolveFile(rootRelative, extensions);
         if (resolved) return resolved;
       }
-      if (import_node_path7.default.isAbsolute(source) && import_node_fs7.default.existsSync(source)) {
+      if (import_node_path8.default.isAbsolute(source) && import_node_fs8.default.existsSync(source)) {
         const resolved = tryResolveFile(source, extensions);
         if (resolved) return resolved;
       }
       if (source.startsWith(".")) {
-        const dir = importer ? import_node_path7.default.dirname(importer) : config.root;
-        const absolute = import_node_path7.default.resolve(dir, source);
+        const dir = importer ? import_node_path8.default.dirname(importer) : config.root;
+        const absolute = import_node_path8.default.resolve(dir, source);
         const resolved = tryResolveFile(absolute, extensions);
         if (resolved) return resolved;
       }
@@ -2950,7 +3130,7 @@ function resolvePlugin(config) {
         if (config.command === "build") return null;
         try {
           const resolved = require2.resolve(source, {
-            paths: [importer ? import_node_path7.default.dirname(importer) : config.root]
+            paths: [importer ? import_node_path8.default.dirname(importer) : config.root]
           });
           return resolved;
         } catch {
@@ -2961,9 +3141,9 @@ function resolvePlugin(config) {
     },
     load(id) {
       if (id.startsWith("\0")) return null;
-      if (!import_node_fs7.default.existsSync(id)) return null;
+      if (!import_node_fs8.default.existsSync(id)) return null;
       if (id.endsWith(".json")) {
-        const content = import_node_fs7.default.readFileSync(id, "utf-8");
+        const content = import_node_fs8.default.readFileSync(id, "utf-8");
         return `export default ${content}`;
       }
       return null;
@@ -2971,36 +3151,36 @@ function resolvePlugin(config) {
   };
 }
 function resolveAliasTarget2(value, root) {
-  if (import_node_path7.default.isAbsolute(value) && import_node_fs7.default.existsSync(value)) return value;
-  if (value.startsWith("/")) return import_node_path7.default.join(root, value.slice(1));
-  return import_node_path7.default.resolve(root, value);
+  if (import_node_path8.default.isAbsolute(value) && import_node_fs8.default.existsSync(value)) return value;
+  if (value.startsWith("/")) return import_node_path8.default.join(root, value.slice(1));
+  return import_node_path8.default.resolve(root, value);
 }
 function tryResolveFile(file, extensions) {
-  if (import_node_fs7.default.existsSync(file) && import_node_fs7.default.statSync(file).isFile()) {
+  if (import_node_fs8.default.existsSync(file) && import_node_fs8.default.statSync(file).isFile()) {
     return file;
   }
   for (const ext of extensions) {
     const withExt = file + ext;
-    if (import_node_fs7.default.existsSync(withExt) && import_node_fs7.default.statSync(withExt).isFile()) {
+    if (import_node_fs8.default.existsSync(withExt) && import_node_fs8.default.statSync(withExt).isFile()) {
       return withExt;
     }
   }
-  if (import_node_fs7.default.existsSync(file) && import_node_fs7.default.statSync(file).isDirectory()) {
+  if (import_node_fs8.default.existsSync(file) && import_node_fs8.default.statSync(file).isDirectory()) {
     for (const ext of extensions) {
-      const indexFile = import_node_path7.default.join(file, "index" + ext);
-      if (import_node_fs7.default.existsSync(indexFile)) {
+      const indexFile = import_node_path8.default.join(file, "index" + ext);
+      if (import_node_fs8.default.existsSync(indexFile)) {
         return indexFile;
       }
     }
   }
   return null;
 }
-var import_node_path7, import_node_fs7, import_node_module2;
+var import_node_path8, import_node_fs8, import_node_module2;
 var init_resolve = __esm({
   "src/plugins/resolve.ts"() {
     "use strict";
-    import_node_path7 = __toESM(require("path"), 1);
-    import_node_fs7 = __toESM(require("fs"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
+    import_node_fs8 = __toESM(require("fs"), 1);
     import_node_module2 = require("module");
   }
 });
@@ -3040,27 +3220,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync = (path18) => {
-      const fd = fs13.openSync(path18, "r");
+    var readFileSync = (path19) => {
+      const fd = fs14.openSync(path19, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs13.close(fd, () => {
+      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs14.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path18) => new Promise((resolve, reject) => {
-      fs13.open(path18, "r", (err, fd) => {
+    var readFile = (path19) => new Promise((resolve, reject) => {
+      fs14.open(path19, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs13.close(fd, () => {
+            fs14.close(fd, () => {
             });
           });
         }
@@ -3172,11 +3352,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path18) => {
-      if (path18) {
-        if (path18.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path19) => {
+      if (path19) {
+        if (path19.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path18.includes("/ld-linux-")) {
+        } else if (path19.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -3223,8 +3403,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path18 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+        const path19 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -3236,8 +3416,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync(SELF_PATH);
-        const path18 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+        const path19 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -3963,7 +4143,7 @@ function hasTailwindDirectives(css) {
 }
 async function loadTailwind(projectRoot) {
   if (cached && cachedRoot === projectRoot) return cached;
-  const req = (0, import_node_module3.createRequire)(import_node_path8.default.join(projectRoot, "package.json"));
+  const req = (0, import_node_module3.createRequire)(import_node_path9.default.join(projectRoot, "package.json"));
   let nodePath;
   let oxidePath;
   try {
@@ -3984,7 +4164,7 @@ async function compileTailwind(css, fromFile, projectRoot) {
   const { node, oxide } = await loadTailwind(projectRoot);
   const dependencies = [];
   const compiler2 = await node.compile(css, {
-    base: import_node_path8.default.dirname(fromFile),
+    base: import_node_path9.default.dirname(fromFile),
     from: fromFile,
     onDependency: (p) => dependencies.push(p)
   });
@@ -3995,11 +4175,11 @@ async function compileTailwind(css, fromFile, projectRoot) {
     dependencies: [...dependencies, ...scanner.files]
   };
 }
-var import_node_path8, import_node_module3, import_node_url3, TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var import_node_path9, import_node_module3, import_node_url3, TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
 var init_tailwind = __esm({
   "src/plugins/tailwind.ts"() {
     "use strict";
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
     import_node_module3 = require("module");
     import_node_url3 = require("url");
     TAILWIND_DIRECTIVE_RE = /@(?:import\s+["']tailwindcss(?:\b|\/)|tailwind\b|theme\b|apply\b|plugin\b|source\b|utility\b|variant\b|custom-variant\b|reference\b)/;
@@ -4131,16 +4311,16 @@ function rewriteCssUrls(css, from, root) {
     if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) {
       return match;
     }
-    const resolved = import_node_path9.default.resolve(import_node_path9.default.dirname(from), url);
-    const relative = "/" + import_node_path9.default.relative(root, resolved).replace(/\\/g, "/");
+    const resolved = import_node_path10.default.resolve(import_node_path10.default.dirname(from), url);
+    const relative = "/" + import_node_path10.default.relative(root, resolved).replace(/\\/g, "/");
     return `url(${relative})`;
   });
 }
-var import_node_path9, import_source_map_js;
+var import_node_path10, import_source_map_js;
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
-    import_node_path9 = __toESM(require("path"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
     import_source_map_js = require("source-map-js");
     init_css_engine();
     init_tailwind();
@@ -4259,8 +4439,8 @@ function vuePlugin(config, environmentName = "client") {
       let cached2 = descriptorCache.get(filePath);
       if (!cached2) {
         try {
-          const fs13 = await import("fs");
-          const rawSource = fs13.readFileSync(filePath, "utf-8");
+          const fs14 = await import("fs");
+          const rawSource = fs14.readFileSync(filePath, "utf-8");
           const transformedSfc = await applySourceTransform(
             vueOptions.transformSfc,
             rawSource,
@@ -4349,8 +4529,10 @@ function vuePlugin(config, environmentName = "client") {
       });
       const scopeId = hashId(id);
       const wantsSourceMap = !!config.build.sourcemap || transformedSfc.map != null;
+      const vapor = resolveVaporMode(descriptor, vueOptions, sfc, config);
       let scriptCode = "";
       let scriptMap;
+      let scriptBindings;
       if (descriptor.script || descriptor.scriptSetup) {
         const inlineTemplate = vueOptions.script?.inlineTemplate !== false;
         const compiled = sfc.compileScript(descriptor, {
@@ -4362,9 +4544,11 @@ function vuePlugin(config, environmentName = "client") {
           // 让 compileScript 产出 `const __sfc__ = ...`（而非默认的 `export default {...}`）。
           // 否则下方追加的 `__sfc__.render` / `__sfc__.__scopeId` / HMR 记录会引用一个
           // 不存在的 `__sfc__`，并与 compileScript 自带的 `export default` 形成双重默认导出。
-          genDefaultAs: "__sfc__"
+          genDefaultAs: "__sfc__",
+          vapor
         });
         scriptCode = compiled.content;
+        scriptBindings = compiled.bindings;
         scriptMap = composeSourceMapChain(
           [compiled.map, transformedSfc.map],
           { filename: id, environmentName, type: "sfc" }
@@ -4378,7 +4562,9 @@ function vuePlugin(config, environmentName = "client") {
       }
       let templateCode = "";
       let templateMap;
+      let templateMultiRoot;
       const scriptSetupIsInline = !!descriptor.scriptSetup && vueOptions.script?.inlineTemplate !== false;
+      const isTemplateOnlyVapor = vapor && !descriptor.script && !descriptor.scriptSetup;
       if (descriptor.template && !scriptSetupIsInline) {
         const transformedTemplate = await applySourceTransform(
           vueOptions.transformTemplate,
@@ -4400,12 +4586,16 @@ function vuePlugin(config, environmentName = "client") {
           filename: id,
           id: scopeId,
           inMap: templateInputMap,
+          vapor,
           compilerOptions: {
             ...customCompilerOptions,
+            // Vapor 在 bindingMetadata 缺失时需要空对象（与 Vite / compiler-sfc 一致）
+            bindingMetadata: customCompilerOptions.bindingMetadata ?? scriptBindings ?? (vapor ? {} : void 0),
             scopeId: `data-v-${scopeId}`
           }
         });
         templateCode = compiled.code;
+        templateMultiRoot = compiled.multiRoot;
         if (wantsSourceMap || transformedTemplate.map != null) {
           templateMap = compiled.map;
         }
@@ -4443,12 +4633,20 @@ function vuePlugin(config, environmentName = "client") {
           outputNode.add(fragment);
         }
       };
-      append(scriptCode || "const __sfc__ = {}", scriptMap);
+      append(
+        scriptCode || (vapor ? "const __sfc__ = { __vapor: true }" : "const __sfc__ = {}"),
+        scriptMap
+      );
       if (templateCode) {
         append("\n");
         append(templateCode, templateMap);
         append("\n");
         append("\n__sfc__.render = render\n");
+        if (isTemplateOnlyVapor && templateMultiRoot !== void 0) {
+          append(`
+__sfc__.__multiRoot = ${JSON.stringify(templateMultiRoot)}
+`);
+        }
       }
       if (descriptor.styles.length > 0) {
         for (let i = 0; i < descriptor.styles.length; i++) {
@@ -4457,6 +4655,16 @@ import "${id}?vue&type=style&index=${i}&lang.css"
 `);
         }
       }
+      if (vapor) {
+        append(
+          `
+if (!globalThis.__NASTI_VAPOR_BETA_WARNED__) {
+  globalThis.__NASTI_VAPOR_BETA_WARNED__ = true
+  console.warn(${JSON.stringify(VAPOR_BETA_WARNING)})
+}
+`
+        );
+      }
       append(`
 __sfc__.__scopeId = "data-v-${scopeId}"
 `);
@@ -4516,6 +4724,32 @@ if (import.meta.hot) {
     }
   };
 }
+function resolveVaporMode(descriptor, vueOptions, sfc, config) {
+  const requested = !!descriptor.vapor || !!vueOptions.features?.vapor && canForceVaporMode(descriptor);
+  if (!requested) return false;
+  if (!supportsVaporCompiler(sfc)) {
+    config.logger.warnOnce(
+      "[nasti:vue] Vapor Mode requires @vue/compiler-sfc >= 3.6. Install it: npm install @vue/compiler-sfc@^3.6.0-0"
+    );
+    return false;
+  }
+  config.logger.warnOnce(VAPOR_BETA_WARNING);
+  return true;
+}
+function canForceVaporMode(descriptor) {
+  if (typeof descriptor.filename === "string" && descriptor.filename.endsWith(".vue")) {
+    if (descriptor.script && !descriptor.scriptSetup) return false;
+    return !!(descriptor.scriptSetup || descriptor.template);
+  }
+  return true;
+}
+function supportsVaporCompiler(sfc) {
+  const version = sfc.version;
+  if (!version) return false;
+  const [major, minor] = version.split(".").map((part) => Number.parseInt(part, 10));
+  if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
+  return major > 3 || major === 3 && minor >= 6;
+}
 async function applySourceTransform(transform2, source, context) {
   if (!transform2) return { code: source };
   const result = await transform2(source, context);
@@ -4576,7 +4810,7 @@ function warnUnchainableMap(context, reason) {
 function hashId(filename) {
   return import_node_crypto2.default.createHash("sha256").update(filename).digest("hex").slice(0, 8);
 }
-var import_node_crypto2, import_source_map_js2, VUE_FILE_RE, VUE_QUERY_RE, debug3, compiler;
+var import_node_crypto2, import_source_map_js2, VUE_FILE_RE, VUE_QUERY_RE, debug3, VAPOR_BETA_WARNING, compiler;
 var init_vue = __esm({
   "src/plugins/vue.ts"() {
     "use strict";
@@ -4587,6 +4821,7 @@ var init_vue = __esm({
     VUE_FILE_RE = /\.vue$/;
     VUE_QUERY_RE = /\.vue\?vue&type=(script|template|style)(&index=\d+)?(&lang[.=]\w+)?/;
     debug3 = createDebugger("nasti:vue");
+    VAPOR_BETA_WARNING = "Vapor Mode is a beta feature; Zixiao Labs and the Vue team do not provide guarantees against crashes in production environments, and it is not suitable for server-side rendering environments.";
     compiler = null;
   }
 });
@@ -4643,12 +4878,12 @@ function createModuleRunner(environment) {
   }
   return new NastiModuleRunner(environment);
 }
-var import_node_path10, import_node_fs8, import_node_module4, import_node_url4, debug4, NODE_BUILTINS, NastiModuleRunner, AsyncFunction;
+var import_node_path11, import_node_fs9, import_node_module4, import_node_url4, debug4, NODE_BUILTINS, NastiModuleRunner, AsyncFunction;
 var init_runnable_environment = __esm({
   "src/server/runnable-environment.ts"() {
     "use strict";
-    import_node_path10 = __toESM(require("path"), 1);
-    import_node_fs8 = __toESM(require("fs"), 1);
+    import_node_path11 = __toESM(require("path"), 1);
+    import_node_fs9 = __toESM(require("fs"), 1);
     import_node_module4 = require("module");
     import_node_url4 = require("url");
     init_transformer();
@@ -4670,7 +4905,7 @@ var init_runnable_environment = __esm({
           this.config.mode,
           ssrDefineOverrides(environment.consumer)
         );
-        this.require = (0, import_node_module4.createRequire)(import_node_path10.default.join(this.config.root, "package.json"));
+        this.require = (0, import_node_module4.createRequire)(import_node_path11.default.join(this.config.root, "package.json"));
         const handlers = {
           fetchModule: async (id, importer) => this.fetchModule(id, importer),
           getBuiltins: () => [/^node:/, ...import_node_module4.builtinModules]
@@ -4694,9 +4929,9 @@ var init_runnable_environment = __esm({
         this.cache.clear();
       }
       resolveToId(rawUrl) {
-        if (import_node_path10.default.isAbsolute(rawUrl) && import_node_fs8.default.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        if (import_node_path11.default.isAbsolute(rawUrl) && import_node_fs9.default.existsSync(rawUrl.split("?")[0])) return rawUrl;
         const clean = rawUrl.replace(/^\//, "");
-        return import_node_path10.default.resolve(this.config.root, clean);
+        return import_node_path11.default.resolve(this.config.root, clean);
       }
       /**
        * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
@@ -4705,14 +4940,14 @@ var init_runnable_environment = __esm({
        */
       async fetchModule(id, importer) {
         if (NODE_BUILTINS.has(id)) return { externalize: id };
-        if (!id.startsWith(".") && !import_node_path10.default.isAbsolute(id) && !id.startsWith("\0")) {
+        if (!id.startsWith(".") && !import_node_path11.default.isAbsolute(id) && !id.startsWith("\0")) {
           return { externalize: id };
         }
         const container = this.environment.pluginContainer;
         let resolvedId = id;
         if (id.startsWith(".") && importer) {
           const resolved = await container.resolveId(id, importer);
-          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : import_node_path10.default.resolve(import_node_path10.default.dirname(importer.split("?")[0]), id);
+          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : import_node_path11.default.resolve(import_node_path11.default.dirname(importer.split("?")[0]), id);
         }
         resolvedId = this.completeExtension(resolvedId);
         const cleanId = resolvedId.split("?")[0];
@@ -4720,8 +4955,8 @@ var init_runnable_environment = __esm({
         const loaded = await container.load(resolvedId);
         if (loaded != null) {
           code = typeof loaded === "string" ? loaded : loaded.code;
-        } else if (import_node_fs8.default.existsSync(cleanId)) {
-          code = import_node_fs8.default.readFileSync(cleanId, "utf-8");
+        } else if (import_node_fs9.default.existsSync(cleanId)) {
+          code = import_node_fs9.default.readFileSync(cleanId, "utf-8");
         } else {
           throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
         }
@@ -4755,19 +4990,19 @@ var init_runnable_environment = __esm({
       completeExtension(id) {
         const clean = id.split("?")[0];
         const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
-        if (import_node_fs8.default.existsSync(clean) && import_node_fs8.default.statSync(clean).isFile()) return id;
+        if (import_node_fs9.default.existsSync(clean) && import_node_fs9.default.statSync(clean).isFile()) return id;
         const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
         if (jsMatch) {
           for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
-            if (import_node_fs8.default.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+            if (import_node_fs9.default.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
           }
         }
         for (const ext of this.config.resolve.extensions) {
-          if (import_node_fs8.default.existsSync(clean + ext)) return clean + ext + query;
+          if (import_node_fs9.default.existsSync(clean + ext)) return clean + ext + query;
         }
         for (const ext of this.config.resolve.extensions) {
-          const indexPath = import_node_path10.default.join(clean, `index${ext}`);
-          if (import_node_fs8.default.existsSync(indexPath)) return indexPath;
+          const indexPath = import_node_path11.default.join(clean, `index${ext}`);
+          if (import_node_fs9.default.existsSync(indexPath)) return indexPath;
         }
         return id;
       }
@@ -4794,10 +5029,10 @@ var init_runnable_environment = __esm({
           return;
         }
         const ssrImport = async (dep) => {
-          if (NODE_BUILTINS.has(dep) || !dep.startsWith(".") && !import_node_path10.default.isAbsolute(dep) && !dep.startsWith("\0")) {
+          if (NODE_BUILTINS.has(dep) || !dep.startsWith(".") && !import_node_path11.default.isAbsolute(dep) && !dep.startsWith("\0")) {
             return this.importExternal(dep);
           }
-          const depId = dep.startsWith(".") ? this.completeExtension(import_node_path10.default.resolve(import_node_path10.default.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
+          const depId = dep.startsWith(".") ? this.completeExtension(import_node_path11.default.resolve(import_node_path11.default.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
           return this.instantiate(depId);
         };
         const ssrExportAll = (sourceModule) => {
@@ -4829,7 +5064,7 @@ var init_runnable_environment = __esm({
       }
       async importExternal(spec) {
         try {
-          return await (spec.startsWith("node:") || !import_node_path10.default.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import((0, import_node_url4.pathToFileURL)(spec).href));
+          return await (spec.startsWith("node:") || !import_node_path11.default.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import((0, import_node_url4.pathToFileURL)(spec).href));
         } catch (err) {
           throw new Error(`[nasti:ssr] failed to import external "${spec}": ${err.message}`);
         }
@@ -4889,7 +5124,7 @@ function reportBuildOutput(output, config, logger) {
     if (compressed && content != null) {
       gzip = (0, import_node_zlib.gzipSync)(typeof content === "string" ? Buffer.from(content) : content).byteLength;
     }
-    const ext = import_node_path11.default.extname(file.fileName);
+    const ext = import_node_path12.default.extname(file.fileName);
     const group = file.type === "chunk" ? "js" : ext === ".css" ? "css" : "assets";
     entries.push({ name: file.fileName, size, gzip, group });
   }
@@ -4923,11 +5158,11 @@ function warnLargeChunks(output, config, logger) {
     )
   );
 }
-var import_node_path11, import_node_zlib, import_picocolors5, debug5, numberFormatter;
+var import_node_path12, import_node_zlib, import_picocolors5, debug5, numberFormatter;
 var init_reporter = __esm({
   "src/build/reporter.ts"() {
     "use strict";
-    import_node_path11 = __toESM(require("path"), 1);
+    import_node_path12 = __toESM(require("path"), 1);
     import_node_zlib = require("zlib");
     import_picocolors5 = __toESM(require("picocolors"), 1);
     init_debug();
@@ -4943,7 +5178,7 @@ var init_reporter = __esm({
 function createBuildAppContext(config, results) {
   const output = [];
   const emitted = /* @__PURE__ */ new Set();
-  const outDir = import_node_path12.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path13.default.resolve(config.root, config.build.outDir);
   let environmentArtifacts;
   return {
     config,
@@ -4999,14 +5234,14 @@ function createBuildAppContext(config, results) {
       if (environmentArtifacts.has(collisionKey)) {
         throw new Error(`[nasti] app artifact conflicts with environment output: ${fileName}`);
       }
-      const target = import_node_path12.default.resolve(outDir, ...fileName.split("/"));
-      const relative = import_node_path12.default.relative(outDir, target);
-      if (relative.startsWith("..") || import_node_path12.default.isAbsolute(relative)) {
+      const target = import_node_path13.default.resolve(outDir, ...fileName.split("/"));
+      const relative = import_node_path13.default.relative(outDir, target);
+      if (relative.startsWith("..") || import_node_path13.default.isAbsolute(relative)) {
         throw new Error(`[nasti] app artifact must stay inside build.outDir: ${file.fileName}`);
       }
       assertNoSymlinkComponents(outDir, fileName);
-      import_node_fs9.default.mkdirSync(import_node_path12.default.dirname(target), { recursive: true });
-      import_node_fs9.default.writeFileSync(target, file.source);
+      import_node_fs10.default.mkdirSync(import_node_path13.default.dirname(target), { recursive: true });
+      import_node_fs10.default.writeFileSync(target, file.source);
       const artifact = {
         ...file,
         fileName,
@@ -5022,10 +5257,10 @@ function joinPublicPath(base, fileName) {
   return `${base.endsWith("/") ? base : `${base}/`}${fileName.replace(/^\//, "")}`;
 }
 function normalizeEnvironmentFileName(fileName) {
-  return import_node_path12.default.posix.normalize(fileName.replace(/\\/g, "/").replace(/^\.\//, ""));
+  return import_node_path13.default.posix.normalize(fileName.replace(/\\/g, "/").replace(/^\.\//, ""));
 }
 function isInvalidEnvironmentFileName(fileName) {
-  return !fileName || fileName === "." || fileName === ".." || fileName.startsWith("../") || import_node_path12.default.posix.isAbsolute(fileName) || /^[A-Za-z]:\//.test(fileName);
+  return !fileName || fileName === "." || fileName === ".." || fileName.startsWith("../") || import_node_path13.default.posix.isAbsolute(fileName) || /^[A-Za-z]:\//.test(fileName);
 }
 function normalizeAppFileName(fileName) {
   const normalized = normalizeEnvironmentFileName(fileName);
@@ -5042,14 +5277,14 @@ function collectEnvironmentArtifacts(config, results, appOutDir) {
   for (const [environmentName, result] of Object.entries(results)) {
     const environment = config.environments[environmentName];
     if (!environment) continue;
-    const environmentOutDir = import_node_path12.default.resolve(config.root, environment.build.outDir);
+    const environmentOutDir = import_node_path13.default.resolve(config.root, environment.build.outDir);
     for (const artifact of result.output) {
-      const artifactPath = import_node_path12.default.resolve(
+      const artifactPath = import_node_path13.default.resolve(
         environmentOutDir,
         ...normalizeEnvironmentFileName(artifact.fileName).split("/")
       );
-      const relative = import_node_path12.default.relative(appOutDir, artifactPath);
-      if (!relative.startsWith("..") && !import_node_path12.default.isAbsolute(relative)) {
+      const relative = import_node_path13.default.relative(appOutDir, artifactPath);
+      if (!relative.startsWith("..") && !import_node_path13.default.isAbsolute(relative)) {
         occupied.add(artifactCollisionKey(relative));
       }
     }
@@ -5059,10 +5294,10 @@ function collectEnvironmentArtifacts(config, results, appOutDir) {
 function assertNoSymlinkComponents(outDir, fileName) {
   let current = outDir;
   for (const segment of fileName.split("/")) {
-    current = import_node_path12.default.join(current, segment);
+    current = import_node_path13.default.join(current, segment);
     let stats;
     try {
-      stats = import_node_fs9.default.lstatSync(current);
+      stats = import_node_fs10.default.lstatSync(current);
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
@@ -5080,12 +5315,12 @@ function inferEnvironmentEntries(output) {
   }
   return Object.keys(entries).length > 0 ? entries : void 0;
 }
-var import_node_fs9, import_node_path12;
+var import_node_fs10, import_node_path13;
 var init_build_app_context = __esm({
   "src/core/build-app-context.ts"() {
     "use strict";
-    import_node_fs9 = __toESM(require("fs"), 1);
-    import_node_path12 = __toESM(require("path"), 1);
+    import_node_fs10 = __toESM(require("fs"), 1);
+    import_node_path13 = __toESM(require("path"), 1);
   }
 });
 
@@ -5102,7 +5337,7 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
   const config = environment.config;
   const envOptions = environment.options;
   const isServer = environment.consumer === "server";
-  const outDir = import_node_path13.default.resolve(config.root, envOptions.build.outDir);
+  const outDir = import_node_path14.default.resolve(config.root, envOptions.build.outDir);
   const assetsDir = envOptions.build.assetsDir;
   const {
     output: userOutput,
@@ -5142,7 +5377,7 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
       // 相对/绝对/虚拟模块照常打包。需要内联依赖时经 rolldownOptions.external 覆盖。
       external: restInputOptions.external ?? ((id) => {
         if (NODE_BUILTINS2.has(id)) return true;
-        return !id.startsWith(".") && !import_node_path13.default.isAbsolute(id) && !id.startsWith("\0");
+        return !id.startsWith(".") && !import_node_path14.default.isAbsolute(id) && !id.startsWith("\0");
       })
     } : {}
   };
@@ -5299,11 +5534,11 @@ function prepareBuildOutputDirectories(config, buildableNames) {
   const protectedPaths = /* @__PURE__ */ new Set();
   const clientIsBuilt = buildableNames.includes("client");
   if (!clientIsBuilt && config.build.emptyOutDir) {
-    directories.add(import_node_path13.default.resolve(config.root, config.build.outDir));
+    directories.add(import_node_path14.default.resolve(config.root, config.build.outDir));
   }
   for (const name of buildableNames) {
     const environment = config.environments[name];
-    const outDir = import_node_path13.default.resolve(config.root, environment.build.outDir);
+    const outDir = import_node_path14.default.resolve(config.root, environment.build.outDir);
     if (!environment.build.emptyOutDir) {
       protectedPaths.add(outDir);
       continue;
@@ -5311,8 +5546,8 @@ function prepareBuildOutputDirectories(config, buildableNames) {
     if (!environment.driver) directories.add(outDir);
   }
   const containsPath = (parent, child) => {
-    const relative = import_node_path13.default.relative(parent, child);
-    return relative === "" || !relative.startsWith("..") && !import_node_path13.default.isAbsolute(relative);
+    const relative = import_node_path14.default.relative(parent, child);
+    return relative === "" || !relative.startsWith("..") && !import_node_path14.default.isAbsolute(relative);
   };
   const roots = [...directories].filter(
     (directory) => ![...protectedPaths].some((protectedPath) => containsPath(directory, protectedPath))
@@ -5320,7 +5555,7 @@ function prepareBuildOutputDirectories(config, buildableNames) {
     (directory, index2, all) => !all.slice(0, index2).some((parent) => containsPath(parent, directory))
   );
   for (const directory of roots) {
-    if (import_node_fs10.default.existsSync(directory)) import_node_fs10.default.rmSync(directory, { recursive: true, force: true });
+    if (import_node_fs11.default.existsSync(directory)) import_node_fs11.default.rmSync(directory, { recursive: true, force: true });
   }
 }
 function assertDriverBuildResult(environment, result) {
@@ -5339,7 +5574,7 @@ function resolveClientEntries(config, html) {
   if (configuredEntries.length > 0) return configuredEntries;
   const entryPoints = [];
   const htmlFile = config.environments.client?.html;
-  const htmlDir = htmlFile ? import_node_path13.default.dirname(htmlFile) : config.root;
+  const htmlDir = htmlFile ? import_node_path14.default.dirname(htmlFile) : config.root;
   if (html) {
     const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
     for (const match of scriptMatches) {
@@ -5347,7 +5582,7 @@ function resolveClientEntries(config, html) {
       if (src && !src.startsWith("http")) {
         const cleanSrc = src.split(/[?#]/, 1)[0];
         entryPoints.push(
-          cleanSrc.startsWith("/") ? import_node_path13.default.resolve(config.root, cleanSrc.replace(/^\//, "")) : import_node_path13.default.resolve(htmlDir, cleanSrc)
+          cleanSrc.startsWith("/") ? import_node_path14.default.resolve(config.root, cleanSrc.replace(/^\//, "")) : import_node_path14.default.resolve(htmlDir, cleanSrc)
         );
       }
     }
@@ -5355,8 +5590,8 @@ function resolveClientEntries(config, html) {
   if (entryPoints.length === 0) {
     const fallbackEntries = ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"];
     for (const entry of fallbackEntries) {
-      const fullPath = import_node_path13.default.resolve(config.root, entry);
-      if (import_node_fs10.default.existsSync(fullPath)) {
+      const fullPath = import_node_path14.default.resolve(config.root, entry);
+      if (import_node_fs11.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
       }
@@ -5385,7 +5620,7 @@ async function build(inlineConfig = {}) {
   const startTime = performance.now();
   logger.info(
     import_picocolors6.default.cyan(`
-nasti v${"2.4.2"} `) + import_picocolors6.default.green(`building for ${config.mode}...`)
+nasti v${"2.4.4"} `) + import_picocolors6.default.green(`building for ${config.mode}...`)
   );
   debug6?.(`root: ${config.root}`);
   const buildableNames = Object.keys(config.environments).filter((name) => {
@@ -5460,7 +5695,7 @@ nasti v${"2.4.2"} `) + import_picocolors6.default.green(`building for ${config.m
 }
 async function buildClientEnvironment(config) {
   const logger = config.logger;
-  const outDir = import_node_path13.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path14.default.resolve(config.root, config.build.outDir);
   const cssEngine = createCssEngine();
   const pluginList = resolvePluginList(config, config.plugins, {
     cssEngine,
@@ -5483,8 +5718,8 @@ async function buildClientEnvironment(config) {
       assertDriverBuildResult(clientEnv, result);
       return { environment: clientEnv, result: finalizeEnvironmentResult(clientEnv, result) };
     }
-    import_node_fs10.default.mkdirSync(outDir, { recursive: true });
-    const htmlFile = config.environments.client.html ?? import_node_path13.default.resolve(config.root, "index.html");
+    import_node_fs11.default.mkdirSync(outDir, { recursive: true });
+    const htmlFile = config.environments.client.html ?? import_node_path14.default.resolve(config.root, "index.html");
     const html = await readHtmlFile(config.root, htmlFile);
     const entryPoints = resolveClientEntries(config, html);
     if (entryPoints.length === 0) {
@@ -5534,7 +5769,7 @@ async function buildClientEnvironment(config) {
           );
         }
       }
-      import_node_fs10.default.writeFileSync(import_node_path13.default.resolve(outDir, "index.html"), processedHtml);
+      import_node_fs11.default.writeFileSync(import_node_path14.default.resolve(outDir, "index.html"), processedHtml);
     }
     if (!nativeReporter && config.logLevel !== "silent") {
       reportBuildOutput(output, config, logger);
@@ -5588,7 +5823,7 @@ async function buildServerEnvironment(config, name) {
     }
   }
   for (const entry of envOptions.entry) {
-    if (!import_node_fs10.default.existsSync(entry)) {
+    if (!import_node_fs11.default.existsSync(entry)) {
       await environment.close();
       throw new Error(`[nasti] environment "${name}" entry not found: ${entry}`);
     }
@@ -5602,13 +5837,13 @@ async function buildServerEnvironment(config, name) {
     envOptions.entry,
     rolldownPlugins
   );
-  import_node_fs10.default.mkdirSync(outDir, { recursive: true });
+  import_node_fs11.default.mkdirSync(outDir, { recursive: true });
   const bundle2 = await (0, import_rolldown.rolldown)(inputOptions);
   const { output } = await bundle2.write(outputOptions);
   await bundle2.close();
   if (cssEngine) environment.setBuildMetadata({ css: getCssMetadata(cssEngine) });
   logger.info(
-    import_picocolors6.default.dim(`  [${name}] `) + output.map((o) => import_node_path13.default.join(envOptions.build.outDir, o.fileName)).join(import_picocolors6.default.dim(", "))
+    import_picocolors6.default.dim(`  [${name}] `) + output.map((o) => import_node_path14.default.join(envOptions.build.outDir, o.fileName)).join(import_picocolors6.default.dim(", "))
   );
   return {
     environment,
@@ -5640,9 +5875,9 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, urlPrefix) {
-  const rootRelative = import_node_path13.default.relative(config.root, facadeModuleId).split(import_node_path13.default.sep).join("/");
-  const resolvedHtmlFile = import_node_path13.default.resolve(config.root, htmlFile);
-  const htmlRelative = import_node_path13.default.relative(import_node_path13.default.dirname(resolvedHtmlFile), facadeModuleId).split(import_node_path13.default.sep).join("/");
+  const rootRelative = import_node_path14.default.relative(config.root, facadeModuleId).split(import_node_path14.default.sep).join("/");
+  const resolvedHtmlFile = import_node_path14.default.resolve(config.root, htmlFile);
+  const htmlRelative = import_node_path14.default.relative(import_node_path14.default.dirname(resolvedHtmlFile), facadeModuleId).split(import_node_path14.default.sep).join("/");
   const candidates = /* @__PURE__ */ new Set([
     rootRelative,
     `/${rootRelative}`,
@@ -5658,12 +5893,12 @@ function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, ur
   }
   return processed;
 }
-var import_node_path13, import_node_fs10, import_node_module5, import_rolldown, import_picocolors6, debug6, NODE_BUILTINS2;
+var import_node_path14, import_node_fs11, import_node_module5, import_rolldown, import_picocolors6, debug6, NODE_BUILTINS2;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path13 = __toESM(require("path"), 1);
-    import_node_fs10 = __toESM(require("fs"), 1);
+    import_node_path14 = __toESM(require("path"), 1);
+    import_node_fs11 = __toESM(require("fs"), 1);
     import_node_module5 = require("module");
     import_rolldown = require("rolldown");
     init_config();
@@ -5769,7 +6004,7 @@ async function createBundledDevServer(opts) {
       }
       const url = `/${patchPath}`;
       logger.info(
-        import_picocolors7.default.green("hmr update ") + import_picocolors7.default.dim(changedFiles.map((f) => import_node_path14.default.relative(config.root, f)).join(", ")),
+        import_picocolors7.default.green("hmr update ") + import_picocolors7.default.dim(changedFiles.map((f) => import_node_path15.default.relative(config.root, f)).join(", ")),
         { timestamp: true }
       );
       sendTo(clientId, { type: "hmr:update", path: url, url });
@@ -5924,7 +6159,7 @@ async function createBundledDevServer(opts) {
           return;
         }
         res.setHeader("ETag", hit.etag);
-        res.setHeader("Content-Type", MIME_TYPES[import_node_path14.default.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Content-Type", MIME_TYPES[import_node_path15.default.extname(fileName)] ?? "application/octet-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.once("finish", () => {
           void engine.notifyPayloadDelivered(fileName).catch(
@@ -5965,7 +6200,7 @@ function stripCatchAllLoad(plugins) {
   );
 }
 function createReactRefreshRuntimePlugin(entryPoints) {
-  const entryIds = new Set(entryPoints.map((p) => import_node_path14.default.resolve(p)));
+  const entryIds = new Set(entryPoints.map((p) => import_node_path15.default.resolve(p)));
   return {
     name: "nasti:bundled-react-refresh",
     resolveId(source) {
@@ -5983,7 +6218,7 @@ function createReactRefreshRuntimePlugin(entryPoints) {
       return null;
     },
     transform(code, id) {
-      if (!entryIds.has(import_node_path14.default.resolve(id.split("?")[0]))) return null;
+      if (!entryIds.has(import_node_path15.default.resolve(id.split("?")[0]))) return null;
       return { code: `import ${JSON.stringify(PREAMBLE_SPEC)};
 ${code}`, map: null };
     }
@@ -6030,11 +6265,11 @@ async function renderBundledIndexHtml(html, config, entryFileNames) {
   }
   return processed;
 }
-var import_node_path14, import_node_crypto3, import_ws2, import_picocolors7, debug7, MIME_TYPES, MemoryFiles, PREAMBLE_SPEC, RESOLVED_PREAMBLE_ID, REFRESH_RUNTIME_URL, BUNDLED_PREAMBLE_CODE, WRAPPER_RUNTIME_HELPERS;
+var import_node_path15, import_node_crypto3, import_ws2, import_picocolors7, debug7, MIME_TYPES, MemoryFiles, PREAMBLE_SPEC, RESOLVED_PREAMBLE_ID, REFRESH_RUNTIME_URL, BUNDLED_PREAMBLE_CODE, WRAPPER_RUNTIME_HELPERS;
 var init_dev_engine = __esm({
   "src/server/bundled/dev-engine.ts"() {
     "use strict";
-    import_node_path14 = __toESM(require("path"), 1);
+    import_node_path15 = __toESM(require("path"), 1);
     import_node_crypto3 = __toESM(require("crypto"), 1);
     import_ws2 = require("ws");
     import_picocolors7 = __toESM(require("picocolors"), 1);
@@ -6244,20 +6479,39 @@ async function createServer(inlineConfig = {}) {
     app.use(bundledServer.middleware);
   }
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = import_node_path15.default.resolve(config.root, config.build.outDir);
-  const watcher = (0, import_chokidar.watch)(config.root, {
+  const outDirAbs = import_node_path16.default.resolve(config.root, config.build.outDir);
+  const linkedPackageRoots = getLinkedPackageRoots(config.root).filter(
+    (r) => r !== config.root && !isUnderRoot(config.root, r)
+  );
+  const watchTargets = [config.root, ...linkedPackageRoots];
+  const watcher = (0, import_chokidar.watch)(watchTargets, {
     ignored: (filePath) => {
-      if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path15.default.sep)) return true;
-      const rel = import_node_path15.default.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || import_node_path15.default.isAbsolute(rel)) return false;
-      for (const seg of rel.split(import_node_path15.default.sep)) {
-        if (ignoredSegments.has(seg)) return true;
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path16.default.sep)) return true;
+      for (const watchRoot of watchTargets) {
+        if (filePath === watchRoot) return false;
+        const rel = import_node_path16.default.relative(watchRoot, filePath);
+        if (!rel || rel.startsWith("..") || import_node_path16.default.isAbsolute(rel)) continue;
+        for (const seg of rel.split(import_node_path16.default.sep)) {
+          if (ignoredSegments.has(seg)) return true;
+        }
+        return false;
       }
       return false;
     },
     ignoreInitial: true
   });
+  await new Promise((resolve, reject) => {
+    const onReady = () => {
+      watcher.off("error", onError);
+      resolve();
+    };
+    const onError = (err) => {
+      watcher.off("ready", onReady);
+      reject(err);
+    };
+    watcher.once("ready", onReady);
+    watcher.once("error", onError);
+  });
   let server;
   const environmentServices = {};
   let environmentDriversStarted = false;
@@ -6369,16 +6623,25 @@ async function createServer(inlineConfig = {}) {
     });
   };
   watcher.on("change", (file) => {
+    if (file.includes(`${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}`) || file.endsWith(`${import_node_path16.default.sep}node_modules`)) {
+      clearLinkedPackageRootsCache();
+    }
     ssrRunner?.invalidateFile(file);
     queueClientEnvironmentUpdate(file);
     notifyEnvironmentDrivers(file, "change");
   });
   watcher.on("add", (file) => {
+    if (file.includes(`${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}`) || file.endsWith(`${import_node_path16.default.sep}node_modules`)) {
+      clearLinkedPackageRootsCache();
+    }
     ssrRunner?.invalidateFile(file);
     queueClientEnvironmentUpdate(file);
     notifyEnvironmentDrivers(file, "add");
   });
   watcher.on("unlink", (file) => {
+    if (file.includes(`${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}`) || file.endsWith(`${import_node_path16.default.sep}node_modules`)) {
+      clearLinkedPackageRootsCache();
+    }
     ssrRunner?.invalidateFile(file);
     notifyEnvironmentDrivers(file, "unlink");
   });
@@ -6408,7 +6671,7 @@ async function createServer(inlineConfig = {}) {
           const readyIn = Math.ceil(performance.now() - startTime);
           logger.info(
             `
-  ${import_picocolors8.default.cyan(import_picocolors8.default.bold("NASTI"))} ${import_picocolors8.default.cyan(`v${"2.4.2"}`)}  ${import_picocolors8.default.dim("ready in")} ${import_picocolors8.default.bold(readyIn)} ${import_picocolors8.default.dim("ms")}
+  ${import_picocolors8.default.cyan(import_picocolors8.default.bold("NASTI"))} ${import_picocolors8.default.cyan(`v${"2.4.4"}`)}  ${import_picocolors8.default.dim("ready in")} ${import_picocolors8.default.bold(readyIn)} ${import_picocolors8.default.dim("ms")}
 `
           );
           printServerUrls(
@@ -6505,7 +6768,7 @@ async function createServer(inlineConfig = {}) {
     throw error;
   }
   app.use(transformMiddleware(transformContexts.get("client")));
-  const publicDir = import_node_path15.default.resolve(config.root, "public");
+  const publicDir = import_node_path16.default.resolve(config.root, "public");
   app.use((0, import_sirv.default)(publicDir, { dev: true, etag: true }));
   app.use((0, import_sirv.default)(config.root, { dev: true, etag: true }));
   const postMiddlewares = [];
@@ -6531,12 +6794,12 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path15, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors8;
+var import_node_http, import_node_path16, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors8;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     import_node_http = __toESM(require("http"), 1);
-    import_node_path15 = __toESM(require("path"), 1);
+    import_node_path16 = __toESM(require("path"), 1);
     import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
@@ -6552,6 +6815,7 @@ var init_server = __esm({
     init_builtins();
     init_plugin_api();
     init_env();
+    init_fs_allow();
   }
 });
 
@@ -6606,16 +6870,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors9.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors9.default.dim(` v${"2.4.2"}`));
+  console.log(import_picocolors9.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors9.default.dim(` v${"2.4.4"}`));
   console.log(import_picocolors9.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors9.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors9.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = import_node_path16.default.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && import_node_fs11.default.existsSync(outDir)) {
-    import_node_fs11.default.rmSync(outDir, { recursive: true, force: true });
+  const outDir = import_node_path17.default.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && import_node_fs12.default.existsSync(outDir)) {
+    import_node_fs12.default.rmSync(outDir, { recursive: true, force: true });
   }
-  import_node_fs11.default.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = import_node_path16.default.join(outDir, "renderer");
+  import_node_fs12.default.mkdirSync(outDir, { recursive: true });
+  const rendererOutDir = import_node_path17.default.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2(createElectronRendererConfig(config, inlineConfig, {
     build: {
@@ -6624,8 +6888,8 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   }));
-  const mainEntry = import_node_path16.default.resolve(config.root, config.electron.main);
-  if (!import_node_fs11.default.existsSync(mainEntry)) {
+  const mainEntry = import_node_path17.default.resolve(config.root, config.electron.main);
+  if (!import_node_fs12.default.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
 \u5728 nasti.config.ts \u7684 electron.main \u6307\u5B9A\u4E3B\u8FDB\u7A0B\u5165\u53E3\u6587\u4EF6\u3002`
@@ -6639,11 +6903,11 @@ async function buildElectron(inlineConfig = {}) {
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
   const preloadFiles = [];
   for (const entry of preloadEntries) {
-    if (!import_node_fs11.default.existsSync(entry)) {
+    if (!import_node_fs12.default.existsSync(entry)) {
       console.warn(import_picocolors9.default.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = import_node_path16.default.basename(entry).replace(/\.[^.]+$/, "");
+    const base = import_node_path17.default.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -6655,10 +6919,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(import_picocolors9.default.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(import_picocolors9.default.dim(`  renderer: ${import_node_path16.default.relative(config.root, rendererOutDir)}/`));
-  console.log(import_picocolors9.default.dim(`  main:     ${import_node_path16.default.relative(config.root, mainFile)}`));
+  console.log(import_picocolors9.default.dim(`  renderer: ${import_node_path17.default.relative(config.root, rendererOutDir)}/`));
+  console.log(import_picocolors9.default.dim(`  main:     ${import_node_path17.default.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(import_picocolors9.default.dim(`  preload:  ${import_node_path16.default.relative(config.root, pf)}`));
+    console.log(import_picocolors9.default.dim(`  preload:  ${import_node_path17.default.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -6696,7 +6960,7 @@ async function bundleNode(config, entry, opts) {
     },
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs11.default.mkdirSync(import_node_path16.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs12.default.mkdirSync(import_node_path17.default.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     sourcemap: !!config.build.sourcemap,
     minify: !!config.build.minify,
@@ -6707,7 +6971,7 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle2.close();
-  console.log(import_picocolors9.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path16.default.relative(config.root, opts.outFile)}`));
+  console.log(import_picocolors9.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path17.default.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function createElectronRendererConfig(config, inlineConfig = {}, overrides = {}) {
@@ -6731,11 +6995,11 @@ function createElectronRendererConfig(config, inlineConfig = {}, overrides = {})
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return import_node_path16.default.join(outDir, base + ext);
+  return import_node_path17.default.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => import_node_path16.default.resolve(root, p));
+  return list.map((p) => import_node_path17.default.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -6750,21 +7014,30 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = import_node_path16.default.resolve(root, "node_modules/electron/package.json");
-    if (!import_node_fs11.default.existsSync(pkgPath)) return null;
-    const pkg = JSON.parse(import_node_fs11.default.readFileSync(pkgPath, "utf-8"));
+    const require2 = (0, import_node_module7.createRequire)(import_node_path17.default.resolve(root, "package.json"));
+    const pkgPath = require2.resolve("electron/package.json");
+    const pkg = JSON.parse(import_node_fs12.default.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
     return Number.isFinite(major) ? major : null;
   } catch {
-    return null;
+    try {
+      const pkgPath = import_node_path17.default.resolve(root, "node_modules/electron/package.json");
+      if (!import_node_fs12.default.existsSync(pkgPath)) return null;
+      const pkg = JSON.parse(import_node_fs12.default.readFileSync(pkgPath, "utf-8"));
+      const major = parseInt(String(pkg.version).split(".")[0], 10);
+      return Number.isFinite(major) ? major : null;
+    } catch {
+      return null;
+    }
   }
 }
-var import_node_path16, import_node_fs11, import_rolldown2, import_picocolors9;
+var import_node_path17, import_node_fs12, import_node_module7, import_rolldown2, import_picocolors9;
 var init_electron2 = __esm({
   "src/build/electron.ts"() {
     "use strict";
-    import_node_path16 = __toESM(require("path"), 1);
-    import_node_fs11 = __toESM(require("fs"), 1);
+    import_node_path17 = __toESM(require("path"), 1);
+    import_node_fs12 = __toESM(require("fs"), 1);
+    import_node_module7 = require("module");
     import_rolldown2 = require("rolldown");
     import_picocolors9 = __toESM(require("picocolors"), 1);
     init_config();
@@ -6785,7 +7058,7 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(import_picocolors10.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors10.default.dim(` v${"2.4.2"}`));
+  console.log(import_picocolors10.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors10.default.dim(` v${"2.4.4"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({
     ...rest,
@@ -6795,11 +7068,11 @@ async function startElectronDev(inlineConfig = {}) {
   await server.listen();
   const devUrl = `http://localhost:${server.config.server.port}` + electronRendererDevPath(config.electron.renderer);
   console.log(import_picocolors10.default.dim(`  renderer: ${devUrl}`));
-  const stageDir = import_node_path17.default.resolve(config.root, ".nasti");
-  import_node_fs12.default.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = import_node_path17.default.resolve(config.root, config.electron.main);
+  const stageDir = import_node_path18.default.resolve(config.root, ".nasti");
+  import_node_fs13.default.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = import_node_path18.default.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = import_node_path17.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = import_node_path18.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -6809,9 +7082,9 @@ async function startElectronDev(inlineConfig = {}) {
     });
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
-      if (!import_node_fs12.default.existsSync(entry)) continue;
-      const base = import_node_path17.default.basename(entry).replace(/\.[^.]+$/, "");
-      const out = import_node_path17.default.join(stageDir, base + extFor(config.electron.preloadFormat));
+      if (!import_node_fs13.default.existsSync(entry)) continue;
+      const base = import_node_path18.default.basename(entry).replace(/\.[^.]+$/, "");
+      const out = import_node_path18.default.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -6850,7 +7123,7 @@ async function startElectronDev(inlineConfig = {}) {
   };
   spawnElectron();
   if (config.electron.autoRestart) {
-    const watchTargets = [mainEntry, ...preloadEntries].filter(import_node_fs12.default.existsSync);
+    const watchTargets = [mainEntry, ...preloadEntries].filter(import_node_fs13.default.existsSync);
     const watcher = import_chokidar2.default.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
     let pending = false;
@@ -6930,7 +7203,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs12.default.mkdirSync(import_node_path17.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs13.default.mkdirSync(import_node_path18.default.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -6943,18 +7216,18 @@ async function compileNode(config, entry, opts) {
   await bundle2.close();
 }
 function electronRendererDevPath(renderer) {
-  const normalized = renderer.split(import_node_path17.default.sep).join("/").replace(/^\.?\//, "");
+  const normalized = renderer.split(import_node_path18.default.sep).join("/").replace(/^\.?\//, "");
   return normalized === "index.html" ? "/" : `/${normalized}`;
 }
 function resolveElectronBinary(config) {
-  if (config.electron.electronPath && import_node_fs12.default.existsSync(config.electron.electronPath)) {
+  if (config.electron.electronPath && import_node_fs13.default.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = (0, import_node_module7.createRequire)(import_node_path17.default.resolve(config.root, "package.json"));
+    const require2 = (0, import_node_module8.createRequire)(import_node_path18.default.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
-    if (typeof electronModule === "string" && import_node_fs12.default.existsSync(electronModule)) {
+    if (typeof electronModule === "string" && import_node_fs13.default.existsSync(electronModule)) {
       return electronModule;
     }
   } catch {
@@ -6979,13 +7252,13 @@ function warnElectronVersion(config) {
     );
   }
 }
-var import_node_path17, import_node_fs12, import_node_module7, import_node_child_process, import_chokidar2, import_picocolors10, import_rolldown3;
+var import_node_path18, import_node_fs13, import_node_module8, import_node_child_process, import_chokidar2, import_picocolors10, import_rolldown3;
 var init_electron_dev = __esm({
   "src/server/electron-dev.ts"() {
     "use strict";
-    import_node_path17 = __toESM(require("path"), 1);
-    import_node_fs12 = __toESM(require("fs"), 1);
-    import_node_module7 = require("module");
+    import_node_path18 = __toESM(require("path"), 1);
+    import_node_fs13 = __toESM(require("fs"), 1);
+    import_node_module8 = require("module");
     import_node_child_process = require("child_process");
     import_chokidar2 = __toESM(require("chokidar"), 1);
     import_picocolors10 = __toESM(require("picocolors"), 1);
@@ -7137,20 +7410,20 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   const logger = createCliLogger(options);
   try {
     const http2 = await import("http");
-    const path18 = await import("path");
+    const path19 = await import("path");
     const os2 = await import("os");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
     const { printServerUrls: printServerUrls2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
-    const resolvedRoot = path18.resolve(root ?? ".");
-    const outDir = path18.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path19.resolve(root ?? ".");
+    const outDir = path19.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;
     const host = options.host === true ? "0.0.0.0" : options.host ?? "localhost";
     http2.createServer(app).listen(port, host, () => {
       logger.info(`
-  ${import_picocolors11.default.cyan(import_picocolors11.default.bold("NASTI"))} ${import_picocolors11.default.cyan(`v${"2.4.2"}`)}  ${import_picocolors11.default.dim("preview")}
+  ${import_picocolors11.default.cyan(import_picocolors11.default.bold("NASTI"))} ${import_picocolors11.default.cyan(`v${"2.4.4"}`)}  ${import_picocolors11.default.dim("preview")}
 `);
       printServerUrls2(
         {
@@ -7167,6 +7440,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("2.4.2");
+cli.version("2.4.4");
 cli.parse();
 //# sourceMappingURL=cli.cjs.map