@nasti-toolchain/nasti 1.2.1 → 1.2.3

package/dist/cli.cjs

@@ -74,6 +74,27 @@ var init_defaults = __esm({
 });
 
 // src/config/index.ts
+function loadTsconfigPaths(root) {
+  const tsconfigPath = import_node_path.default.resolve(root, "tsconfig.json");
+  if (!import_node_fs.default.existsSync(tsconfigPath)) return {};
+  try {
+    const content = import_node_fs.default.readFileSync(tsconfigPath, "utf-8");
+    const stripped = content.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const tsconfig = JSON.parse(stripped);
+    const paths = tsconfig?.compilerOptions?.paths ?? {};
+    const baseUrl = tsconfig?.compilerOptions?.baseUrl ?? ".";
+    const alias = {};
+    for (const [pattern, targets] of Object.entries(paths)) {
+      if (!targets.length) continue;
+      const cleanKey = pattern.replace(/\/\*$/, "");
+      const cleanTarget = targets[0].replace(/\/\*$/, "");
+      alias[cleanKey] = import_node_path.default.resolve(root, baseUrl, cleanTarget);
+    }
+    return alias;
+  } catch {
+    return {};
+  }
+}
 async function loadConfigFromFile(root) {
   for (const file of CONFIG_FILES) {
     const filePath = import_node_path.default.resolve(root, file);
@@ -116,11 +137,6 @@ async function resolveConfig(inlineConfig = {}, command) {
       if (result) Object.assign(merged, result);
     }
   }
-  const filteredPlugins = rawPlugins.filter((p) => {
-    if (!p.apply) return true;
-    if (typeof p.apply === "function") return p.apply(resolved, env);
-    return p.apply === command;
-  });
   const resolved = {
     root,
     base: merged.base ?? defaults.base,
@@ -128,17 +144,24 @@ async function resolveConfig(inlineConfig = {}, command) {
     framework: merged.framework ?? defaults.framework,
     command,
     resolve: {
-      alias: { ...defaults.resolve.alias, ...merged.resolve?.alias },
+      // tsconfig paths 优先级最低：tsconfig < defaults < user config
+      alias: { ...loadTsconfigPaths(root), ...defaults.resolve.alias, ...merged.resolve?.alias },
       extensions: merged.resolve?.extensions ?? defaults.resolve.extensions,
       conditions: merged.resolve?.conditions ?? defaults.resolve.conditions,
       mainFields: merged.resolve?.mainFields ?? defaults.resolve.mainFields
     },
-    plugins: filteredPlugins,
+    plugins: [],
     server: { ...defaults.server, ...merged.server },
     build: { ...defaults.build, ...merged.build },
     envPrefix: Array.isArray(merged.envPrefix) ? merged.envPrefix : merged.envPrefix ? [merged.envPrefix] : [...defaults.envPrefix],
     logLevel: merged.logLevel ?? defaults.logLevel
   };
+  const filteredPlugins = rawPlugins.filter((p) => {
+    if (!p.apply) return true;
+    if (typeof p.apply === "function") return p.apply(resolved, env);
+    return p.apply === command;
+  });
+  resolved.plugins = filteredPlugins;
   for (const plugin of resolved.plugins) {
     if (plugin.configResolved) {
       await plugin.configResolved(resolved);
@@ -198,6 +221,7 @@ var init_plugin_container = __esm({
       plugins;
       config;
       ctx;
+      emittedFiles = /* @__PURE__ */ new Map();
       constructor(config) {
         this.config = config;
         this.plugins = sortPlugins(config.plugins);
@@ -209,14 +233,24 @@ var init_plugin_container = __esm({
           async resolve(source, importer) {
             return container.resolveId(source, importer);
           },
-          emitFile(_file) {
-            return "";
+          emitFile(file) {
+            const fileName = file.fileName ?? file.name ?? `asset-${container.emittedFiles.size}`;
+            const id = `emitted:${fileName}`;
+            container.emittedFiles.set(id, {
+              fileName,
+              source: file.source ?? ""
+            });
+            return id;
           },
           getModuleInfo(_id) {
             return null;
           }
         };
       }
+      /** 返回所有通过 emitFile() 输出的文件 */
+      getEmittedFiles() {
+        return Array.from(this.emittedFiles.values());
+      }
       async buildStart() {
         for (const plugin of this.plugins) {
           if (plugin.buildStart) {
@@ -460,6 +494,11 @@ function transformCode(filename, code, options = {}) {
     } : void 0,
     sourcemap: options.sourcemap ?? true
   });
+  if (result.errors && result.errors.length > 0) {
+    const msg = result.errors.map((e) => e.message ?? String(e)).join("\n");
+    throw new Error(`OXC transform failed for ${filename}:
+${msg}`);
+  }
   return {
     code: result.code,
     map: result.map ? JSON.stringify(result.map) : null
@@ -543,6 +582,68 @@ var init_html = __esm({
   }
 });
 
+// src/core/env.ts
+function loadEnv(mode, root, prefixes) {
+  const envFiles = [
+    ".env",
+    `.env.${mode}`,
+    ".env.local",
+    `.env.${mode}.local`
+  ];
+  const raw = {};
+  for (const file of envFiles) {
+    const filePath = import_node_path3.default.resolve(root, file);
+    if (!import_node_fs3.default.existsSync(filePath)) continue;
+    const content = import_node_fs3.default.readFileSync(filePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      let value = trimmed.slice(eqIdx + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      raw[key] = value;
+    }
+  }
+  const filtered = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function buildEnvDefine(env, mode) {
+  const define = {};
+  for (const [key, value] of Object.entries(env)) {
+    define[`import.meta.env.${key}`] = JSON.stringify(value);
+  }
+  define["import.meta.env.MODE"] = JSON.stringify(mode);
+  define["import.meta.env.DEV"] = mode !== "production" ? "true" : "false";
+  define["import.meta.env.PROD"] = mode === "production" ? "true" : "false";
+  define["import.meta.env.SSR"] = "false";
+  return define;
+}
+function replaceEnvInCode(code, define) {
+  let result = code;
+  for (const [key, value] of Object.entries(define)) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(escaped, "g"), value);
+  }
+  return result;
+}
+var import_node_path3, import_node_fs3;
+var init_env = __esm({
+  "src/core/env.ts"() {
+    "use strict";
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_fs3 = __toESM(require("fs"), 1);
+  }
+});
+
 // src/server/middleware.ts
 var middleware_exports = {};
 __export(middleware_exports, {
@@ -552,6 +653,17 @@ __export(middleware_exports, {
 function transformMiddleware(ctx) {
   return async (req, res, next) => {
     const url = req.url ?? "/";
+    if (ctx.config.server.cors) {
+      const origin = req.headers.origin ?? "*";
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return;
+      }
+    }
     if (req.method !== "GET") return next();
     if (url === "/@nasti/client") {
       res.setHeader("Content-Type", "application/javascript");
@@ -574,10 +686,12 @@ function transformMiddleware(ctx) {
             }
           }
         }
-        processedHtml = processedHtml.replace(
-          "<head>",
-          '<head>\n  <script type="module" src="/@nasti/client"></script>'
-        );
+        if (ctx.config.server.hmr !== false) {
+          processedHtml = processedHtml.replace(
+            "<head>",
+            '<head>\n  <script type="module" src="/@nasti/client"></script>'
+          );
+        }
         res.setHeader("Content-Type", "text/html");
         res.end(processedHtml);
         return;
@@ -610,10 +724,10 @@ async function transformRequest(url, ctx) {
     return cached.transformResult;
   }
   const filePath = resolveUrlToFile(url, config.root);
-  if (!filePath || !import_node_fs3.default.existsSync(filePath)) return null;
+  if (!filePath || !import_node_fs4.default.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
   moduleGraph.registerModule(mod, filePath);
-  let code = import_node_fs3.default.readFileSync(filePath, "utf-8");
+  let code = import_node_fs4.default.readFileSync(filePath, "utf-8");
   const pluginResult = await pluginContainer.transform(code, filePath);
   if (pluginResult) {
     code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
@@ -627,23 +741,31 @@ async function transformRequest(url, ctx) {
     });
     code = result.code;
   }
+  const env = loadEnv(config.mode, config.root, config.envPrefix);
+  const envDefine = buildEnvDefine(env, config.mode);
+  code = replaceEnvInCode(code, envDefine);
   code = rewriteImports(code, config);
   const transformResult = { code };
   mod.transformResult = transformResult;
   return transformResult;
 }
-function rewriteImports(code, config) {
+function rewriteImports(code, _config) {
   return code.replace(
-    /from\s+['"]([^'"./][^'"]*)['"]/g,
-    (match, specifier) => {
-      if (specifier.startsWith("/") || specifier.startsWith(".")) return match;
-      return `from "/@modules/${specifier}"`;
+    /\bfrom\s+(['"])([^'"./][^'"]*)\1/g,
+    (match, quote, specifier) => {
+      return `from ${quote}/@modules/${specifier}${quote}`;
+    }
+  ).replace(
+    // 处理纯副作用导入: import 'bare-specifier'
+    /\bimport\s+(['"])([^'"./][^'"]*)\1/g,
+    (match, quote, specifier) => {
+      return `import ${quote}/@modules/${specifier}${quote}`;
     }
   ).replace(
-    /import\s+['"]([^'"./][^'"]*)['"]/g,
-    (match, specifier) => {
-      if (specifier.startsWith("/") || specifier.startsWith(".")) return match;
-      return `import "/@modules/${specifier}"`;
+    // 处理动态导入: import('bare-specifier')
+    /\bimport\s*\(\s*(['"])([^'"./][^'"]*)\1\s*\)/g,
+    (match, quote, specifier) => {
+      return `import(${quote}/@modules/${specifier}${quote})`;
     }
   );
 }
@@ -652,14 +774,13 @@ function resolveUrlToFile(url, root) {
   if (cleanUrl.startsWith("/@modules/")) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     try {
-      const { createRequire: createRequire2 } = require("module");
-      const req = createRequire2(import_node_path3.default.resolve(root, "package.json"));
+      const req = (0, import_node_module.createRequire)(import_node_path4.default.resolve(root, "package.json"));
       return req.resolve(moduleName);
     } catch {
       return null;
     }
   }
-  return import_node_path3.default.resolve(root, cleanUrl.replace(/^\//, ""));
+  return import_node_path4.default.resolve(root, cleanUrl.replace(/^\//, ""));
 }
 function isModuleRequest(url) {
   const cleanUrl = url.split("?")[0];
@@ -721,7 +842,18 @@ function showErrorOverlay(err) {
   const overlay = document.createElement('div');
   overlay.id = 'nasti-error-overlay';
   overlay.style.cssText = 'position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,0.85);color:#fff;font-family:monospace;padding:2rem;overflow:auto;';
-  overlay.innerHTML = \`<h2 style="color:#ff5555">Build Error</h2><pre>\${err.message}\\n\${err.stack || ''}</pre><button onclick="this.parentElement.remove()" style="margin-top:1rem;padding:0.5rem 1rem;cursor:pointer">Close</button>\`;
+  const title = document.createElement('h2');
+  title.style.color = '#ff5555';
+  title.textContent = 'Build Error';
+  const pre = document.createElement('pre');
+  pre.textContent = err.message + '\\n' + (err.stack || '');
+  const btn = document.createElement('button');
+  btn.style.cssText = 'margin-top:1rem;padding:0.5rem 1rem;cursor:pointer';
+  btn.textContent = 'Close';
+  btn.onclick = () => overlay.remove();
+  overlay.appendChild(title);
+  overlay.appendChild(pre);
+  overlay.appendChild(btn);
   document.body.appendChild(overlay);
 }
 
@@ -752,21 +884,23 @@ if (!window.__nasti_hot_map) window.__nasti_hot_map = new Map();
 window.__NASTI_HMR__ = { createHotContext };
 `;
 }
-var import_node_path3, import_node_fs3;
+var import_node_path4, import_node_fs4, import_node_module;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
-    import_node_path3 = __toESM(require("path"), 1);
-    import_node_fs3 = __toESM(require("fs"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
+    import_node_fs4 = __toESM(require("fs"), 1);
+    import_node_module = require("module");
     init_transformer();
     init_html();
+    init_env();
   }
 });
 
 // src/server/hmr.ts
 async function handleFileChange(file, server) {
   const { moduleGraph, ws, config } = server;
-  const relativePath = "/" + import_node_path4.default.relative(config.root, file);
+  const relativePath = "/" + import_node_path5.default.relative(config.root, file);
   const mods = moduleGraph.getModulesByFile(file);
   if (!mods || mods.size === 0) {
     return;
@@ -779,7 +913,7 @@ async function handleFileChange(file, server) {
       file,
       timestamp,
       modules: [mod],
-      read: () => import_node_fs4.default.readFileSync(file, "utf-8"),
+      read: () => import_node_fs5.default.readFileSync(file, "utf-8"),
       server
     };
     let affectedModules = [mod];
@@ -811,19 +945,19 @@ async function handleFileChange(file, server) {
     ws.send({ type: "update", updates });
   }
 }
-var import_node_path4, import_node_fs4;
+var import_node_path5, import_node_fs5;
 var init_hmr = __esm({
   "src/server/hmr.ts"() {
     "use strict";
-    import_node_path4 = __toESM(require("path"), 1);
-    import_node_fs4 = __toESM(require("fs"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
+    import_node_fs5 = __toESM(require("fs"), 1);
   }
 });
 
 // src/plugins/resolve.ts
 function resolvePlugin(config) {
   const { alias, extensions } = config.resolve;
-  const require2 = (0, import_node_module.createRequire)(import_node_path5.default.resolve(config.root, "package.json"));
+  const require2 = (0, import_node_module2.createRequire)(import_node_path6.default.resolve(config.root, "package.json"));
   return {
     name: "nasti:resolve",
     enforce: "pre",
@@ -831,26 +965,26 @@ function resolvePlugin(config) {
       for (const [key, value] of Object.entries(alias)) {
         if (source === key || source.startsWith(key + "/")) {
           source = source.replace(key, value);
-          if (!import_node_path5.default.isAbsolute(source)) {
-            source = import_node_path5.default.resolve(config.root, source);
+          if (!import_node_path6.default.isAbsolute(source)) {
+            source = import_node_path6.default.resolve(config.root, source);
           }
           break;
         }
       }
-      if (import_node_path5.default.isAbsolute(source)) {
+      if (import_node_path6.default.isAbsolute(source)) {
         const resolved = tryResolveFile(source, extensions);
         if (resolved) return resolved;
       }
       if (source.startsWith(".")) {
-        const dir = importer ? import_node_path5.default.dirname(importer) : config.root;
-        const absolute = import_node_path5.default.resolve(dir, source);
+        const dir = importer ? import_node_path6.default.dirname(importer) : config.root;
+        const absolute = import_node_path6.default.resolve(dir, source);
         const resolved = tryResolveFile(absolute, extensions);
         if (resolved) return resolved;
       }
       if (!source.startsWith("/") && !source.startsWith(".")) {
         try {
           const resolved = require2.resolve(source, {
-            paths: [importer ? import_node_path5.default.dirname(importer) : config.root]
+            paths: [importer ? import_node_path6.default.dirname(importer) : config.root]
           });
           return resolved;
         } catch {
@@ -860,40 +994,42 @@ function resolvePlugin(config) {
       return null;
     },
     load(id) {
-      if (import_node_fs5.default.existsSync(id)) {
-        return import_node_fs5.default.readFileSync(id, "utf-8");
+      if (!import_node_fs6.default.existsSync(id)) return null;
+      if (id.endsWith(".json")) {
+        const content = import_node_fs6.default.readFileSync(id, "utf-8");
+        return `export default ${content}`;
       }
-      return null;
+      return import_node_fs6.default.readFileSync(id, "utf-8");
     }
   };
 }
 function tryResolveFile(file, extensions) {
-  if (import_node_fs5.default.existsSync(file) && import_node_fs5.default.statSync(file).isFile()) {
+  if (import_node_fs6.default.existsSync(file) && import_node_fs6.default.statSync(file).isFile()) {
     return file;
   }
   for (const ext of extensions) {
     const withExt = file + ext;
-    if (import_node_fs5.default.existsSync(withExt) && import_node_fs5.default.statSync(withExt).isFile()) {
+    if (import_node_fs6.default.existsSync(withExt) && import_node_fs6.default.statSync(withExt).isFile()) {
       return withExt;
     }
   }
-  if (import_node_fs5.default.existsSync(file) && import_node_fs5.default.statSync(file).isDirectory()) {
+  if (import_node_fs6.default.existsSync(file) && import_node_fs6.default.statSync(file).isDirectory()) {
     for (const ext of extensions) {
-      const indexFile = import_node_path5.default.join(file, "index" + ext);
-      if (import_node_fs5.default.existsSync(indexFile)) {
+      const indexFile = import_node_path6.default.join(file, "index" + ext);
+      if (import_node_fs6.default.existsSync(indexFile)) {
         return indexFile;
       }
     }
   }
   return null;
 }
-var import_node_path5, import_node_fs5, import_node_module;
+var import_node_path6, import_node_fs6, import_node_module2;
 var init_resolve = __esm({
   "src/plugins/resolve.ts"() {
     "use strict";
-    import_node_path5 = __toESM(require("path"), 1);
-    import_node_fs5 = __toESM(require("fs"), 1);
-    import_node_module = require("module");
+    import_node_path6 = __toESM(require("path"), 1);
+    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_module2 = require("module");
   }
 });
 
@@ -907,13 +1043,17 @@ function cssPlugin(config) {
     },
     transform(code, id) {
       if (!id.endsWith(".css")) return null;
+      const rewritten = rewriteCssUrls(code, id, config.root);
       if (config.command === "serve") {
-        const escaped = JSON.stringify(code);
+        const escaped = JSON.stringify(rewritten);
         return {
           code: `
 const css = ${escaped};
+const __nasti_css_id__ = ${JSON.stringify(id)};
+const __nasti_existing__ = document.querySelector('style[data-nasti-css=' + JSON.stringify(__nasti_css_id__) + ']');
+if (__nasti_existing__) __nasti_existing__.remove();
 const style = document.createElement('style');
-style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
+style.setAttribute('data-nasti-css', __nasti_css_id__);
 style.textContent = css;
 document.head.appendChild(style);
 
@@ -929,15 +1069,25 @@ export default css;
 `
         };
       }
-      return null;
+      return rewritten !== code ? { code: rewritten } : null;
     }
   };
 }
-var import_node_path6;
+function rewriteCssUrls(css, from, root) {
+  return css.replace(/url\(\s*['"]?([^'")\s]+)['"]?\s*\)/g, (match, url) => {
+    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);
+    return `url(${relative})`;
+  });
+}
+var import_node_path7;
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
-    import_node_path6 = __toESM(require("path"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
   }
 });
 
@@ -952,24 +1102,24 @@ function assetsPlugin(config) {
       return null;
     },
     load(id) {
-      const ext = import_node_path7.default.extname(id.replace(/\?.*$/, ""));
+      const ext = import_node_path8.default.extname(id.replace(/\?.*$/, ""));
       if (id.endsWith("?raw")) {
         const file = id.slice(0, -4);
-        if (import_node_fs6.default.existsSync(file)) {
-          const content = import_node_fs6.default.readFileSync(file, "utf-8");
+        if (import_node_fs7.default.existsSync(file)) {
+          const content = import_node_fs7.default.readFileSync(file, "utf-8");
           return `export default ${JSON.stringify(content)}`;
         }
       }
       if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
         const file = id.replace(/\?.*$/, "");
-        if (!import_node_fs6.default.existsSync(file)) return null;
+        if (!import_node_fs7.default.existsSync(file)) return null;
         if (config.command === "serve") {
-          const url = "/" + import_node_path7.default.relative(config.root, file);
+          const url = "/" + import_node_path8.default.relative(config.root, file);
           return `export default ${JSON.stringify(url)}`;
         }
-        const content = import_node_fs6.default.readFileSync(file);
+        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_path7.default.basename(file, ext);
+        const basename = import_node_path8.default.basename(file, ext);
         const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
         return `export default ${JSON.stringify(config.base + hashedName)}`;
       }
@@ -977,12 +1127,12 @@ function assetsPlugin(config) {
     }
   };
 }
-var import_node_path7, import_node_fs6, import_node_crypto, ASSET_EXTENSIONS;
+var import_node_path8, import_node_fs7, import_node_crypto, ASSET_EXTENSIONS;
 var init_assets = __esm({
   "src/plugins/assets.ts"() {
     "use strict";
-    import_node_path7 = __toESM(require("path"), 1);
-    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
+    import_node_fs7 = __toESM(require("fs"), 1);
     import_node_crypto = __toESM(require("crypto"), 1);
     ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
       ".png",
@@ -1034,7 +1184,7 @@ async function createServer(inlineConfig = {}) {
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = import_node_path8.default.resolve(config.root, "public");
+  const publicDir = import_node_path9.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);
@@ -1111,8 +1261,7 @@ async function createServer(inlineConfig = {}) {
   return server;
 }
 function getNetworkAddress() {
-  const os = require("os");
-  const interfaces = os.networkInterfaces();
+  const interfaces = import_node_os.default.networkInterfaces();
   for (const name of Object.keys(interfaces)) {
     for (const iface of interfaces[name] ?? []) {
       if (iface.family === "IPv4" && !iface.internal) {
@@ -1122,12 +1271,13 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path8, import_connect, import_sirv, import_chokidar, import_picocolors;
+var import_node_http, import_node_path9, 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_path8 = __toESM(require("path"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
+    import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
     import_chokidar = require("chokidar");
@@ -1156,11 +1306,11 @@ async function build(inlineConfig = {}) {
   console.log(import_picocolors2.default.cyan("\n\u{1F528} nasti build") + import_picocolors2.default.dim(` v${process.env.npm_package_version ?? "0.0.1"}`));
   console.log(import_picocolors2.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors2.default.dim(`  mode: ${config.mode}`));
-  const outDir = import_node_path9.default.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && import_node_fs7.default.existsSync(outDir)) {
-    import_node_fs7.default.rmSync(outDir, { recursive: true, force: true });
+  const outDir = import_node_path10.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 });
   }
-  import_node_fs7.default.mkdirSync(outDir, { recursive: true });
+  import_node_fs8.default.mkdirSync(outDir, { recursive: true });
   const html = await readHtmlFile(config.root);
   let entryPoints = [];
   if (html) {
@@ -1168,15 +1318,15 @@ async function build(inlineConfig = {}) {
     for (const match of scriptMatches) {
       const src = match[1];
       if (src && !src.startsWith("http")) {
-        entryPoints.push(import_node_path9.default.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(import_node_path10.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_path9.default.resolve(config.root, entry);
-      if (import_node_fs7.default.existsSync(fullPath)) {
+      const fullPath = import_node_path10.default.resolve(config.root, entry);
+      if (import_node_fs8.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
       }
@@ -1191,6 +1341,8 @@ async function build(inlineConfig = {}) {
     assetsPlugin(config)
   ];
   const allPlugins = [...builtinPlugins, ...config.plugins];
+  const pluginContainer = new PluginContainer(config);
+  await pluginContainer.buildStart();
   const oxcTransformPlugin = {
     name: "nasti:oxc-transform",
     transform(code, id) {
@@ -1203,8 +1355,11 @@ async function build(inlineConfig = {}) {
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
+  const env = loadEnv(config.mode, config.root, config.envPrefix);
+  const envDefine = buildEnvDefine(env, config.mode);
   const bundle = await (0, import_rolldown.rolldown)({
     input: entryPoints,
+    define: envDefine,
     plugins: [
       oxcTransformPlugin,
       // 转换 Nasti 插件为 Rolldown 插件格式
@@ -1223,11 +1378,18 @@ async function build(inlineConfig = {}) {
     dir: outDir,
     format: "esm",
     sourcemap: !!config.build.sourcemap,
+    minify: !!config.build.minify,
     entryFileNames: "assets/[name].[hash].js",
     chunkFileNames: "assets/[name].[hash].js",
     assetFileNames: "assets/[name].[hash][extname]"
   });
   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 });
+    import_node_fs8.default.writeFileSync(dest, ef.source);
+  }
   if (html) {
     let processedHtml = html;
     const htmlPlugin_ = htmlPlugin(config);
@@ -1242,15 +1404,15 @@ async function build(inlineConfig = {}) {
       }
     }
     for (const chunk of output) {
-      if (chunk.type === "chunk" && chunk.isEntry) {
-        const originalEntry = import_node_path9.default.relative(config.root, entryPoints[0]);
+      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
+        const originalEntry = import_node_path10.default.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    import_node_fs7.default.writeFileSync(import_node_path9.default.resolve(outDir, "index.html"), processedHtml);
+    import_node_fs8.default.writeFileSync(import_node_path10.default.resolve(outDir, "index.html"), processedHtml);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   const totalSize = output.reduce((sum, chunk) => {
@@ -1272,12 +1434,12 @@ function formatSize(bytes) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_node_path9, import_node_fs7, import_rolldown, import_picocolors2;
+var import_node_path10, import_node_fs8, import_rolldown, import_picocolors2;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path9 = __toESM(require("path"), 1);
-    import_node_fs7 = __toESM(require("fs"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
+    import_node_fs8 = __toESM(require("fs"), 1);
     import_rolldown = require("rolldown");
     init_config();
     init_resolve();
@@ -1285,6 +1447,8 @@ var init_build = __esm({
     init_assets();
     init_html();
     init_transformer();
+    init_env();
+    init_plugin_container();
     import_picocolors2 = __toESM(require("picocolors"), 1);
   }
 });
@@ -1339,11 +1503,11 @@ cli.command("build [root]", "Build for production").option("--outDir <dir>", "Ou
 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 path10 = await import("path");
+    const path11 = await import("path");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
-    const resolvedRoot = path10.resolve(root ?? ".");
-    const outDir = path10.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path11.resolve(root ?? ".");
+    const outDir = path11.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;