@nasti-toolchain/nasti 1.6.2 → 1.6.4

package/dist/cli.cjs

@@ -464,6 +464,19 @@ var init_module_graph = __esm({
         }
         mods.add(mod);
       }
+      /**
+       * Reindex a module under a plugin-provided canonical id (e.g. a `\0virtual:foo`
+       * id returned from `resolveId`). Plugins look up their own virtual modules via
+       * `getModuleById(RESOLVED_ID)` to invalidate them on watcher events; without
+       * this remap they'd never find the node because `ensureEntryFromUrl` keys by
+       * the public URL only.
+       */
+      setModuleId(mod, id) {
+        if (mod.id === id) return;
+        this.idToModuleMap.delete(mod.id);
+        mod.id = id;
+        this.idToModuleMap.set(id, mod);
+      }
       /** 更新模块依赖关系 */
       updateModuleImports(mod, importedIds) {
         for (const imported of mod.importedModules) {
@@ -906,13 +919,23 @@ function transformMiddleware(ctx) {
 async function transformRequest(url, ctx) {
   const { config, pluginContainer, moduleGraph } = ctx;
   const cleanReqUrl = url.split("?")[0];
-  const cached = moduleGraph.getModuleByUrl(url);
-  if (cached?.transformResult) {
-    return cached.transformResult;
+  const cached2 = moduleGraph.getModuleByUrl(url);
+  if (cached2?.transformResult) {
+    return cached2.transformResult;
   }
   if (cleanReqUrl === "/@react-refresh") {
     return { code: getReactRefreshRuntimeEsm() };
   }
+  if (cleanReqUrl.startsWith("/@modules/")) {
+    const spec = cleanReqUrl.slice("/@modules/".length);
+    const virtual = await loadVirtualModule(spec, ctx);
+    if (virtual) {
+      const mod2 = await moduleGraph.ensureEntryFromUrl(url);
+      moduleGraph.setModuleId(mod2, virtual.id);
+      mod2.transformResult = virtual.result;
+      return virtual.result;
+    }
+  }
   const filePath = resolveUrlToFile(url, config.root);
   if (!filePath || !import_node_fs4.default.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
@@ -959,6 +982,28 @@ async function transformRequest(url, ctx) {
   mod.transformResult = transformResult;
   return transformResult;
 }
+async function loadVirtualModule(spec, ctx) {
+  const { config, pluginContainer } = 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_fs4.default.existsSync(resolvedId);
+  if (!looksVirtual) return null;
+  const loadResult = await pluginContainer.load(resolvedId);
+  if (loadResult == null) return null;
+  let code = typeof loadResult === "string" ? loadResult : loadResult.code;
+  const transformed = await pluginContainer.transform(code, resolvedId);
+  if (transformed != null) {
+    code = typeof transformed === "string" ? transformed : transformed.code;
+  }
+  code = replaceEnvInCode(code, ctx.envDefine ?? buildEnvDefine(
+    loadEnv(config.mode, config.root, config.envPrefix),
+    config.mode
+  ));
+  const anchor = import_node_path4.default.join(config.root, "__nasti_virtual__.ts");
+  code = rewriteImports(code, config, anchor);
+  return { id: resolvedId, result: { code } };
+}
 async function bundlePackageAsEsm(entryFile) {
   if (!esmBundleCache.has(entryFile)) {
     esmBundleCache.set(entryFile, doBundlePackage(entryFile));
@@ -1115,19 +1160,20 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire4 } = await import("module");
-    const req = createRequire4(entryFile);
+    const { createRequire: createRequire5 } = await import("module");
+    const req = createRequire5(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
       (k) => k !== "__esModule" && k !== "default" && VALID_IDENT.test(k)
     );
-    if (namedKeys.length === 0) return code;
+    const hasEsmInterop = cjsExports.__esModule === true && "default" in cjsExports;
+    if (!hasEsmInterop && namedKeys.length === 0) return code;
     return code.replace(
       /^export default (\w+\(\));?\s*$/m,
       (_, call) => [
         `const __cjsMod = ${call};`,
-        `export default __cjsMod;`,
+        hasEsmInterop ? `export default __cjsMod.default;` : `export default __cjsMod;`,
         ...namedKeys.map((k) => `export const ${k} = __cjsMod[${JSON.stringify(k)}];`)
       ].join("\n")
     );
@@ -1614,6 +1660,59 @@ var init_resolve = __esm({
   }
 });
 
+// src/plugins/tailwind.ts
+function hasTailwindDirectives(css) {
+  const withoutBlockComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const withoutLineComments = withoutBlockComments.replace(/\/\/.*$/gm, "");
+  return TAILWIND_DIRECTIVE_RE.test(withoutLineComments);
+}
+async function loadTailwind(projectRoot) {
+  if (cached && cachedRoot === projectRoot) return cached;
+  const req = (0, import_node_module3.createRequire)(import_node_path7.default.join(projectRoot, "package.json"));
+  let nodePath;
+  let oxidePath;
+  try {
+    nodePath = req.resolve("@tailwindcss/node");
+    oxidePath = req.resolve("@tailwindcss/oxide");
+  } catch {
+    throw new Error(
+      "[nasti] CSS contains Tailwind v4 directives but `@tailwindcss/node` and/or `@tailwindcss/oxide` are not installed in this project. Install them with:  npm i -D tailwindcss @tailwindcss/node @tailwindcss/oxide"
+    );
+  }
+  const node = await import((0, import_node_url3.pathToFileURL)(nodePath).href);
+  const oxide = await import((0, import_node_url3.pathToFileURL)(oxidePath).href);
+  cached = { node, oxide };
+  cachedRoot = projectRoot;
+  return cached;
+}
+async function compileTailwind(css, fromFile, projectRoot) {
+  const { node, oxide } = await loadTailwind(projectRoot);
+  const dependencies = [];
+  const compiler = await node.compile(css, {
+    base: import_node_path7.default.dirname(fromFile),
+    from: fromFile,
+    onDependency: (p) => dependencies.push(p)
+  });
+  const scanner = new oxide.Scanner({ sources: compiler.sources });
+  const candidates = scanner.scan();
+  return {
+    css: compiler.build(candidates),
+    dependencies: [...dependencies, ...scanner.files]
+  };
+}
+var import_node_path7, import_node_module3, import_node_url3, TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var init_tailwind = __esm({
+  "src/plugins/tailwind.ts"() {
+    "use strict";
+    import_node_path7 = __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)/;
+    cached = null;
+    cachedRoot = null;
+  }
+});
+
 // src/plugins/css.ts
 function cssPlugin(config) {
   return {
@@ -1622,9 +1721,14 @@ function cssPlugin(config) {
       if (source.endsWith(".css")) return null;
       return null;
     },
-    transform(code, id) {
+    async transform(code, id) {
       if (!id.endsWith(".css")) return null;
-      const rewritten = rewriteCssUrls(code, id, config.root);
+      let cssSource = code;
+      if (hasTailwindDirectives(code)) {
+        const compiled = await compileTailwind(code, id, config.root);
+        cssSource = compiled.css;
+      }
+      const rewritten = rewriteCssUrls(cssSource, id, config.root);
       if (config.command === "serve") {
         const escaped = JSON.stringify(rewritten);
         return {
@@ -1659,16 +1763,17 @@ function rewriteCssUrls(css, from, root) {
     if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) {
       return match;
     }
-    const resolved = import_node_path7.default.resolve(import_node_path7.default.dirname(from), url);
-    const relative = "/" + import_node_path7.default.relative(root, resolved);
+    const resolved = import_node_path8.default.resolve(import_node_path8.default.dirname(from), url);
+    const relative = "/" + import_node_path8.default.relative(root, resolved);
     return `url(${relative})`;
   });
 }
-var import_node_path7;
+var import_node_path8;
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
+    init_tailwind();
   }
 });
 
@@ -1683,7 +1788,7 @@ function assetsPlugin(config) {
       return null;
     },
     load(id) {
-      const ext = import_node_path8.default.extname(id.replace(/\?.*$/, ""));
+      const ext = import_node_path9.default.extname(id.replace(/\?.*$/, ""));
       if (id.endsWith("?raw")) {
         const file = id.slice(0, -4);
         if (import_node_fs7.default.existsSync(file)) {
@@ -1695,12 +1800,12 @@ function assetsPlugin(config) {
         const file = id.replace(/\?.*$/, "");
         if (!import_node_fs7.default.existsSync(file)) return null;
         if (config.command === "serve") {
-          const url = "/" + import_node_path8.default.relative(config.root, file);
+          const url = "/" + import_node_path9.default.relative(config.root, file);
           return `export default ${JSON.stringify(url)}`;
         }
         const content = import_node_fs7.default.readFileSync(file);
         const hash = import_node_crypto.default.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = import_node_path8.default.basename(file, ext);
+        const basename = import_node_path9.default.basename(file, ext);
         const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
         return `export default ${JSON.stringify(config.base + hashedName)}`;
       }
@@ -1708,11 +1813,11 @@ function assetsPlugin(config) {
     }
   };
 }
-var import_node_path8, import_node_fs7, import_node_crypto, ASSET_EXTENSIONS;
+var import_node_path9, import_node_fs7, import_node_crypto, ASSET_EXTENSIONS;
 var init_assets = __esm({
   "src/plugins/assets.ts"() {
     "use strict";
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
     import_node_fs7 = __toESM(require("fs"), 1);
     import_node_crypto = __toESM(require("crypto"), 1);
     ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -1765,20 +1870,20 @@ async function createServer(inlineConfig = {}) {
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = import_node_path9.default.resolve(config.root, "public");
+  const publicDir = import_node_path10.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 httpServer = import_node_http.default.createServer(app);
   const ws = createWebSocketServer(httpServer);
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = import_node_path9.default.resolve(config.root, config.build.outDir);
+  const outDirAbs = import_node_path10.default.resolve(config.root, config.build.outDir);
   const watcher = (0, import_chokidar.watch)(config.root, {
     ignored: (filePath) => {
       if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path9.default.sep)) return true;
-      const rel = import_node_path9.default.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || import_node_path9.default.isAbsolute(rel)) return false;
-      for (const seg of rel.split(import_node_path9.default.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path10.default.sep)) return true;
+      const rel = import_node_path10.default.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || import_node_path10.default.isAbsolute(rel)) return false;
+      for (const seg of rel.split(import_node_path10.default.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -1810,7 +1915,7 @@ async function createServer(inlineConfig = {}) {
           const localUrl = `http://localhost:${actualPort}`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
           console.log();
-          console.log(import_picocolors.default.cyan("  nasti dev server") + import_picocolors.default.dim(` v${"1.6.2"}`));
+          console.log(import_picocolors.default.cyan("  nasti dev server") + import_picocolors.default.dim(` v${"1.6.4"}`));
           console.log();
           console.log(`  ${import_picocolors.default.green(">")} Local:   ${import_picocolors.default.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1866,12 +1971,12 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path9, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors;
+var import_node_http, import_node_path10, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     import_node_http = __toESM(require("http"), 1);
-    import_node_path9 = __toESM(require("path"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
     import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
@@ -1911,14 +2016,14 @@ function electronPlugin(config) {
     }
   };
 }
-var import_node_module3, NODE_BUILTINS, ELECTRON_MODULES;
+var import_node_module4, NODE_BUILTINS, ELECTRON_MODULES;
 var init_electron = __esm({
   "src/plugins/electron.ts"() {
     "use strict";
-    import_node_module3 = require("module");
+    import_node_module4 = require("module");
     NODE_BUILTINS = /* @__PURE__ */ new Set([
-      ...import_node_module3.builtinModules,
-      ...import_node_module3.builtinModules.map((m) => `node:${m}`)
+      ...import_node_module4.builtinModules,
+      ...import_node_module4.builtinModules.map((m) => `node:${m}`)
     ]);
     ELECTRON_MODULES = /* @__PURE__ */ new Set([
       "electron",
@@ -1937,10 +2042,10 @@ __export(build_exports, {
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(import_picocolors2.default.cyan("\n\u{1F528} nasti build") + import_picocolors2.default.dim(` v${"1.6.2"}`));
+  console.log(import_picocolors2.default.cyan("\n\u{1F528} nasti build") + import_picocolors2.default.dim(` v${"1.6.4"}`));
   console.log(import_picocolors2.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors2.default.dim(`  mode: ${config.mode}`));
-  const outDir = import_node_path10.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path11.default.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && import_node_fs8.default.existsSync(outDir)) {
     import_node_fs8.default.rmSync(outDir, { recursive: true, force: true });
   }
@@ -1952,14 +2057,14 @@ async function build(inlineConfig = {}) {
     for (const match of scriptMatches) {
       const src = match[1];
       if (src && !src.startsWith("http")) {
-        entryPoints.push(import_node_path10.default.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(import_node_path11.default.resolve(config.root, src.replace(/^\//, "")));
       }
     }
   }
   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_path10.default.resolve(config.root, entry);
+      const fullPath = import_node_path11.default.resolve(config.root, entry);
       if (import_node_fs8.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
@@ -2003,7 +2108,11 @@ async function build(inlineConfig = {}) {
         load: p.load,
         transform: p.transform,
         buildStart: p.buildStart,
-        buildEnd: p.buildEnd
+        buildEnd: p.buildEnd,
+        // Forward `closeBundle` to Rolldown — it invokes the hook during
+        // `bundle.close()` below. This is the hook Vite plugins (e.g. PWA
+        // manifest/SW writers) rely on for final-stage artifact emission.
+        closeBundle: p.closeBundle
       }))
     ],
     ...config.build.rolldownOptions
@@ -2020,8 +2129,8 @@ async function build(inlineConfig = {}) {
   await bundle.close();
   await pluginContainer.buildEnd();
   for (const ef of pluginContainer.getEmittedFiles()) {
-    const dest = import_node_path10.default.resolve(outDir, ef.fileName);
-    import_node_fs8.default.mkdirSync(import_node_path10.default.dirname(dest), { recursive: true });
+    const dest = import_node_path11.default.resolve(outDir, ef.fileName);
+    import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(dest), { recursive: true });
     import_node_fs8.default.writeFileSync(dest, ef.source);
   }
   if (html) {
@@ -2039,14 +2148,14 @@ async function build(inlineConfig = {}) {
     }
     for (const chunk of output) {
       if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = import_node_path10.default.relative(config.root, chunk.facadeModuleId);
+        const originalEntry = import_node_path11.default.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    import_node_fs8.default.writeFileSync(import_node_path10.default.resolve(outDir, "index.html"), processedHtml);
+    import_node_fs8.default.writeFileSync(import_node_path11.default.resolve(outDir, "index.html"), processedHtml);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   const totalSize = output.reduce((sum, chunk) => {
@@ -2068,11 +2177,11 @@ function formatSize(bytes) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_node_path10, import_node_fs8, import_rolldown, import_picocolors2;
+var import_node_path11, import_node_fs8, import_rolldown, import_picocolors2;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path10 = __toESM(require("path"), 1);
+    import_node_path11 = __toESM(require("path"), 1);
     import_node_fs8 = __toESM(require("fs"), 1);
     import_rolldown = require("rolldown");
     init_config();
@@ -2098,16 +2207,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors3.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors3.default.dim(` v${"1.6.2"}`));
+  console.log(import_picocolors3.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors3.default.dim(` v${"1.6.4"}`));
   console.log(import_picocolors3.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors3.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors3.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = import_node_path11.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path12.default.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && import_node_fs9.default.existsSync(outDir)) {
     import_node_fs9.default.rmSync(outDir, { recursive: true, force: true });
   }
   import_node_fs9.default.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = import_node_path11.default.join(outDir, "renderer");
+  const rendererOutDir = import_node_path12.default.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2118,7 +2227,7 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = import_node_path11.default.resolve(config.root, config.electron.main);
+  const mainEntry = import_node_path12.default.resolve(config.root, config.electron.main);
   if (!import_node_fs9.default.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
@@ -2137,7 +2246,7 @@ async function buildElectron(inlineConfig = {}) {
       console.warn(import_picocolors3.default.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = import_node_path11.default.basename(entry).replace(/\.[^.]+$/, "");
+    const base = import_node_path12.default.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2149,10 +2258,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(import_picocolors3.default.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(import_picocolors3.default.dim(`  renderer: ${import_node_path11.default.relative(config.root, rendererOutDir)}/`));
-  console.log(import_picocolors3.default.dim(`  main:     ${import_node_path11.default.relative(config.root, mainFile)}`));
+  console.log(import_picocolors3.default.dim(`  renderer: ${import_node_path12.default.relative(config.root, rendererOutDir)}/`));
+  console.log(import_picocolors3.default.dim(`  main:     ${import_node_path12.default.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(import_picocolors3.default.dim(`  preload:  ${import_node_path11.default.relative(config.root, pf)}`));
+    console.log(import_picocolors3.default.dim(`  preload:  ${import_node_path12.default.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2183,7 +2292,7 @@ async function bundleNode(config, entry, opts) {
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)],
     ...config.build.rolldownOptions
   });
-  import_node_fs9.default.mkdirSync(import_node_path11.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path12.default.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2192,16 +2301,16 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle.close();
-  console.log(import_picocolors3.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path11.default.relative(config.root, opts.outFile)}`));
+  console.log(import_picocolors3.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path12.default.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return import_node_path11.default.join(outDir, base + ext);
+  return import_node_path12.default.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => import_node_path11.default.resolve(root, p));
+  return list.map((p) => import_node_path12.default.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -2216,7 +2325,7 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = import_node_path11.default.resolve(root, "node_modules/electron/package.json");
+    const pkgPath = import_node_path12.default.resolve(root, "node_modules/electron/package.json");
     if (!import_node_fs9.default.existsSync(pkgPath)) return null;
     const pkg = JSON.parse(import_node_fs9.default.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
@@ -2225,11 +2334,11 @@ function detectInstalledElectron(root) {
     return null;
   }
 }
-var import_node_path11, import_node_fs9, import_rolldown2, import_picocolors3;
+var import_node_path12, import_node_fs9, import_rolldown2, import_picocolors3;
 var init_electron2 = __esm({
   "src/build/electron.ts"() {
     "use strict";
-    import_node_path11 = __toESM(require("path"), 1);
+    import_node_path12 = __toESM(require("path"), 1);
     import_node_fs9 = __toESM(require("fs"), 1);
     import_rolldown2 = require("rolldown");
     import_picocolors3 = __toESM(require("picocolors"), 1);
@@ -2250,17 +2359,17 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(import_picocolors4.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors4.default.dim(` v${"1.6.2"}`));
+  console.log(import_picocolors4.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors4.default.dim(` v${"1.6.4"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();
   const devUrl = `http://localhost:${server.config.server.port}/`;
   console.log(import_picocolors4.default.dim(`  renderer: ${devUrl}`));
-  const stageDir = import_node_path12.default.resolve(config.root, ".nasti");
+  const stageDir = import_node_path13.default.resolve(config.root, ".nasti");
   import_node_fs10.default.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = import_node_path12.default.resolve(config.root, config.electron.main);
+  const mainEntry = import_node_path13.default.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = import_node_path12.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = import_node_path13.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -2271,8 +2380,8 @@ async function startElectronDev(inlineConfig = {}) {
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
       if (!import_node_fs10.default.existsSync(entry)) continue;
-      const base = import_node_path12.default.basename(entry).replace(/\.[^.]+$/, "");
-      const out = import_node_path12.default.join(stageDir, base + extFor(config.electron.preloadFormat));
+      const base = import_node_path13.default.basename(entry).replace(/\.[^.]+$/, "");
+      const out = import_node_path13.default.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -2387,7 +2496,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs10.default.mkdirSync(import_node_path12.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs10.default.mkdirSync(import_node_path13.default.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2404,7 +2513,7 @@ function resolveElectronBinary(config) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = (0, import_node_module4.createRequire)(import_node_path12.default.resolve(config.root, "package.json"));
+    const require2 = (0, import_node_module5.createRequire)(import_node_path13.default.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
     if (typeof electronModule === "string" && import_node_fs10.default.existsSync(electronModule)) {
@@ -2432,13 +2541,13 @@ function warnElectronVersion(config) {
     );
   }
 }
-var import_node_path12, import_node_fs10, import_node_module4, import_node_child_process, import_chokidar2, import_picocolors4, import_rolldown3;
+var import_node_path13, import_node_fs10, import_node_module5, import_node_child_process, import_chokidar2, import_picocolors4, import_rolldown3;
 var init_electron_dev = __esm({
   "src/server/electron-dev.ts"() {
     "use strict";
-    import_node_path12 = __toESM(require("path"), 1);
+    import_node_path13 = __toESM(require("path"), 1);
     import_node_fs10 = __toESM(require("fs"), 1);
-    import_node_module4 = require("module");
+    import_node_module5 = require("module");
     import_node_child_process = require("child_process");
     import_chokidar2 = __toESM(require("chokidar"), 1);
     import_picocolors4 = __toESM(require("picocolors"), 1);
@@ -2560,11 +2669,11 @@ cli.command("electron-build [root]", "Build Electron app for production").option
 cli.command("preview [root]", "Preview production build").option("--port <port>", "Port number", { default: 4173 }).option("--host [host]", "Hostname").option("--outDir <dir>", "Output directory to serve", { default: "dist" }).action(async (root, options) => {
   try {
     const http2 = await import("http");
-    const path13 = await import("path");
+    const path14 = await import("path");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
-    const resolvedRoot = path13.resolve(root ?? ".");
-    const outDir = path13.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path14.resolve(root ?? ".");
+    const outDir = path14.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;
@@ -2585,6 +2694,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("1.6.2");
+cli.version("1.6.4");
 cli.parse();
 //# sourceMappingURL=cli.cjs.map